diff --git a/.gitignore b/.gitignore
index c3b7e21496a53763ecaaa42956bc85bd4cf19b39..8cf2599eafc935ea880bcdb1762d44a7534f30c9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@ bin/
y.go
*.output
coverage.txt
+vendor/
diff --git a/cmd/db-server/main.go b/cmd/db-server/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..eb7f01ed0646a9e6318e129cdf04db10743cc2bd
--- /dev/null
+++ b/cmd/db-server/main.go
@@ -0,0 +1,88 @@
+package main
+
+import (
+ "context"
+ "flag"
+ "fmt"
+ "github.com/pingcap/parser/terror"
+ "matrixbase/pkg/config"
+ "matrixbase/pkg/server"
+ "matrixbase/pkg/util/signal"
+ "os"
+)
+
+const (
+ nmVersion = "V"
+ nmConfig = "config"
+ nmConfigCheck = "config-check"
+ nmConfigStrict = "config-strict"
+)
+
+var (
+ version = flagBoolean(nmVersion, false, "print version information and exit")
+ configPath = flag.String(nmConfig, "", "config file path")
+ configCheck = flagBoolean(nmConfigCheck, false, "check config file validity and exit")
+ configStrict = flagBoolean(nmConfigStrict, false, "enforce config file validity")
+)
+
+var (
+ svr *server.Server
+ graceful bool
+)
+
+func createServer() {
+ cfg := config.GetGlobalConfig()
+ driver := server.NewDBDriver()
+ var err error
+ svr, err = server.NewServer(cfg, driver)
+ terror.MustNil(err)
+}
+
+func runServer() {
+ err := svr.Run()
+ terror.MustNil(err)
+}
+
+func serverShutdown(isgraceful bool) {
+ if isgraceful {
+ graceful = true
+ }
+ svr.Close()
+}
+
+func registerSignalHandlers() {
+ signal.SetupSignalHandler(serverShutdown)
+}
+
+func cleanup() {
+ if graceful {
+ svr.GracefulDown(context.Background(), nil)
+ } else {
+ svr.TryGracefulDown()
+ }
+}
+
+func main() {
+ flag.Parse()
+ config.InitializeConfig(*configPath, *configCheck, *configStrict, reloadConfig, overrideConfig)
+ createServer()
+ registerSignalHandlers()
+ runServer()
+ cleanup()
+ os.Exit(0)
+}
+
+func flagBoolean(name string, defaultVal bool, usage string) *bool {
+ if !defaultVal {
+ // Fix #4125, golang do not print default false value in usage, so we append it.
+ usage = fmt.Sprintf("%s (default false)", usage)
+ return flag.Bool(name, defaultVal, usage)
+ }
+ return flag.Bool(name, defaultVal, usage)
+}
+
+func reloadConfig(nc, c *config.Config) {
+}
+
+func overrideConfig(cfg *config.Config) {
+}
diff --git a/cmd/parser-demo/checker.go b/cmd/parser-demo/checker.go
index 47563a9c4953182e17eea14d339df286e1f7198e..33931eb6dbb33eaf6b4efb90e73a5a660b4bba3b 100644
--- a/cmd/parser-demo/checker.go
+++ b/cmd/parser-demo/checker.go
@@ -1,8 +1,8 @@
package main
import (
+ "github.com/pingcap/parser/ast"
log "github.com/sirupsen/logrus"
- "matrixbase/pkg/parser/ast"
)
type checker struct {
@@ -20,7 +20,7 @@ func getDBFromResultNode(pos int, resultNode ast.ResultSetNode) []string {
return getDBFromResultNode(pos, node.Source)
case *ast.TableName:
log.Infof("[%d] GRN-TableName: %v", pos, node.Name)
- dbLables = append(dbLables, node.DBInfo.Name.O)
+ // dbLables = append(dbLables, node.DBInfo.Name.O)
case *ast.Join:
iter := func(x ast.ResultSetNode) {
if x != nil {
diff --git a/cmd/parser-demo/main.go b/cmd/parser-demo/main.go
index 00a203f23c437295d009292b2e95929a6dfe0e66..9e9e0686274663e2439cbb69f59e79f68171ed31 100644
--- a/cmd/parser-demo/main.go
+++ b/cmd/parser-demo/main.go
@@ -1,9 +1,9 @@
package main
import (
+ "github.com/pingcap/parser"
+ "github.com/pingcap/parser/ast"
log "github.com/sirupsen/logrus"
- "matrixbase/pkg/parser"
- "matrixbase/pkg/parser/ast"
_ "matrixbase/pkg/types/parser_driver"
)
diff --git a/go.mod b/go.mod
index f7a3aec1ab029c715e55606f9e53007d9dc7cf19..4316096d4a6f1a701e17ac52b36109496d7f8877 100644
--- a/go.mod
+++ b/go.mod
@@ -3,15 +3,23 @@ module matrixbase
go 1.15
require (
+ github.com/BurntSushi/toml v0.3.1
github.com/aws/aws-sdk-go v1.37.14
- github.com/klauspost/compress v1.11.7
+ github.com/blacktear23/go-proxyprotocol v0.0.0-20180807104634-af7a81e8dd0d
+ github.com/cznic/mathutil v0.0.0-20181122101859-297441e03548
github.com/frankban/quicktest v1.11.3 // indirect
- github.com/go-sql-driver/mysql v1.5.0
+ github.com/go-sql-driver/mysql v1.5.0 // indirect
+ github.com/klauspost/compress v1.11.7 // indirect
github.com/pierrec/lz4 v2.6.0+incompatible
github.com/pilosa/pilosa v1.4.0
+ github.com/pingcap/check v0.0.0-20190102082844-67f458068fc8
+ github.com/pingcap/errors v0.11.5-0.20201029093017-5a7df2af2ac7
+ github.com/pingcap/log v0.0.0-20200511115504-543df19646ad
+ github.com/pingcap/parser v0.0.0-20210310110710-c7333a4927e6
+ github.com/sirupsen/logrus v1.2.0
github.com/traetox/goaio v0.0.0-20171005222435-46641abceb17
go.uber.org/zap v1.15.0
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f
- golang.org/x/text v0.3.3
+ golang.org/x/text v0.3.3 // indirect
golang.org/x/tools v0.0.0-20201105001634-bc3cf281b174 // indirect
)
diff --git a/pkg/config/config.go b/pkg/config/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..a71d0bf61673dccded5885b2c2e52741ab0eb08e
--- /dev/null
+++ b/pkg/config/config.go
@@ -0,0 +1,312 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package config
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "os"
+ "path/filepath"
+ "strings"
+ "sync/atomic"
+
+ "github.com/BurntSushi/toml"
+ "github.com/pingcap/parser/mysql"
+)
+
+// Config number limitations
+const (
+ // DefPort is the default port
+ DefPort = 8800
+ // DefHost is the default host
+ DefHost = "0.0.0.0"
+)
+
+// ProxyProtocol is the PROXY protocol section of the config.
+type ProxyProtocol struct {
+ // PROXY protocol acceptable client networks.
+ // Empty string means disable PROXY protocol,
+ // * means all networks.
+ Networks string `toml:"networks" json:"networks"`
+ // PROXY protocol header read timeout, Unit is second.
+ HeaderTimeout uint `toml:"header-timeout" json:"header-timeout"`
+}
+
+// Config contains configuration options.
+type Config struct {
+ Host string `toml:"host" json:"host"`
+ Port uint `toml:"port" json:"port"`
+ Socket string `toml:"socket" json:"socket"`
+ ServerVersion string `toml:"server-version" json:"server-version"`
+ Security Security `toml:"security" json:"security"`
+ Performance Performance `toml:"performance" json:"performance"`
+ ProxyProtocol ProxyProtocol `toml:"proxy-protocol" json:"proxy-protocol"`
+ GracefulWaitBeforeShutdown int `toml:"graceful-wait-before-shutdown" json:"graceful-wait-before-shutdown"`
+ // EnableTCP4Only enables net.Listen("tcp4",...)
+ // Note that: it can make lvs with toa work and thus get real client ip.
+ EnableTCP4Only bool `toml:"enable-tcp4-only" json:"enable-tcp4-only"`
+ // MaxServerConnections is the maximum permitted number of simultaneous client connections.
+ MaxServerConnections uint32 `toml:"max-server-connections" json:"max-server-connections"`
+}
+
+// nullableBool defaults unset bool options to unset instead of false, which enables us to know if the user has set 2
+// conflict options at the same time.
+type nullableBool struct {
+ IsValid bool
+ IsTrue bool
+}
+
+var (
+ nbUnset = nullableBool{false, false}
+ nbFalse = nullableBool{true, false}
+ nbTrue = nullableBool{true, true}
+)
+
+func (b *nullableBool) toBool() bool {
+ return b.IsValid && b.IsTrue
+}
+
+func (b nullableBool) MarshalJSON() ([]byte, error) {
+ switch b {
+ case nbTrue:
+ return json.Marshal(true)
+ case nbFalse:
+ return json.Marshal(false)
+ default:
+ return json.Marshal(nil)
+ }
+}
+
+func (b *nullableBool) UnmarshalText(text []byte) error {
+ str := string(text)
+ switch str {
+ case "", "null":
+ *b = nbUnset
+ return nil
+ case "true":
+ *b = nbTrue
+ case "false":
+ *b = nbFalse
+ default:
+ *b = nbUnset
+ return errors.New("Invalid value for bool type: " + str)
+ }
+ return nil
+}
+
+func (b nullableBool) MarshalText() ([]byte, error) {
+ if !b.IsValid {
+ return []byte(""), nil
+ }
+ if b.IsTrue {
+ return []byte("true"), nil
+ }
+ return []byte("false"), nil
+}
+
+func (b *nullableBool) UnmarshalJSON(data []byte) error {
+ var err error
+ var v interface{}
+ if err = json.Unmarshal(data, &v); err != nil {
+ return err
+ }
+ switch raw := v.(type) {
+ case bool:
+ *b = nullableBool{true, raw}
+ default:
+ *b = nbUnset
+ }
+ return err
+}
+
+// The following constants represents the valid action configurations for Security.SpilledFileEncryptionMethod.
+// "plaintext" means encryption is disabled.
+// NOTE: Although the values is case insensitive, we should use lower-case
+// strings because the configuration value will be transformed to lower-case
+// string and compared with these constants in the further usage.
+const (
+ SpilledFileEncryptionMethodPlaintext = "plaintext"
+ SpilledFileEncryptionMethodAES128CTR = "aes128-ctr"
+)
+
+// Security is the security section of the config.
+type Security struct {
+ SkipGrantTable bool `toml:"skip-grant-table" json:"skip-grant-table"`
+ SSLCA string `toml:"ssl-ca" json:"ssl-ca"`
+ SSLCert string `toml:"ssl-cert" json:"ssl-cert"`
+ SSLKey string `toml:"ssl-key" json:"ssl-key"`
+ RequireSecureTransport bool `toml:"require-secure-transport" json:"require-secure-transport"`
+ ClusterSSLCA string `toml:"cluster-ssl-ca" json:"cluster-ssl-ca"`
+ ClusterSSLCert string `toml:"cluster-ssl-cert" json:"cluster-ssl-cert"`
+ ClusterSSLKey string `toml:"cluster-ssl-key" json:"cluster-ssl-key"`
+ ClusterVerifyCN []string `toml:"cluster-verify-cn" json:"cluster-verify-cn"`
+ // If set to "plaintext", the spilled files will not be encrypted.
+ SpilledFileEncryptionMethod string `toml:"spilled-file-encryption-method" json:"spilled-file-encryption-method"`
+}
+
+// Performance is the performance section of the config.
+type Performance struct {
+ TCPKeepAlive bool `toml:"tcp-keep-alive" json:"tcp-keep-alive"`
+}
+
+// The ErrConfigValidationFailed error is used so that external callers can do a type assertion
+// to defer handling of this specific error when someone does not want strict type checking.
+// This is needed only because logging hasn't been set up at the time we parse the config file.
+// This should all be ripped out once strict config checking is made the default behavior.
+type ErrConfigValidationFailed struct {
+ confFile string
+ UndecodedItems []string
+}
+
+func (e *ErrConfigValidationFailed) Error() string {
+ return fmt.Sprintf("config file %s contained invalid configuration options: %s; check "+
+ "manual to make sure this option has not been deprecated and removed from your server "+
+ "version if the option does not appear to be a typo", e.confFile, strings.Join(
+ e.UndecodedItems, ", "))
+
+}
+
+var defaultConf = Config{
+ Host: DefHost,
+ Port: DefPort,
+ ServerVersion: "",
+ Security: Security{
+ SpilledFileEncryptionMethod: SpilledFileEncryptionMethodPlaintext,
+ },
+}
+
+var (
+ globalConf atomic.Value
+)
+
+// NewConfig creates a new config instance with default value.
+func NewConfig() *Config {
+ conf := defaultConf
+ return &conf
+}
+
+// GetGlobalConfig returns the global configuration for this server.
+// It should store configuration from command line and configuration file.
+// Other parts of the system can read the global configuration use this function.
+func GetGlobalConfig() *Config {
+ return globalConf.Load().(*Config)
+}
+
+// StoreGlobalConfig stores a new config to the globalConf. It mostly uses in the test to avoid some data races.
+func StoreGlobalConfig(config *Config) {
+ globalConf.Store(config)
+}
+
+// InitializeConfig initialize the global config handler.
+// The function enforceCmdArgs is used to merge the config file with command arguments:
+// For example, if you start by the command "./server --port=3000", the port number should be
+// overwritten to 3000 and ignore the port number in the config file.
+func InitializeConfig(confPath string, configCheck, configStrict bool, reloadFunc ConfReloadFunc, enforceCmdArgs func(*Config)) {
+ cfg := GetGlobalConfig()
+ var err error
+ if confPath != "" {
+ if err = cfg.Load(confPath); err != nil {
+ // Unused config item error turns to warnings.
+ if _, ok := err.(*ErrConfigValidationFailed); ok {
+ if !configCheck && !configStrict {
+ fmt.Fprintln(os.Stderr, err.Error())
+ err = nil
+ }
+ }
+ }
+
+ panic(err)
+ } else {
+ // configCheck should have the config file specified.
+ if configCheck {
+ fmt.Fprintln(os.Stderr, "config check failed", errors.New("no config file specified for config-check"))
+ os.Exit(1)
+ }
+ }
+ enforceCmdArgs(cfg)
+
+ if err := cfg.Valid(); err != nil {
+ if !filepath.IsAbs(confPath) {
+ if tmp, err := filepath.Abs(confPath); err == nil {
+ confPath = tmp
+ }
+ }
+ fmt.Fprintln(os.Stderr, "load config file:", confPath)
+ fmt.Fprintln(os.Stderr, "invalid config", err)
+ os.Exit(1)
+ }
+ if configCheck {
+ fmt.Println("config check successful")
+ os.Exit(0)
+ }
+ StoreGlobalConfig(cfg)
+}
+
+// Load loads config options from a toml file.
+func (c *Config) Load(confFile string) error {
+ metaData, err := toml.DecodeFile(confFile, c)
+ if len(c.ServerVersion) > 0 {
+ mysql.ServerVersion = c.ServerVersion
+ }
+ // If any items in confFile file are not mapped into the Config struct, issue
+ // an error and stop the server from starting.
+ undecoded := metaData.Undecoded()
+ if len(undecoded) > 0 && err == nil {
+ var undecodedItems []string
+ for _, item := range undecoded {
+ undecodedItems = append(undecodedItems, item.String())
+ }
+ err = &ErrConfigValidationFailed{confFile, undecodedItems}
+ }
+
+ return err
+}
+
+// Valid checks if this config is valid.
+func (c *Config) Valid() error {
+ if c.Security.SkipGrantTable && !hasRootPrivilege() {
+ return fmt.Errorf("Run with skip-grant-table need root privilege")
+ }
+ return nil
+}
+
+// UpdateGlobal updates the global config, and provide a restore function that can be used to restore to the original.
+func UpdateGlobal(f func(conf *Config)) {
+ g := GetGlobalConfig()
+ newConf := *g
+ f(&newConf)
+ StoreGlobalConfig(&newConf)
+}
+
+// RestoreFunc gets a function that restore the config to the current value.
+func RestoreFunc() (restore func()) {
+ g := GetGlobalConfig()
+ return func() {
+ StoreGlobalConfig(g)
+ }
+}
+
+func hasRootPrivilege() bool {
+ return os.Geteuid() == 0
+}
+
+func init() {
+ initByLDFlags()
+}
+
+func initByLDFlags() {
+ conf := defaultConf
+ StoreGlobalConfig(&conf)
+}
diff --git a/pkg/config/config_util.go b/pkg/config/config_util.go
new file mode 100644
index 0000000000000000000000000000000000000000..6922437cf1bcbd71bc2a740d8f20fb976a3380f9
--- /dev/null
+++ b/pkg/config/config_util.go
@@ -0,0 +1,156 @@
+// Copyright 2020 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package config
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "reflect"
+ "time"
+
+ "github.com/BurntSushi/toml"
+ "github.com/pingcap/errors"
+)
+
+// CloneConf deeply clones this config.
+func CloneConf(conf *Config) (*Config, error) {
+ content, err := json.Marshal(conf)
+ if err != nil {
+ return nil, err
+ }
+ var clonedConf Config
+ if err := json.Unmarshal(content, &clonedConf); err != nil {
+ return nil, err
+ }
+ return &clonedConf, nil
+}
+
+var (
+ // dynamicConfigItems contains all config items that can be changed during runtime.
+ dynamicConfigItems = map[string]struct{}{
+ "Performance.MaxProcs": {},
+ "Performance.MaxMemory": {},
+ "Performance.CrossJoin": {},
+ "Performance.FeedbackProbability": {},
+ "Performance.QueryFeedbackLimit": {},
+ "Performance.PseudoEstimateRatio": {},
+ "Performance.StmtCountLimit": {},
+ "Performance.TCPKeepAlive": {},
+ "OOMAction": {},
+ "MemQuotaQuery": {},
+ "TiKVClient.StoreLimit": {},
+ "Log.Level": {},
+ "Log.SlowThreshold": {},
+ "Log.QueryLogMaxLen": {},
+ "Log.ExpensiveThreshold": {},
+ "CheckMb4ValueInUTF8": {},
+ "EnableStreaming": {},
+ "TxnLocalLatches.Capacity": {},
+ "CompatibleKillQuery": {},
+ "TreatOldVersionUTF8AsUTF8MB4": {},
+ "OpenTracing.Enable": {},
+ "PreparedPlanCache.Enabled": {},
+ }
+)
+
+// MergeConfigItems overwrites the dynamic config items and leaves the other items unchanged.
+func MergeConfigItems(dstConf, newConf *Config) (acceptedItems, rejectedItems []string) {
+ return mergeConfigItems(reflect.ValueOf(dstConf), reflect.ValueOf(newConf), "")
+}
+
+func mergeConfigItems(dstConf, newConf reflect.Value, fieldPath string) (acceptedItems, rejectedItems []string) {
+ t := dstConf.Type()
+ if t.Kind() == reflect.Ptr {
+ t = t.Elem()
+ dstConf = dstConf.Elem()
+ newConf = newConf.Elem()
+ }
+ if t.Kind() != reflect.Struct {
+ if reflect.DeepEqual(dstConf.Interface(), newConf.Interface()) {
+ return
+ }
+ if _, ok := dynamicConfigItems[fieldPath]; ok {
+ dstConf.Set(newConf)
+ return []string{fieldPath}, nil
+ }
+ return nil, []string{fieldPath}
+ }
+
+ for i := 0; i < t.NumField(); i++ {
+ fieldName := t.Field(i).Name
+ if fieldPath != "" {
+ fieldName = fieldPath + "." + fieldName
+ }
+ as, rs := mergeConfigItems(dstConf.Field(i), newConf.Field(i), fieldName)
+ acceptedItems = append(acceptedItems, as...)
+ rejectedItems = append(rejectedItems, rs...)
+ }
+ return
+}
+
+func atomicWriteConfig(c *Config, confPath string) (err error) {
+ content, err := encodeConfig(c)
+ if err != nil {
+ return err
+ }
+ tmpConfPath := filepath.Join(os.TempDir(), fmt.Sprintf("tmp_conf_%v.toml", time.Now().Format("20060102150405")))
+ if err := ioutil.WriteFile(tmpConfPath, []byte(content), 0666); err != nil {
+ return errors.Trace(err)
+ }
+ return errors.Trace(os.Rename(tmpConfPath, confPath))
+}
+
+// ConfReloadFunc is used to reload the config to make it work.
+type ConfReloadFunc func(oldConf, newConf *Config)
+
+func encodeConfig(conf *Config) (string, error) {
+ confBuf := bytes.NewBuffer(nil)
+ te := toml.NewEncoder(confBuf)
+ if err := te.Encode(conf); err != nil {
+ return "", errors.New("encode config error=" + err.Error())
+ }
+ return confBuf.String(), nil
+}
+
+func decodeConfig(content string) (*Config, error) {
+ c := new(Config)
+ _, err := toml.Decode(content, c)
+ return c, err
+}
+
+// FlattenConfigItems flatten this config, see more cases in the test.
+func FlattenConfigItems(nestedConfig map[string]interface{}) map[string]interface{} {
+ flatMap := make(map[string]interface{})
+ flatten(flatMap, nestedConfig, "")
+ return flatMap
+}
+
+func flatten(flatMap map[string]interface{}, nested interface{}, prefix string) {
+ switch nested.(type) {
+ case map[string]interface{}:
+ for k, v := range nested.(map[string]interface{}) {
+ path := k
+ if prefix != "" {
+ path = prefix + "." + k
+ }
+ flatten(flatMap, v, path)
+ }
+ default: // don't flatten arrays
+ flatMap[prefix] = nested
+ }
+}
diff --git a/pkg/errno/errcode.go b/pkg/errno/errcode.go
new file mode 100644
index 0000000000000000000000000000000000000000..edba326e78fc80ff6cd80d2ffda469ef76473436
--- /dev/null
+++ b/pkg/errno/errcode.go
@@ -0,0 +1,1036 @@
+package errno
+
+// MySQL error code.
+// This value is numeric. It is not portable to other database systems.
+const (
+ ErrErrorFirst = 1000
+ ErrHashchk = 1000
+ ErrNisamchk = 1001
+ ErrNo = 1002
+ ErrYes = 1003
+ ErrCantCreateFile = 1004
+ ErrCantCreateTable = 1005
+ ErrCantCreateDB = 1006
+ ErrDBCreateExists = 1007
+ ErrDBDropExists = 1008
+ ErrDBDropDelete = 1009
+ ErrDBDropRmdir = 1010
+ ErrCantDeleteFile = 1011
+ ErrCantFindSystemRec = 1012
+ ErrCantGetStat = 1013
+ ErrCantGetWd = 1014
+ ErrCantLock = 1015
+ ErrCantOpenFile = 1016
+ ErrFileNotFound = 1017
+ ErrCantReadDir = 1018
+ ErrCantSetWd = 1019
+ ErrCheckread = 1020
+ ErrDiskFull = 1021
+ ErrDupKey = 1022
+ ErrErrorOnClose = 1023
+ ErrErrorOnRead = 1024
+ ErrErrorOnRename = 1025
+ ErrErrorOnWrite = 1026
+ ErrFileUsed = 1027
+ ErrFilsortAbort = 1028
+ ErrFormNotFound = 1029
+ ErrGetErrno = 1030
+ ErrIllegalHa = 1031
+ ErrKeyNotFound = 1032
+ ErrNotFormFile = 1033
+ ErrNotKeyFile = 1034
+ ErrOldKeyFile = 1035
+ ErrOpenAsReadonly = 1036
+ ErrOutofMemory = 1037
+ ErrOutOfSortMemory = 1038
+ ErrUnexpectedEOF = 1039
+ ErrConCount = 1040
+ ErrOutOfResources = 1041
+ ErrBadHost = 1042
+ ErrHandshake = 1043
+ ErrDBaccessDenied = 1044
+ ErrAccessDenied = 1045
+ ErrNoDB = 1046
+ ErrUnknownCom = 1047
+ ErrBadNull = 1048
+ ErrBadDB = 1049
+ ErrTableExists = 1050
+ ErrBadTable = 1051
+ ErrNonUniq = 1052
+ ErrServerShutdown = 1053
+ ErrBadField = 1054
+ ErrFieldNotInGroupBy = 1055
+ ErrWrongGroupField = 1056
+ ErrWrongSumSelect = 1057
+ ErrWrongValueCount = 1058
+ ErrTooLongIdent = 1059
+ ErrDupFieldName = 1060
+ ErrDupKeyName = 1061
+ ErrDupEntry = 1062
+ ErrWrongFieldSpec = 1063
+ ErrParse = 1064
+ ErrEmptyQuery = 1065
+ ErrNonuniqTable = 1066
+ ErrInvalidDefault = 1067
+ ErrMultiplePriKey = 1068
+ ErrTooManyKeys = 1069
+ ErrTooManyKeyParts = 1070
+ ErrTooLongKey = 1071
+ ErrKeyColumnDoesNotExits = 1072
+ ErrBlobUsedAsKey = 1073
+ ErrTooBigFieldlength = 1074
+ ErrWrongAutoKey = 1075
+ ErrReady = 1076
+ ErrNormalShutdown = 1077
+ ErrGotSignal = 1078
+ ErrShutdownComplete = 1079
+ ErrForcingClose = 1080
+ ErrIpsock = 1081
+ ErrNoSuchIndex = 1082
+ ErrWrongFieldTerminators = 1083
+ ErrBlobsAndNoTerminated = 1084
+ ErrTextFileNotReadable = 1085
+ ErrFileExists = 1086
+ ErrLoadInfo = 1087
+ ErrAlterInfo = 1088
+ ErrWrongSubKey = 1089
+ ErrCantRemoveAllFields = 1090
+ ErrCantDropFieldOrKey = 1091
+ ErrInsertInfo = 1092
+ ErrUpdateTableUsed = 1093
+ ErrNoSuchThread = 1094
+ ErrKillDenied = 1095
+ ErrNoTablesUsed = 1096
+ ErrTooBigSet = 1097
+ ErrNoUniqueLogFile = 1098
+ ErrTableNotLockedForWrite = 1099
+ ErrTableNotLocked = 1100
+ ErrBlobCantHaveDefault = 1101
+ ErrWrongDBName = 1102
+ ErrWrongTableName = 1103
+ ErrTooBigSelect = 1104
+ ErrUnknown = 1105
+ ErrUnknownProcedure = 1106
+ ErrWrongParamcountToProcedure = 1107
+ ErrWrongParametersToProcedure = 1108
+ ErrUnknownTable = 1109
+ ErrFieldSpecifiedTwice = 1110
+ ErrInvalidGroupFuncUse = 1111
+ ErrUnsupportedExtension = 1112
+ ErrTableMustHaveColumns = 1113
+ ErrRecordFileFull = 1114
+ ErrUnknownCharacterSet = 1115
+ ErrTooManyTables = 1116
+ ErrTooManyFields = 1117
+ ErrTooBigRowsize = 1118
+ ErrStackOverrun = 1119
+ ErrWrongOuterJoin = 1120
+ ErrNullColumnInIndex = 1121
+ ErrCantFindUdf = 1122
+ ErrCantInitializeUdf = 1123
+ ErrUdfNoPaths = 1124
+ ErrUdfExists = 1125
+ ErrCantOpenLibrary = 1126
+ ErrCantFindDlEntry = 1127
+ ErrFunctionNotDefined = 1128
+ ErrHostIsBlocked = 1129
+ ErrHostNotPrivileged = 1130
+ ErrPasswordAnonymousUser = 1131
+ ErrPasswordNotAllowed = 1132
+ ErrPasswordNoMatch = 1133
+ ErrUpdateInfo = 1134
+ ErrCantCreateThread = 1135
+ ErrWrongValueCountOnRow = 1136
+ ErrCantReopenTable = 1137
+ ErrInvalidUseOfNull = 1138
+ ErrRegexp = 1139
+ ErrMixOfGroupFuncAndFields = 1140
+ ErrNonexistingGrant = 1141
+ ErrTableaccessDenied = 1142
+ ErrColumnaccessDenied = 1143
+ ErrIllegalGrantForTable = 1144
+ ErrGrantWrongHostOrUser = 1145
+ ErrNoSuchTable = 1146
+ ErrNonexistingTableGrant = 1147
+ ErrNotAllowedCommand = 1148
+ ErrSyntax = 1149
+ ErrDelayedCantChangeLock = 1150
+ ErrTooManyDelayedThreads = 1151
+ ErrAbortingConnection = 1152
+ ErrNetPacketTooLarge = 1153
+ ErrNetReadErrorFromPipe = 1154
+ ErrNetFcntl = 1155
+ ErrNetPacketsOutOfOrder = 1156
+ ErrNetUncompress = 1157
+ ErrNetRead = 1158
+ ErrNetReadInterrupted = 1159
+ ErrNetErrorOnWrite = 1160
+ ErrNetWriteInterrupted = 1161
+ ErrTooLongString = 1162
+ ErrTableCantHandleBlob = 1163
+ ErrTableCantHandleAutoIncrement = 1164
+ ErrDelayedInsertTableLocked = 1165
+ ErrWrongColumnName = 1166
+ ErrWrongKeyColumn = 1167
+ ErrWrongMrgTable = 1168
+ ErrDupUnique = 1169
+ ErrBlobKeyWithoutLength = 1170
+ ErrPrimaryCantHaveNull = 1171
+ ErrTooManyRows = 1172
+ ErrRequiresPrimaryKey = 1173
+ ErrNoRaidCompiled = 1174
+ ErrUpdateWithoutKeyInSafeMode = 1175
+ ErrKeyDoesNotExist = 1176
+ ErrCheckNoSuchTable = 1177
+ ErrCheckNotImplemented = 1178
+ ErrCantDoThisDuringAnTransaction = 1179
+ ErrErrorDuringCommit = 1180
+ ErrErrorDuringRollback = 1181
+ ErrErrorDuringFlushLogs = 1182
+ ErrErrorDuringCheckpoint = 1183
+ ErrNewAbortingConnection = 1184
+ ErrDumpNotImplemented = 1185
+ ErrIndexRebuild = 1187
+ ErrFtMatchingKeyNotFound = 1191
+ ErrLockOrActiveTransaction = 1192
+ ErrUnknownSystemVariable = 1193
+ ErrCrashedOnUsage = 1194
+ ErrCrashedOnRepair = 1195
+ ErrWarningNotCompleteRollback = 1196
+ ErrTransCacheFull = 1197
+ ErrTooManyUserConnections = 1203
+ ErrSetConstantsOnly = 1204
+ ErrLockWaitTimeout = 1205
+ ErrLockTableFull = 1206
+ ErrReadOnlyTransaction = 1207
+ ErrDropDBWithReadLock = 1208
+ ErrCreateDBWithReadLock = 1209
+ ErrWrongArguments = 1210
+ ErrNoPermissionToCreateUser = 1211
+ ErrUnionTablesInDifferentDir = 1212
+ ErrLockDeadlock = 1213
+ ErrTableCantHandleFt = 1214
+ ErrCannotAddForeign = 1215
+ ErrNoReferencedRow = 1216
+ ErrRowIsReferenced = 1217
+ ErrErrorWhenExecutingCommand = 1220
+ ErrWrongUsage = 1221
+ ErrWrongNumberOfColumnsInSelect = 1222
+ ErrCantUpdateWithReadlock = 1223
+ ErrMixingNotAllowed = 1224
+ ErrDupArgument = 1225
+ ErrUserLimitReached = 1226
+ ErrSpecificAccessDenied = 1227
+ ErrLocalVariable = 1228
+ ErrGlobalVariable = 1229
+ ErrNoDefault = 1230
+ ErrWrongValueForVar = 1231
+ ErrWrongTypeForVar = 1232
+ ErrVarCantBeRead = 1233
+ ErrCantUseOptionHere = 1234
+ ErrNotSupportedYet = 1235
+ ErrIncorrectGlobalLocalVar = 1238
+ ErrWrongFkDef = 1239
+ ErrKeyRefDoNotMatchTableRef = 1240
+ ErrOperandColumns = 1241
+ ErrSubqueryNo1Row = 1242
+ ErrUnknownStmtHandler = 1243
+ ErrCorruptHelpDB = 1244
+ ErrCyclicReference = 1245
+ ErrAutoConvert = 1246
+ ErrIllegalReference = 1247
+ ErrDerivedMustHaveAlias = 1248
+ ErrSelectReduced = 1249
+ ErrTablenameNotAllowedHere = 1250
+ ErrNotSupportedAuthMode = 1251
+ ErrSpatialCantHaveNull = 1252
+ ErrCollationCharsetMismatch = 1253
+ ErrTooBigForUncompress = 1256
+ ErrZlibZMem = 1257
+ ErrZlibZBuf = 1258
+ ErrZlibZData = 1259
+ ErrCutValueGroupConcat = 1260
+ ErrWarnTooFewRecords = 1261
+ ErrWarnTooManyRecords = 1262
+ ErrWarnNullToNotnull = 1263
+ ErrWarnDataOutOfRange = 1264
+ WarnDataTruncated = 1265
+ ErrWarnUsingOtherHandler = 1266
+ ErrCantAggregate2collations = 1267
+ ErrDropUser = 1268
+ ErrRevokeGrants = 1269
+ ErrCantAggregate3collations = 1270
+ ErrCantAggregateNcollations = 1271
+ ErrVariableIsNotStruct = 1272
+ ErrUnknownCollation = 1273
+ ErrServerIsInSecureAuthMode = 1275
+ ErrWarnFieldResolved = 1276
+ ErrUntilCondIgnored = 1279
+ ErrWrongNameForIndex = 1280
+ ErrWrongNameForCatalog = 1281
+ ErrWarnQcResize = 1282
+ ErrBadFtColumn = 1283
+ ErrUnknownKeyCache = 1284
+ ErrWarnHostnameWontWork = 1285
+ ErrUnknownStorageEngine = 1286
+ ErrWarnDeprecatedSyntax = 1287
+ ErrNonUpdatableTable = 1288
+ ErrFeatureDisabled = 1289
+ ErrOptionPreventsStatement = 1290
+ ErrDuplicatedValueInType = 1291
+ ErrTruncatedWrongValue = 1292
+ ErrTooMuchAutoTimestampCols = 1293
+ ErrInvalidOnUpdate = 1294
+ ErrUnsupportedPs = 1295
+ ErrGetErrmsg = 1296
+ ErrGetTemporaryErrmsg = 1297
+ ErrUnknownTimeZone = 1298
+ ErrWarnInvalidTimestamp = 1299
+ ErrInvalidCharacterString = 1300
+ ErrWarnAllowedPacketOverflowed = 1301
+ ErrConflictingDeclarations = 1302
+ ErrSpNoRecursiveCreate = 1303
+ ErrSpAlreadyExists = 1304
+ ErrSpDoesNotExist = 1305
+ ErrSpDropFailed = 1306
+ ErrSpStoreFailed = 1307
+ ErrSpLilabelMismatch = 1308
+ ErrSpLabelRedefine = 1309
+ ErrSpLabelMismatch = 1310
+ ErrSpUninitVar = 1311
+ ErrSpBadselect = 1312
+ ErrSpBadreturn = 1313
+ ErrSpBadstatement = 1314
+ ErrUpdateLogDeprecatedIgnored = 1315
+ ErrUpdateLogDeprecatedTranslated = 1316
+ ErrQueryInterrupted = 1317
+ ErrSpWrongNoOfArgs = 1318
+ ErrSpCondMismatch = 1319
+ ErrSpNoreturn = 1320
+ ErrSpNoreturnend = 1321
+ ErrSpBadCursorQuery = 1322
+ ErrSpBadCursorSelect = 1323
+ ErrSpCursorMismatch = 1324
+ ErrSpCursorAlreadyOpen = 1325
+ ErrSpCursorNotOpen = 1326
+ ErrSpUndeclaredVar = 1327
+ ErrSpWrongNoOfFetchArgs = 1328
+ ErrSpFetchNoData = 1329
+ ErrSpDupParam = 1330
+ ErrSpDupVar = 1331
+ ErrSpDupCond = 1332
+ ErrSpDupCurs = 1333
+ ErrSpCantAlter = 1334
+ ErrSpSubselectNyi = 1335
+ ErrStmtNotAllowedInSfOrTrg = 1336
+ ErrSpVarcondAfterCurshndlr = 1337
+ ErrSpCursorAfterHandler = 1338
+ ErrSpCaseNotFound = 1339
+ ErrFparserTooBigFile = 1340
+ ErrFparserBadHeader = 1341
+ ErrFparserEOFInComment = 1342
+ ErrFparserErrorInParameter = 1343
+ ErrFparserEOFInUnknownParameter = 1344
+ ErrViewNoExplain = 1345
+ ErrFrmUnknownType = 1346
+ ErrWrongObject = 1347
+ ErrNonupdateableColumn = 1348
+ ErrViewSelectDerived = 1349
+ ErrViewSelectClause = 1350
+ ErrViewSelectVariable = 1351
+ ErrViewSelectTmptable = 1352
+ ErrViewWrongList = 1353
+ ErrWarnViewMerge = 1354
+ ErrWarnViewWithoutKey = 1355
+ ErrViewInvalid = 1356
+ ErrSpNoDropSp = 1357
+ ErrSpGotoInHndlr = 1358
+ ErrTrgAlreadyExists = 1359
+ ErrTrgDoesNotExist = 1360
+ ErrTrgOnViewOrTempTable = 1361
+ ErrTrgCantChangeRow = 1362
+ ErrTrgNoSuchRowInTrg = 1363
+ ErrNoDefaultForField = 1364
+ ErrDivisionByZero = 1365
+ ErrTruncatedWrongValueForField = 1366
+ ErrIllegalValueForType = 1367
+ ErrViewNonupdCheck = 1368
+ ErrViewCheckFailed = 1369
+ ErrProcaccessDenied = 1370
+ ErrRelayLogFail = 1371
+ ErrPasswdLength = 1372
+ ErrUnknownTargetBinlog = 1373
+ ErrIoErrLogIndexRead = 1374
+ ErrBinlogPurgeProhibited = 1375
+ ErrFseekFail = 1376
+ ErrBinlogPurgeFatalErr = 1377
+ ErrLogInUse = 1378
+ ErrLogPurgeUnknownErr = 1379
+ ErrRelayLogInit = 1380
+ ErrNoBinaryLogging = 1381
+ ErrReservedSyntax = 1382
+ ErrWsasFailed = 1383
+ ErrDiffGroupsProc = 1384
+ ErrNoGroupForProc = 1385
+ ErrOrderWithProc = 1386
+ ErrLoggingProhibitChangingOf = 1387
+ ErrNoFileMapping = 1388
+ ErrWrongMagic = 1389
+ ErrPsManyParam = 1390
+ ErrKeyPart0 = 1391
+ ErrViewChecksum = 1392
+ ErrViewMultiupdate = 1393
+ ErrViewNoInsertFieldList = 1394
+ ErrViewDeleteMergeView = 1395
+ ErrCannotUser = 1396
+ ErrXaerNota = 1397
+ ErrXaerInval = 1398
+ ErrXaerRmfail = 1399
+ ErrXaerOutside = 1400
+ ErrXaerRmerr = 1401
+ ErrXaRbrollback = 1402
+ ErrNonexistingProcGrant = 1403
+ ErrProcAutoGrantFail = 1404
+ ErrProcAutoRevokeFail = 1405
+ ErrDataTooLong = 1406
+ ErrSpBadSQLstate = 1407
+ ErrStartup = 1408
+ ErrLoadFromFixedSizeRowsToVar = 1409
+ ErrCantCreateUserWithGrant = 1410
+ ErrWrongValueForType = 1411
+ ErrTableDefChanged = 1412
+ ErrSpDupHandler = 1413
+ ErrSpNotVarArg = 1414
+ ErrSpNoRetset = 1415
+ ErrCantCreateGeometryObject = 1416
+ ErrFailedRoutineBreakBinlog = 1417
+ ErrBinlogUnsafeRoutine = 1418
+ ErrBinlogCreateRoutineNeedSuper = 1419
+ ErrExecStmtWithOpenCursor = 1420
+ ErrStmtHasNoOpenCursor = 1421
+ ErrCommitNotAllowedInSfOrTrg = 1422
+ ErrNoDefaultForViewField = 1423
+ ErrSpNoRecursion = 1424
+ ErrTooBigScale = 1425
+ ErrTooBigPrecision = 1426
+ ErrMBiggerThanD = 1427
+ ErrWrongLockOfSystemTable = 1428
+ ErrConnectToForeignDataSource = 1429
+ ErrQueryOnForeignDataSource = 1430
+ ErrForeignDataSourceDoesntExist = 1431
+ ErrForeignDataStringInvalidCantCreate = 1432
+ ErrForeignDataStringInvalid = 1433
+ ErrCantCreateFederatedTable = 1434
+ ErrTrgInWrongSchema = 1435
+ ErrStackOverrunNeedMore = 1436
+ ErrTooLongBody = 1437
+ ErrWarnCantDropDefaultKeycache = 1438
+ ErrTooBigDisplaywidth = 1439
+ ErrXaerDupid = 1440
+ ErrDatetimeFunctionOverflow = 1441
+ ErrCantUpdateUsedTableInSfOrTrg = 1442
+ ErrViewPreventUpdate = 1443
+ ErrPsNoRecursion = 1444
+ ErrSpCantSetAutocommit = 1445
+ ErrMalformedDefiner = 1446
+ ErrViewFrmNoUser = 1447
+ ErrViewOtherUser = 1448
+ ErrNoSuchUser = 1449
+ ErrForbidSchemaChange = 1450
+ ErrRowIsReferenced2 = 1451
+ ErrNoReferencedRow2 = 1452
+ ErrSpBadVarShadow = 1453
+ ErrTrgNoDefiner = 1454
+ ErrOldFileFormat = 1455
+ ErrSpRecursionLimit = 1456
+ ErrSpProcTableCorrupt = 1457
+ ErrSpWrongName = 1458
+ ErrTableNeedsUpgrade = 1459
+ ErrSpNoAggregate = 1460
+ ErrMaxPreparedStmtCountReached = 1461
+ ErrViewRecursive = 1462
+ ErrNonGroupingFieldUsed = 1463
+ ErrTableCantHandleSpkeys = 1464
+ ErrNoTriggersOnSystemSchema = 1465
+ ErrRemovedSpaces = 1466
+ ErrAutoincReadFailed = 1467
+ ErrUsername = 1468
+ ErrHostname = 1469
+ ErrWrongStringLength = 1470
+ ErrNonInsertableTable = 1471
+ ErrAdminWrongMrgTable = 1472
+ ErrTooHighLevelOfNestingForSelect = 1473
+ ErrNameBecomesEmpty = 1474
+ ErrAmbiguousFieldTerm = 1475
+ ErrForeignServerExists = 1476
+ ErrForeignServerDoesntExist = 1477
+ ErrIllegalHaCreateOption = 1478
+ ErrPartitionRequiresValues = 1479
+ ErrPartitionWrongValues = 1480
+ ErrPartitionMaxvalue = 1481
+ ErrPartitionSubpartition = 1482
+ ErrPartitionSubpartMix = 1483
+ ErrPartitionWrongNoPart = 1484
+ ErrPartitionWrongNoSubpart = 1485
+ ErrWrongExprInPartitionFunc = 1486
+ ErrNoConstExprInRangeOrList = 1487
+ ErrFieldNotFoundPart = 1488
+ ErrListOfFieldsOnlyInHash = 1489
+ ErrInconsistentPartitionInfo = 1490
+ ErrPartitionFuncNotAllowed = 1491
+ ErrPartitionsMustBeDefined = 1492
+ ErrRangeNotIncreasing = 1493
+ ErrInconsistentTypeOfFunctions = 1494
+ ErrMultipleDefConstInListPart = 1495
+ ErrPartitionEntry = 1496
+ ErrMixHandler = 1497
+ ErrPartitionNotDefined = 1498
+ ErrTooManyPartitions = 1499
+ ErrSubpartition = 1500
+ ErrCantCreateHandlerFile = 1501
+ ErrBlobFieldInPartFunc = 1502
+ ErrUniqueKeyNeedAllFieldsInPf = 1503
+ ErrNoParts = 1504
+ ErrPartitionMgmtOnNonpartitioned = 1505
+ ErrForeignKeyOnPartitioned = 1506
+ ErrDropPartitionNonExistent = 1507
+ ErrDropLastPartition = 1508
+ ErrCoalesceOnlyOnHashPartition = 1509
+ ErrReorgHashOnlyOnSameNo = 1510
+ ErrReorgNoParam = 1511
+ ErrOnlyOnRangeListPartition = 1512
+ ErrAddPartitionSubpart = 1513
+ ErrAddPartitionNoNewPartition = 1514
+ ErrCoalescePartitionNoPartition = 1515
+ ErrReorgPartitionNotExist = 1516
+ ErrSameNamePartition = 1517
+ ErrNoBinlog = 1518
+ ErrConsecutiveReorgPartitions = 1519
+ ErrReorgOutsideRange = 1520
+ ErrPartitionFunctionFailure = 1521
+ ErrPartState = 1522
+ ErrLimitedPartRange = 1523
+ ErrPluginIsNotLoaded = 1524
+ ErrWrongValue = 1525
+ ErrNoPartitionForGivenValue = 1526
+ ErrFilegroupOptionOnlyOnce = 1527
+ ErrCreateFilegroupFailed = 1528
+ ErrDropFilegroupFailed = 1529
+ ErrTablespaceAutoExtend = 1530
+ ErrWrongSizeNumber = 1531
+ ErrSizeOverflow = 1532
+ ErrAlterFilegroupFailed = 1533
+ ErrBinlogRowLoggingFailed = 1534
+ ErrEventAlreadyExists = 1537
+ ErrEventStoreFailed = 1538
+ ErrEventDoesNotExist = 1539
+ ErrEventCantAlter = 1540
+ ErrEventDropFailed = 1541
+ ErrEventIntervalNotPositiveOrTooBig = 1542
+ ErrEventEndsBeforeStarts = 1543
+ ErrEventExecTimeInThePast = 1544
+ ErrEventOpenTableFailed = 1545
+ ErrEventNeitherMExprNorMAt = 1546
+ ErrObsoleteColCountDoesntMatchCorrupted = 1547
+ ErrObsoleteCannotLoadFromTable = 1548
+ ErrEventCannotDelete = 1549
+ ErrEventCompile = 1550
+ ErrEventSameName = 1551
+ ErrEventDataTooLong = 1552
+ ErrDropIndexFk = 1553
+ ErrWarnDeprecatedSyntaxWithVer = 1554
+ ErrCantWriteLockLogTable = 1555
+ ErrCantLockLogTable = 1556
+ ErrForeignDuplicateKeyOldUnused = 1557
+ ErrColCountDoesntMatchPleaseUpdate = 1558
+ ErrTempTablePreventsSwitchOutOfRbr = 1559
+ ErrStoredFunctionPreventsSwitchBinlogFormat = 1560
+ ErrNdbCantSwitchBinlogFormat = 1561
+ ErrPartitionNoTemporary = 1562
+ ErrPartitionConstDomain = 1563
+ ErrPartitionFunctionIsNotAllowed = 1564
+ ErrDdlLog = 1565
+ ErrNullInValuesLessThan = 1566
+ ErrWrongPartitionName = 1567
+ ErrCantChangeTxCharacteristics = 1568
+ ErrDupEntryAutoincrementCase = 1569
+ ErrEventModifyQueue = 1570
+ ErrEventSetVar = 1571
+ ErrPartitionMerge = 1572
+ ErrCantActivateLog = 1573
+ ErrRbrNotAvailable = 1574
+ ErrBase64Decode = 1575
+ ErrEventRecursionForbidden = 1576
+ ErrEventsDB = 1577
+ ErrOnlyIntegersAllowed = 1578
+ ErrUnsuportedLogEngine = 1579
+ ErrBadLogStatement = 1580
+ ErrCantRenameLogTable = 1581
+ ErrWrongParamcountToNativeFct = 1582
+ ErrWrongParametersToNativeFct = 1583
+ ErrWrongParametersToStoredFct = 1584
+ ErrNativeFctNameCollision = 1585
+ ErrDupEntryWithKeyName = 1586
+ ErrBinlogPurgeEmFile = 1587
+ ErrEventCannotCreateInThePast = 1588
+ ErrEventCannotAlterInThePast = 1589
+ ErrNoPartitionForGivenValueSilent = 1591
+ ErrBinlogUnsafeStatement = 1592
+ ErrBinlogLoggingImpossible = 1598
+ ErrViewNoCreationCtx = 1599
+ ErrViewInvalidCreationCtx = 1600
+ ErrSrInvalidCreationCtx = 1601
+ ErrTrgCorruptedFile = 1602
+ ErrTrgNoCreationCtx = 1603
+ ErrTrgInvalidCreationCtx = 1604
+ ErrEventInvalidCreationCtx = 1605
+ ErrTrgCantOpenTable = 1606
+ ErrCantCreateSroutine = 1607
+ ErrNoFormatDescriptionEventBeforeBinlogStatement = 1609
+ ErrLoadDataInvalidColumn = 1611
+ ErrLogPurgeNoFile = 1612
+ ErrXaRbtimeout = 1613
+ ErrXaRbdeadlock = 1614
+ ErrNeedReprepare = 1615
+ ErrDelayedNotSupported = 1616
+ WarnOptionIgnored = 1618
+ WarnPluginDeleteBuiltin = 1619
+ WarnPluginBusy = 1620
+ ErrVariableIsReadonly = 1621
+ ErrWarnEngineTransactionRollback = 1622
+ ErrNdbReplicationSchema = 1625
+ ErrConflictFnParse = 1626
+ ErrExceptionsWrite = 1627
+ ErrTooLongTableComment = 1628
+ ErrTooLongFieldComment = 1629
+ ErrFuncInexistentNameCollision = 1630
+ ErrDatabaseName = 1631
+ ErrTableName = 1632
+ ErrPartitionName = 1633
+ ErrSubpartitionName = 1634
+ ErrTemporaryName = 1635
+ ErrRenamedName = 1636
+ ErrTooManyConcurrentTrxs = 1637
+ WarnNonASCIISeparatorNotImplemented = 1638
+ ErrDebugSyncTimeout = 1639
+ ErrDebugSyncHitLimit = 1640
+ ErrDupSignalSet = 1641
+ ErrSignalWarn = 1642
+ ErrSignalNotFound = 1643
+ ErrSignalException = 1644
+ ErrResignalWithoutActiveHandler = 1645
+ ErrSignalBadConditionType = 1646
+ WarnCondItemTruncated = 1647
+ ErrCondItemTooLong = 1648
+ ErrUnknownLocale = 1649
+ ErrQueryCacheDisabled = 1651
+ ErrSameNamePartitionField = 1652
+ ErrPartitionColumnList = 1653
+ ErrWrongTypeColumnValue = 1654
+ ErrTooManyPartitionFuncFields = 1655
+ ErrMaxvalueInValuesIn = 1656
+ ErrTooManyValues = 1657
+ ErrRowSinglePartitionField = 1658
+ ErrFieldTypeNotAllowedAsPartitionField = 1659
+ ErrPartitionFieldsTooLong = 1660
+ ErrBinlogRowEngineAndStmtEngine = 1661
+ ErrBinlogRowModeAndStmtEngine = 1662
+ ErrBinlogUnsafeAndStmtEngine = 1663
+ ErrBinlogRowInjectionAndStmtEngine = 1664
+ ErrBinlogStmtModeAndRowEngine = 1665
+ ErrBinlogRowInjectionAndStmtMode = 1666
+ ErrBinlogMultipleEnginesAndSelfLoggingEngine = 1667
+ ErrBinlogUnsafeLimit = 1668
+ ErrBinlogUnsafeInsertDelayed = 1669
+ ErrBinlogUnsafeAutoincColumns = 1671
+ ErrBinlogUnsafeNontransAfterTrans = 1675
+ ErrMessageAndStatement = 1676
+ ErrInsideTransactionPreventsSwitchBinlogFormat = 1679
+ ErrPathLength = 1680
+ ErrWarnDeprecatedSyntaxNoReplacement = 1681
+ ErrWrongNativeTableStructure = 1682
+ ErrWrongPerfSchemaUsage = 1683
+ ErrWarnISSkippedTable = 1684
+ ErrInsideTransactionPreventsSwitchBinlogDirect = 1685
+ ErrStoredFunctionPreventsSwitchBinlogDirect = 1686
+ ErrSpatialMustHaveGeomCol = 1687
+ ErrTooLongIndexComment = 1688
+ ErrLockAborted = 1689
+ ErrDataOutOfRange = 1690
+ ErrWrongSpvarTypeInLimit = 1691
+ ErrBinlogUnsafeMultipleEnginesAndSelfLoggingEngine = 1692
+ ErrBinlogUnsafeMixedStatement = 1693
+ ErrInsideTransactionPreventsSwitchSQLLogBin = 1694
+ ErrStoredFunctionPreventsSwitchSQLLogBin = 1695
+ ErrFailedReadFromParFile = 1696
+ ErrValuesIsNotIntType = 1697
+ ErrAccessDeniedNoPassword = 1698
+ ErrSetPasswordAuthPlugin = 1699
+ ErrGrantPluginUserExists = 1700
+ ErrTruncateIllegalFk = 1701
+ ErrPluginIsPermanent = 1702
+ ErrStmtCacheFull = 1705
+ ErrMultiUpdateKeyConflict = 1706
+ ErrTableNeedsRebuild = 1707
+ WarnOptionBelowLimit = 1708
+ ErrIndexColumnTooLong = 1709
+ ErrErrorInTriggerBody = 1710
+ ErrErrorInUnknownTriggerBody = 1711
+ ErrIndexCorrupt = 1712
+ ErrUndoRecordTooBig = 1713
+ ErrPluginNoUninstall = 1720
+ ErrPluginNoInstall = 1721
+ ErrBinlogUnsafeInsertTwoKeys = 1724
+ ErrTableInFkCheck = 1725
+ ErrUnsupportedEngine = 1726
+ ErrBinlogUnsafeAutoincNotFirst = 1727
+ ErrCannotLoadFromTableV2 = 1728
+ ErrOnlyFdAndRbrEventsAllowedInBinlogStatement = 1730
+ ErrPartitionExchangeDifferentOption = 1731
+ ErrPartitionExchangePartTable = 1732
+ ErrPartitionExchangeTempTable = 1733
+ ErrPartitionInsteadOfSubpartition = 1734
+ ErrUnknownPartition = 1735
+ ErrTablesDifferentMetadata = 1736
+ ErrRowDoesNotMatchPartition = 1737
+ ErrBinlogCacheSizeGreaterThanMax = 1738
+ ErrWarnIndexNotApplicable = 1739
+ ErrPartitionExchangeForeignKey = 1740
+ ErrNoSuchKeyValue = 1741
+ ErrRplInfoDataTooLong = 1742
+ ErrNetworkReadEventChecksumFailure = 1743
+ ErrBinlogReadEventChecksumFailure = 1744
+ ErrBinlogStmtCacheSizeGreaterThanMax = 1745
+ ErrCantUpdateTableInCreateTableSelect = 1746
+ ErrPartitionClauseOnNonpartitioned = 1747
+ ErrRowDoesNotMatchGivenPartitionSet = 1748
+ ErrNoSuchPartitionunused = 1749
+ ErrChangeRplInfoRepositoryFailure = 1750
+ ErrWarningNotCompleteRollbackWithCreatedTempTable = 1751
+ ErrWarningNotCompleteRollbackWithDroppedTempTable = 1752
+ ErrMtsUpdatedDBsGreaterMax = 1754
+ ErrMtsCantParallel = 1755
+ ErrMtsInconsistentData = 1756
+ ErrFulltextNotSupportedWithPartitioning = 1757
+ ErrDaInvalidConditionNumber = 1758
+ ErrInsecurePlainText = 1759
+ ErrForeignDuplicateKeyWithChildInfo = 1761
+ ErrForeignDuplicateKeyWithoutChildInfo = 1762
+ ErrTableHasNoFt = 1764
+ ErrVariableNotSettableInSfOrTrigger = 1765
+ ErrVariableNotSettableInTransaction = 1766
+ ErrGtidNextIsNotInGtidNextList = 1767
+ ErrCantChangeGtidNextInTransactionWhenGtidNextListIsNull = 1768
+ ErrSetStatementCannotInvokeFunction = 1769
+ ErrGtidNextCantBeAutomaticIfGtidNextListIsNonNull = 1770
+ ErrSkippingLoggedTransaction = 1771
+ ErrMalformedGtidSetSpecification = 1772
+ ErrMalformedGtidSetEncoding = 1773
+ ErrMalformedGtidSpecification = 1774
+ ErrGnoExhausted = 1775
+ ErrCantDoImplicitCommitInTrxWhenGtidNextIsSet = 1778
+ ErrGtidMode2Or3RequiresEnforceGtidConsistencyOn = 1779
+ ErrCantSetGtidNextToGtidWhenGtidModeIsOff = 1781
+ ErrCantSetGtidNextToAnonymousWhenGtidModeIsOn = 1782
+ ErrCantSetGtidNextListToNonNullWhenGtidModeIsOff = 1783
+ ErrFoundGtidEventWhenGtidModeIsOff = 1784
+ ErrGtidUnsafeNonTransactionalTable = 1785
+ ErrGtidUnsafeCreateSelect = 1786
+ ErrGtidUnsafeCreateDropTemporaryTableInTransaction = 1787
+ ErrGtidModeCanOnlyChangeOneStepAtATime = 1788
+ ErrCantSetGtidNextWhenOwningGtid = 1790
+ ErrUnknownExplainFormat = 1791
+ ErrCantExecuteInReadOnlyTransaction = 1792
+ ErrTooLongTablePartitionComment = 1793
+ ErrInnodbFtLimit = 1795
+ ErrInnodbNoFtTempTable = 1796
+ ErrInnodbFtWrongDocidColumn = 1797
+ ErrInnodbFtWrongDocidIndex = 1798
+ ErrInnodbOnlineLogTooBig = 1799
+ ErrUnknownAlterAlgorithm = 1800
+ ErrUnknownAlterLock = 1801
+ ErrMtsResetWorkers = 1804
+ ErrColCountDoesntMatchCorruptedV2 = 1805
+ ErrDiscardFkChecksRunning = 1807
+ ErrTableSchemaMismatch = 1808
+ ErrTableInSystemTablespace = 1809
+ ErrIoRead = 1810
+ ErrIoWrite = 1811
+ ErrTablespaceMissing = 1812
+ ErrTablespaceExists = 1813
+ ErrTablespaceDiscarded = 1814
+ ErrInternal = 1815
+ ErrInnodbImport = 1816
+ ErrInnodbIndexCorrupt = 1817
+ ErrInvalidYearColumnLength = 1818
+ ErrNotValidPassword = 1819
+ ErrMustChangePassword = 1820
+ ErrFkNoIndexChild = 1821
+ ErrFkNoIndexParent = 1822
+ ErrFkFailAddSystem = 1823
+ ErrFkCannotOpenParent = 1824
+ ErrFkIncorrectOption = 1825
+ ErrFkDupName = 1826
+ ErrPasswordFormat = 1827
+ ErrFkColumnCannotDrop = 1828
+ ErrFkColumnCannotDropChild = 1829
+ ErrFkColumnNotNull = 1830
+ ErrDupIndex = 1831
+ ErrFkColumnCannotChange = 1832
+ ErrFkColumnCannotChangeChild = 1833
+ ErrFkCannotDeleteParent = 1834
+ ErrMalformedPacket = 1835
+ ErrReadOnlyMode = 1836
+ ErrVariableNotSettableInSp = 1838
+ ErrCantSetGtidPurgedWhenGtidModeIsOff = 1839
+ ErrCantSetGtidPurgedWhenGtidExecutedIsNotEmpty = 1840
+ ErrCantSetGtidPurgedWhenOwnedGtidsIsNotEmpty = 1841
+ ErrGtidPurgedWasChanged = 1842
+ ErrGtidExecutedWasChanged = 1843
+ ErrBinlogStmtModeAndNoReplTables = 1844
+ ErrAlterOperationNotSupported = 1845
+ ErrAlterOperationNotSupportedReason = 1846
+ ErrAlterOperationNotSupportedReasonCopy = 1847
+ ErrAlterOperationNotSupportedReasonPartition = 1848
+ ErrAlterOperationNotSupportedReasonFkRename = 1849
+ ErrAlterOperationNotSupportedReasonColumnType = 1850
+ ErrAlterOperationNotSupportedReasonFkCheck = 1851
+ ErrAlterOperationNotSupportedReasonIgnore = 1852
+ ErrAlterOperationNotSupportedReasonNopk = 1853
+ ErrAlterOperationNotSupportedReasonAutoinc = 1854
+ ErrAlterOperationNotSupportedReasonHiddenFts = 1855
+ ErrAlterOperationNotSupportedReasonChangeFts = 1856
+ ErrAlterOperationNotSupportedReasonFts = 1857
+ ErrDupUnknownInIndex = 1859
+ ErrIdentCausesTooLongPath = 1860
+ ErrAlterOperationNotSupportedReasonNotNull = 1861
+ ErrMustChangePasswordLogin = 1862
+ ErrRowInWrongPartition = 1863
+ ErrErrorLast = 1863
+ ErrMaxExecTimeExceeded = 1907
+ ErrInvalidFieldSize = 3013
+ ErrInvalidArgumentForLogarithm = 3020
+ ErrAggregateOrderNonAggQuery = 3029
+ ErrIncorrectType = 3064
+ ErrFieldInOrderNotSelect = 3065
+ ErrAggregateInOrderNotSelect = 3066
+ ErrInvalidJSONData = 3069
+ ErrGeneratedColumnFunctionIsNotAllowed = 3102
+ ErrUnsupportedAlterInplaceOnVirtualColumn = 3103
+ ErrWrongFKOptionForGeneratedColumn = 3104
+ ErrBadGeneratedColumn = 3105
+ ErrUnsupportedOnGeneratedColumn = 3106
+ ErrGeneratedColumnNonPrior = 3107
+ ErrDependentByGeneratedColumn = 3108
+ ErrGeneratedColumnRefAutoInc = 3109
+ ErrWarnConflictingHint = 3126
+ ErrUnresolvedHintName = 3128
+ ErrInvalidJSONText = 3140
+ ErrInvalidJSONPath = 3143
+ ErrInvalidTypeForJSON = 3146
+ ErrInvalidJSONPathWildcard = 3149
+ ErrInvalidJSONContainsPathType = 3150
+ ErrJSONUsedAsKey = 3152
+ ErrJSONDocumentNULLKey = 3158
+ ErrSecureTransportRequired = 3159
+ ErrBadUser = 3162
+ ErrUserAlreadyExists = 3163
+ ErrInvalidJSONPathArrayCell = 3165
+ ErrInvalidEncryptionOption = 3184
+ ErrTooLongValueForType = 3505
+ ErrPKIndexCantBeInvisible = 3522
+ ErrRoleNotGranted = 3530
+ ErrLockAcquireFailAndNoWaitSet = 3572
+ ErrWindowNoSuchWindow = 3579
+ ErrWindowCircularityInWindowGraph = 3580
+ ErrWindowNoChildPartitioning = 3581
+ ErrWindowNoInherentFrame = 3582
+ ErrWindowNoRedefineOrderBy = 3583
+ ErrWindowFrameStartIllegal = 3584
+ ErrWindowFrameEndIllegal = 3585
+ ErrWindowFrameIllegal = 3586
+ ErrWindowRangeFrameOrderType = 3587
+ ErrWindowRangeFrameTemporalType = 3588
+ ErrWindowRangeFrameNumericType = 3589
+ ErrWindowRangeBoundNotConstant = 3590
+ ErrWindowDuplicateName = 3591
+ ErrWindowIllegalOrderBy = 3592
+ ErrWindowInvalidWindowFuncUse = 3593
+ ErrWindowInvalidWindowFuncAliasUse = 3594
+ ErrWindowNestedWindowFuncUseInWindowSpec = 3595
+ ErrWindowRowsIntervalUse = 3596
+ ErrWindowNoGroupOrderUnused = 3597
+ ErrWindowExplainJSON = 3598
+ ErrWindowFunctionIgnoresFrame = 3599
+ ErrNotHintUpdatable = 3637
+ ErrDataTruncatedFunctionalIndex = 3751
+ ErrDataOutOfRangeFunctionalIndex = 3752
+ ErrFunctionalIndexOnJSONOrGeometryFunction = 3753
+ ErrFunctionalIndexRefAutoIncrement = 3754
+ ErrCannotDropColumnFunctionalIndex = 3755
+ ErrFunctionalIndexPrimaryKey = 3756
+ ErrFunctionalIndexOnLob = 3757
+ ErrFunctionalIndexFunctionIsNotAllowed = 3758
+ ErrFulltextFunctionalIndex = 3759
+ ErrSpatialFunctionalIndex = 3760
+ ErrWrongKeyColumnFunctionalIndex = 3761
+ ErrFunctionalIndexOnField = 3762
+ ErrGeneratedColumnRowValueIsNotAllowed = 3764
+ ErrFKIncompatibleColumns = 3780
+ ErrFunctionalIndexRowValueIsNotAllowed = 3800
+ ErrDependentByFunctionalIndex = 3837
+ ErrInvalidJSONValueForFuncIndex = 3903
+ ErrJSONValueOutOfRangeForFuncIndex = 3904
+ ErrFunctionalIndexDataIsTooLong = 3907
+ ErrFunctionalIndexNotApplicable = 3909
+ // MariaDB errors.
+ ErrOnlyOneDefaultPartionAllowed = 4030
+ ErrWrongPartitionTypeExpectedSystemTime = 4113
+ ErrSystemVersioningWrongPartitions = 4128
+ ErrSequenceRunOut = 4135
+ ErrSequenceInvalidData = 4136
+ ErrSequenceAccessFail = 4137
+ ErrNotSequence = 4138
+ ErrUnknownSequence = 4139
+ ErrWrongInsertIntoSequence = 4140
+ ErrSequenceInvalidTableStructure = 4141
+ // TiDB self-defined errors.
+ ErrMemExceedThreshold = 8001
+ ErrForUpdateCantRetry = 8002
+ ErrAdminCheckTable = 8003
+ ErrTxnTooLarge = 8004
+ ErrWriteConflictInTiDB = 8005
+ ErrUnsupportedReloadPlugin = 8018
+ ErrUnsupportedReloadPluginVar = 8019
+ ErrTableLocked = 8020
+ ErrNotExist = 8021
+ ErrTxnRetryable = 8022
+ ErrCannotSetNilValue = 8023
+ ErrInvalidTxn = 8024
+ ErrEntryTooLarge = 8025
+ ErrNotImplemented = 8026
+ ErrInfoSchemaExpired = 8027
+ ErrInfoSchemaChanged = 8028
+ ErrBadNumber = 8029
+ ErrCastAsSignedOverflow = 8030
+ ErrCastNegIntAsUnsigned = 8031
+ ErrInvalidYearFormat = 8032
+ ErrInvalidYear = 8033
+ ErrIncorrectDatetimeValue = 8034
+ ErrInvalidTimeFormat = 8036
+ ErrInvalidWeekModeFormat = 8037
+ ErrFieldGetDefaultFailed = 8038
+ ErrIndexOutBound = 8039
+ ErrUnsupportedOp = 8040
+ ErrRowNotFound = 8041
+ ErrTableStateCantNone = 8042
+ ErrColumnStateNonPublic = 8043
+ ErrIndexStateCantNone = 8044
+ ErrInvalidRecordKey = 8045
+ ErrColumnStateCantNone = 8046
+ ErrUnsupportedValueForVar = 8047
+ ErrUnsupportedIsolationLevel = 8048
+ ErrLoadPrivilege = 8049
+ ErrInvalidPrivilegeType = 8050
+ ErrUnknownFieldType = 8051
+ ErrInvalidSequence = 8052
+ ErrCantGetValidID = 8053
+ ErrCantSetToNull = 8054
+ ErrSnapshotTooOld = 8055
+ ErrInvalidTableID = 8056
+ ErrInvalidType = 8057
+ ErrUnknownAllocatorType = 8058
+ ErrAutoRandReadFailed = 8059
+ ErrInvalidIncrementAndOffset = 8060
+ ErrWarnOptimizerHintUnsupportedHint = 8061
+ ErrWarnOptimizerHintInvalidToken = 8062
+ ErrWarnMemoryQuotaOverflow = 8063
+ ErrWarnOptimizerHintParseError = 8064
+ ErrWarnOptimizerHintInvalidInteger = 8065
+ ErrUnsupportedSecondArgumentType = 8066
+ ErrInvalidPluginID = 8101
+ ErrInvalidPluginManifest = 8102
+ ErrInvalidPluginName = 8103
+ ErrInvalidPluginVersion = 8104
+ ErrDuplicatePlugin = 8105
+ ErrInvalidPluginSysVarName = 8106
+ ErrRequireVersionCheckFail = 8107
+ ErrUnsupportedType = 8108
+ ErrAnalyzeMissIndex = 8109
+ ErrCartesianProductUnsupported = 8110
+ ErrPreparedStmtNotFound = 8111
+ ErrWrongParamCount = 8112
+ ErrSchemaChanged = 8113
+ ErrUnknownPlan = 8114
+ ErrPrepareMulti = 8115
+ ErrPrepareDDL = 8116
+ ErrResultIsEmpty = 8117
+ ErrBuildExecutor = 8118
+ ErrBatchInsertFail = 8119
+ ErrGetStartTS = 8120
+ ErrPrivilegeCheckFail = 8121
+ ErrInvalidWildCard = 8122
+ ErrMixOfGroupFuncAndFieldsIncompatible = 8123
+ ErrBRIEBackupFailed = 8124
+ ErrBRIERestoreFailed = 8125
+ ErrBRIEImportFailed = 8126
+ ErrBRIEExportFailed = 8127
+ ErrInvalidTableSample = 8128
+ ErrJSONObjectKeyTooLong = 8129
+ ErrMultiStatementDisabled = 8130
+ ErrPartitionStatsMissing = 8131
+
+ // Error codes used by TiDB ddl package
+ ErrUnsupportedDDLOperation = 8200
+ ErrNotOwner = 8201
+ ErrCantDecodeRecord = 8202
+ ErrInvalidDDLWorker = 8203
+ ErrInvalidDDLJob = 8204
+ ErrInvalidDDLJobFlag = 8205
+ ErrWaitReorgTimeout = 8206
+ ErrInvalidStoreVersion = 8207
+ ErrUnknownTypeLength = 8208
+ ErrUnknownFractionLength = 8209
+ ErrInvalidDDLState = 8210
+ ErrReorgPanic = 8211
+ ErrInvalidSplitRegionRanges = 8212
+ ErrInvalidDDLJobVersion = 8213
+ ErrCancelledDDLJob = 8214
+ ErrRepairTable = 8215
+ ErrInvalidAutoRandom = 8216
+ ErrInvalidHashKeyFlag = 8217
+ ErrInvalidListIndex = 8218
+ ErrInvalidListMetaData = 8219
+ ErrWriteOnSnapshot = 8220
+ ErrInvalidKey = 8221
+ ErrInvalidIndexKey = 8222
+ ErrDataInConsistent = 8223
+ ErrDDLJobNotFound = 8224
+ ErrCancelFinishedDDLJob = 8225
+ ErrCannotCancelDDLJob = 8226
+ ErrSequenceUnsupportedTableOption = 8227
+ ErrColumnTypeUnsupportedNextValue = 8228
+ ErrLockExpire = 8229
+ ErrAddColumnWithSequenceAsDefault = 8230
+ ErrUnsupportedConstraintCheck = 8231
+ ErrTableOptionUnionUnsupported = 8232
+ ErrTableOptionInsertMethodUnsupported = 8233
+ ErrInvalidPlacementSpec = 8234
+ ErrDDLReorgElementNotExist = 8235
+ ErrPlacementPolicyCheck = 8236
+
+ // TiKV/PD/TiFlash errors.
+ ErrPDServerTimeout = 9001
+ ErrTiKVServerTimeout = 9002
+ ErrTiKVServerBusy = 9003
+ ErrResolveLockTimeout = 9004
+ ErrRegionUnavailable = 9005
+ ErrGCTooEarly = 9006
+ ErrWriteConflict = 9007
+ ErrTiKVStoreLimit = 9008
+ ErrPrometheusAddrIsNotSet = 9009
+ ErrTiKVStaleCommand = 9010
+ ErrTiKVMaxTimestampNotSynced = 9011
+ ErrTiFlashServerTimeout = 9012
+ ErrTiFlashServerBusy = 9013
+)
diff --git a/pkg/errno/errname.go b/pkg/errno/errname.go
new file mode 100644
index 0000000000000000000000000000000000000000..850b8dd03e2c3a62bfe670292cf4111a11e3d57d
--- /dev/null
+++ b/pkg/errno/errname.go
@@ -0,0 +1,1043 @@
+package errno
+
+import "github.com/pingcap/parser/mysql"
+
+// MySQLErrName maps error code to MySQL error messages.
+// Note: all ErrMessage to be added should be considered about the log redaction
+// by setting the suitable configuration in the second argument of mysql.Message.
+// See https://github.com/pingcap/tidb/blob/master/errno/logredaction.md
+var MySQLErrName = map[uint16]*mysql.ErrMessage{
+ ErrHashchk: mysql.Message("hashchk", nil),
+ ErrNisamchk: mysql.Message("isamchk", nil),
+ ErrNo: mysql.Message("NO", nil),
+ ErrYes: mysql.Message("YES", nil),
+ ErrCantCreateFile: mysql.Message("Can't create file '%-.200s' (errno: %d - %s)", nil),
+ ErrCantCreateTable: mysql.Message("Can't create table '%-.200s' (errno: %d)", nil),
+ ErrCantCreateDB: mysql.Message("Can't create database '%-.192s' (errno: %d)", nil),
+ ErrDBCreateExists: mysql.Message("Can't create database '%-.192s'; database exists", nil),
+ ErrDBDropExists: mysql.Message("Can't drop database '%-.192s'; database doesn't exist", nil),
+ ErrDBDropDelete: mysql.Message("Error dropping database (can't delete '%-.192s', errno: %d)", nil),
+ ErrDBDropRmdir: mysql.Message("Error dropping database (can't rmdir '%-.192s', errno: %d)", nil),
+ ErrCantDeleteFile: mysql.Message("Error on delete of '%-.192s' (errno: %d - %s)", nil),
+ ErrCantFindSystemRec: mysql.Message("Can't read record in system table", nil),
+ ErrCantGetStat: mysql.Message("Can't get status of '%-.200s' (errno: %d - %s)", nil),
+ ErrCantGetWd: mysql.Message("Can't get working directory (errno: %d - %s)", nil),
+ ErrCantLock: mysql.Message("Can't lock file (errno: %d - %s)", nil),
+ ErrCantOpenFile: mysql.Message("Can't open file: '%-.200s' (errno: %d - %s)", nil),
+ ErrFileNotFound: mysql.Message("Can't find file: '%-.200s' (errno: %d - %s)", nil),
+ ErrCantReadDir: mysql.Message("Can't read dir of '%-.192s' (errno: %d - %s)", nil),
+ ErrCantSetWd: mysql.Message("Can't change dir to '%-.192s' (errno: %d - %s)", nil),
+ ErrCheckread: mysql.Message("Record has changed since last read in table '%-.192s'", nil),
+ ErrDiskFull: mysql.Message("Disk full (%s); waiting for someone to free some space... (errno: %d - %s)", nil),
+ ErrDupKey: mysql.Message("Can't write; duplicate key in table '%-.192s'", nil),
+ ErrErrorOnClose: mysql.Message("Error on close of '%-.192s' (errno: %d - %s)", nil),
+ ErrErrorOnRead: mysql.Message("Error reading file '%-.200s' (errno: %d - %s)", nil),
+ ErrErrorOnRename: mysql.Message("Error on rename of '%-.210s' to '%-.210s' (errno: %d - %s)", nil),
+ ErrErrorOnWrite: mysql.Message("Error writing file '%-.200s' (errno: %d - %s)", nil),
+ ErrFileUsed: mysql.Message("'%-.192s' is locked against change", nil),
+ ErrFilsortAbort: mysql.Message("Sort aborted", nil),
+ ErrFormNotFound: mysql.Message("View '%-.192s' doesn't exist for '%-.192s'", nil),
+ ErrGetErrno: mysql.Message("Got error %d from storage engine", nil),
+ ErrIllegalHa: mysql.Message("Table storage engine for '%-.192s' doesn't have this option", nil),
+ ErrKeyNotFound: mysql.Message("Can't find record in '%-.192s'", nil),
+ ErrNotFormFile: mysql.Message("Incorrect information in file: '%-.200s'", nil),
+ ErrNotKeyFile: mysql.Message("Incorrect key file for table '%-.200s'; try to repair it", nil),
+ ErrOldKeyFile: mysql.Message("Old key file for table '%-.192s'; repair it!", nil),
+ ErrOpenAsReadonly: mysql.Message("Table '%-.192s' is read only", nil),
+ ErrOutofMemory: mysql.Message("Out of memory; restart server and try again (needed %d bytes)", nil),
+ ErrOutOfSortMemory: mysql.Message("Out of sort memory, consider increasing server sort buffer size", nil),
+ ErrUnexpectedEOF: mysql.Message("Unexpected EOF found when reading file '%-.192s' (errno: %d - %s)", nil),
+ ErrConCount: mysql.Message("Too many connections", nil),
+ ErrOutOfResources: mysql.Message("Out of memory; check if mysqld or some other process uses all available memory; if not, you may have to use 'ulimit' to allow mysqld to use more memory or you can add more swap space", nil),
+ ErrBadHost: mysql.Message("Can't get hostname for your address", nil),
+ ErrHandshake: mysql.Message("Bad handshake", nil),
+ ErrDBaccessDenied: mysql.Message("Access denied for user '%-.48s'@'%-.64s' to database '%-.192s'", nil),
+ ErrAccessDenied: mysql.Message("Access denied for user '%-.48s'@'%-.64s' (using password: %s)", nil),
+ ErrNoDB: mysql.Message("No database selected", nil),
+ ErrUnknownCom: mysql.Message("Unknown command", nil),
+ ErrBadNull: mysql.Message("Column '%-.192s' cannot be null", nil),
+ ErrBadDB: mysql.Message("Unknown database '%-.192s'", nil),
+ ErrTableExists: mysql.Message("Table '%-.192s' already exists", nil),
+ ErrBadTable: mysql.Message("Unknown table '%-.100s'", nil),
+ ErrNonUniq: mysql.Message("Column '%-.192s' in %-.192s is ambiguous", nil),
+ ErrServerShutdown: mysql.Message("Server shutdown in progress", nil),
+ ErrBadField: mysql.Message("Unknown column '%-.192s' in '%-.192s'", nil),
+ ErrFieldNotInGroupBy: mysql.Message("Expression #%d of %s is not in GROUP BY clause and contains nonaggregated column '%s' which is not functionally dependent on columns in GROUP BY clause; this is incompatible with sql_mode=only_full_group_by", nil),
+ ErrWrongGroupField: mysql.Message("Can't group on '%-.192s'", nil),
+ ErrWrongSumSelect: mysql.Message("Statement has sum functions and columns in same statement", nil),
+ ErrWrongValueCount: mysql.Message("Column count doesn't match value count", nil),
+ ErrTooLongIdent: mysql.Message("Identifier name '%-.100s' is too long", nil),
+ ErrDupFieldName: mysql.Message("Duplicate column name '%-.192s'", nil),
+ ErrDupKeyName: mysql.Message("Duplicate key name '%-.192s'", nil),
+ ErrDupEntry: mysql.Message("Duplicate entry '%-.64s' for key '%-.192s'", []int{0}),
+ ErrWrongFieldSpec: mysql.Message("Incorrect column specifier for column '%-.192s'", nil),
+ ErrParse: mysql.Message("%s %s", nil),
+ ErrEmptyQuery: mysql.Message("Query was empty", nil),
+ ErrNonuniqTable: mysql.Message("Not unique table/alias: '%-.192s'", nil),
+ ErrInvalidDefault: mysql.Message("Invalid default value for '%-.192s'", nil),
+ ErrMultiplePriKey: mysql.Message("Multiple primary key defined", nil),
+ ErrTooManyKeys: mysql.Message("Too many keys specified; max %d keys allowed", nil),
+ ErrTooManyKeyParts: mysql.Message("Too many key parts specified; max %d parts allowed", nil),
+ ErrTooLongKey: mysql.Message("Specified key was too long; max key length is %d bytes", nil),
+ ErrKeyColumnDoesNotExits: mysql.Message("Key column '%-.192s' doesn't exist in table", nil),
+ ErrBlobUsedAsKey: mysql.Message("BLOB column '%-.192s' can't be used in key specification with the used table type", nil),
+ ErrTooBigFieldlength: mysql.Message("Column length too big for column '%-.192s' (max = %d); use BLOB or TEXT instead", nil),
+ ErrWrongAutoKey: mysql.Message("Incorrect table definition; there can be only one auto column and it must be defined as a key", nil),
+ ErrReady: mysql.Message("%s: ready for connections.\nVersion: '%s' socket: '%s' port: %d", nil),
+ ErrNormalShutdown: mysql.Message("%s: Normal shutdown\n", nil),
+ ErrGotSignal: mysql.Message("%s: Got signal %d. Aborting!\n", nil),
+ ErrShutdownComplete: mysql.Message("%s: Shutdown complete\n", nil),
+ ErrForcingClose: mysql.Message("%s: Forcing close of thread %d user: '%-.48s'\n", nil),
+ ErrIpsock: mysql.Message("Can't create IP socket", nil),
+ ErrNoSuchIndex: mysql.Message("Table '%-.192s' has no index like the one used in CREATE INDEX; recreate the table", nil),
+ ErrWrongFieldTerminators: mysql.Message("Field separator argument is not what is expected; check the manual", nil),
+ ErrBlobsAndNoTerminated: mysql.Message("You can't use fixed rowlength with BLOBs; please use 'fields terminated by'", nil),
+ ErrTextFileNotReadable: mysql.Message("The file '%-.128s' must be in the database directory or be readable by all", nil),
+ ErrFileExists: mysql.Message("File '%-.200s' already exists", nil),
+ ErrLoadInfo: mysql.Message("Records: %d Deleted: %d Skipped: %d Warnings: %d", nil),
+ ErrAlterInfo: mysql.Message("Records: %d Duplicates: %d", nil),
+ ErrWrongSubKey: mysql.Message("Incorrect prefix key; the used key part isn't a string, the used length is longer than the key part, or the storage engine doesn't support unique prefix keys", nil),
+ ErrCantRemoveAllFields: mysql.Message("You can't delete all columns with ALTER TABLE; use DROP TABLE instead", nil),
+ ErrCantDropFieldOrKey: mysql.Message("Can't DROP '%-.192s'; check that column/key exists", nil),
+ ErrInsertInfo: mysql.Message("Records: %d Duplicates: %d Warnings: %d", nil),
+ ErrUpdateTableUsed: mysql.Message("You can't specify target table '%-.192s' for update in FROM clause", nil),
+ ErrNoSuchThread: mysql.Message("Unknown thread id: %d", nil),
+ ErrKillDenied: mysql.Message("You are not owner of thread %d", nil),
+ ErrNoTablesUsed: mysql.Message("No tables used", nil),
+ ErrTooBigSet: mysql.Message("Too many strings for column %-.192s and SET", nil),
+ ErrNoUniqueLogFile: mysql.Message("Can't generate a unique log-filename %-.200s.(1-999)\n", nil),
+ ErrTableNotLockedForWrite: mysql.Message("Table '%-.192s' was locked with a READ lock and can't be updated", nil),
+ ErrTableNotLocked: mysql.Message("Table '%-.192s' was not locked with LOCK TABLES", nil),
+ ErrBlobCantHaveDefault: mysql.Message("BLOB/TEXT/JSON column '%-.192s' can't have a default value", nil),
+ ErrWrongDBName: mysql.Message("Incorrect database name '%-.100s'", nil),
+ ErrWrongTableName: mysql.Message("Incorrect table name '%-.100s'", nil),
+ ErrTooBigSelect: mysql.Message("The SELECT would examine more than MAXJOINSIZE rows; check your WHERE and use SET SQLBIGSELECTS=1 or SET MAXJOINSIZE=# if the SELECT is okay", nil),
+ ErrUnknown: mysql.Message("Unknown error", nil),
+ ErrUnknownProcedure: mysql.Message("Unknown procedure '%-.192s'", nil),
+ ErrWrongParamcountToProcedure: mysql.Message("Incorrect parameter count to procedure '%-.192s'", nil),
+ ErrWrongParametersToProcedure: mysql.Message("Incorrect parameters to procedure '%-.192s'", nil),
+ ErrUnknownTable: mysql.Message("Unknown table '%-.192s' in %-.32s", nil),
+ ErrFieldSpecifiedTwice: mysql.Message("Column '%-.192s' specified twice", nil),
+ ErrInvalidGroupFuncUse: mysql.Message("Invalid use of group function", nil),
+ ErrUnsupportedExtension: mysql.Message("Table '%-.192s' uses an extension that doesn't exist in this MySQL version", nil),
+ ErrTableMustHaveColumns: mysql.Message("A table must have at least 1 column", nil),
+ ErrRecordFileFull: mysql.Message("The table '%-.192s' is full", nil),
+ ErrUnknownCharacterSet: mysql.Message("Unknown character set: '%-.64s'", nil),
+ ErrTooManyTables: mysql.Message("Too many tables; MySQL can only use %d tables in a join", nil),
+ ErrTooManyFields: mysql.Message("Too many columns", nil),
+ ErrTooBigRowsize: mysql.Message("Row size too large. The maximum row size for the used table type, not counting BLOBs, is %d. This includes storage overhead, check the manual. You have to change some columns to TEXT or BLOBs", nil),
+ ErrStackOverrun: mysql.Message("Thread stack overrun: Used: %d of a %d stack. Use 'mysqld --threadStack=#' to specify a bigger stack if needed", nil),
+ ErrWrongOuterJoin: mysql.Message("Cross dependency found in OUTER JOIN; examine your ON conditions", nil),
+ ErrNullColumnInIndex: mysql.Message("Table handler doesn't support NULL in given index. Please change column '%-.192s' to be NOT NULL or use another handler", nil),
+ ErrCantFindUdf: mysql.Message("Can't load function '%-.192s'", nil),
+ ErrCantInitializeUdf: mysql.Message("Can't initialize function '%-.192s'; %-.80s", nil),
+ ErrUdfNoPaths: mysql.Message("No paths allowed for shared library", nil),
+ ErrUdfExists: mysql.Message("Function '%-.192s' already exists", nil),
+ ErrCantOpenLibrary: mysql.Message("Can't open shared library '%-.192s' (errno: %d %-.128s)", nil),
+ ErrCantFindDlEntry: mysql.Message("Can't find symbol '%-.128s' in library", nil),
+ ErrFunctionNotDefined: mysql.Message("Function '%-.192s' is not defined", nil),
+ ErrHostIsBlocked: mysql.Message("Host '%-.64s' is blocked because of many connection errors; unblock with 'mysqladmin flush-hosts'", nil),
+ ErrHostNotPrivileged: mysql.Message("Host '%-.64s' is not allowed to connect to this MySQL server", nil),
+ ErrPasswordAnonymousUser: mysql.Message("You are using MySQL as an anonymous user and anonymous users are not allowed to change passwords", nil),
+ ErrPasswordNotAllowed: mysql.Message("You must have privileges to update tables in the mysql database to be able to change passwords for others", nil),
+ ErrPasswordNoMatch: mysql.Message("Can't find any matching row in the user table", nil),
+ ErrUpdateInfo: mysql.Message("Rows matched: %d Changed: %d Warnings: %d", nil),
+ ErrCantCreateThread: mysql.Message("Can't create a new thread (errno %d); if you are not out of available memory, you can consult the manual for a possible OS-dependent bug", nil),
+ ErrWrongValueCountOnRow: mysql.Message("Column count doesn't match value count at row %d", nil),
+ ErrCantReopenTable: mysql.Message("Can't reopen table: '%-.192s'", nil),
+ ErrInvalidUseOfNull: mysql.Message("Invalid use of NULL value", nil),
+ ErrRegexp: mysql.Message("Got error '%-.64s' from regexp", nil),
+ ErrMixOfGroupFuncAndFields: mysql.Message("Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no GROUP columns is illegal if there is no GROUP BY clause", nil),
+ ErrNonexistingGrant: mysql.Message("There is no such grant defined for user '%-.48s' on host '%-.64s'", nil),
+ ErrTableaccessDenied: mysql.Message("%-.128s command denied to user '%-.48s'@'%-.64s' for table '%-.64s'", nil),
+ ErrColumnaccessDenied: mysql.Message("%-.16s command denied to user '%-.48s'@'%-.64s' for column '%-.192s' in table '%-.192s'", nil),
+ ErrIllegalGrantForTable: mysql.Message("Illegal GRANT/REVOKE command; please consult the manual to see which privileges can be used", nil),
+ ErrGrantWrongHostOrUser: mysql.Message("The host or user argument to GRANT is too long", nil),
+ ErrNoSuchTable: mysql.Message("Table '%-.192s.%-.192s' doesn't exist", nil),
+ ErrNonexistingTableGrant: mysql.Message("There is no such grant defined for user '%-.48s' on host '%-.64s' on table '%-.192s'", nil),
+ ErrNotAllowedCommand: mysql.Message("The used command is not allowed with this MySQL version", nil),
+ ErrSyntax: mysql.Message("You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use", nil),
+ ErrDelayedCantChangeLock: mysql.Message("Delayed insert thread couldn't get requested lock for table %-.192s", nil),
+ ErrTooManyDelayedThreads: mysql.Message("Too many delayed threads in use", nil),
+ ErrAbortingConnection: mysql.Message("Aborted connection %d to db: '%-.192s' user: '%-.48s' (%-.64s)", nil),
+ ErrNetPacketTooLarge: mysql.Message("Got a packet bigger than 'maxAllowedPacket' bytes", nil),
+ ErrNetReadErrorFromPipe: mysql.Message("Got a read error from the connection pipe", nil),
+ ErrNetFcntl: mysql.Message("Got an error from fcntl()", nil),
+ ErrNetPacketsOutOfOrder: mysql.Message("Got packets out of order", nil),
+ ErrNetUncompress: mysql.Message("Couldn't uncompress communication packet", nil),
+ ErrNetRead: mysql.Message("Got an error reading communication packets", nil),
+ ErrNetReadInterrupted: mysql.Message("Got timeout reading communication packets", nil),
+ ErrNetErrorOnWrite: mysql.Message("Got an error writing communication packets", nil),
+ ErrNetWriteInterrupted: mysql.Message("Got timeout writing communication packets", nil),
+ ErrTooLongString: mysql.Message("Result string is longer than 'maxAllowedPacket' bytes", nil),
+ ErrTableCantHandleBlob: mysql.Message("The used table type doesn't support BLOB/TEXT columns", nil),
+ ErrTableCantHandleAutoIncrement: mysql.Message("The used table type doesn't support AUTOINCREMENT columns", nil),
+ ErrDelayedInsertTableLocked: mysql.Message("INSERT DELAYED can't be used with table '%-.192s' because it is locked with LOCK TABLES", nil),
+ ErrWrongColumnName: mysql.Message("Incorrect column name '%-.100s'", nil),
+ ErrWrongKeyColumn: mysql.Message("The used storage engine can't index column '%-.192s'", nil),
+ ErrWrongMrgTable: mysql.Message("Unable to open underlying table which is differently defined or of non-MyISAM type or doesn't exist", nil),
+ ErrDupUnique: mysql.Message("Can't write, because of unique constraint, to table '%-.192s'", nil),
+ ErrBlobKeyWithoutLength: mysql.Message("BLOB/TEXT column '%-.192s' used in key specification without a key length", nil),
+ ErrPrimaryCantHaveNull: mysql.Message("All parts of a PRIMARY KEY must be NOT NULL; if you need NULL in a key, use UNIQUE instead", nil),
+ ErrTooManyRows: mysql.Message("Result consisted of more than one row", nil),
+ ErrRequiresPrimaryKey: mysql.Message("This table type requires a primary key", nil),
+ ErrNoRaidCompiled: mysql.Message("This version of MySQL is not compiled with RAID support", nil),
+ ErrUpdateWithoutKeyInSafeMode: mysql.Message("You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column", nil),
+ ErrKeyDoesNotExist: mysql.Message("Key '%-.192s' doesn't exist in table '%-.192s'", nil),
+ ErrCheckNoSuchTable: mysql.Message("Can't open table", nil),
+ ErrCheckNotImplemented: mysql.Message("The storage engine for the table doesn't support %s", nil),
+ ErrCantDoThisDuringAnTransaction: mysql.Message("You are not allowed to execute this command in a transaction", nil),
+ ErrErrorDuringCommit: mysql.Message("Got error %d during COMMIT", nil),
+ ErrErrorDuringRollback: mysql.Message("Got error %d during ROLLBACK", nil),
+ ErrErrorDuringFlushLogs: mysql.Message("Got error %d during FLUSHLOGS", nil),
+ ErrErrorDuringCheckpoint: mysql.Message("Got error %d during CHECKPOINT", nil),
+ ErrNewAbortingConnection: mysql.Message("Aborted connection %d to db: '%-.192s' user: '%-.48s' host: '%-.64s' (%-.64s)", nil),
+ ErrDumpNotImplemented: mysql.Message("The storage engine for the table does not support binary table dump", nil),
+ ErrIndexRebuild: mysql.Message("Failed rebuilding the index of dumped table '%-.192s'", nil),
+ ErrFtMatchingKeyNotFound: mysql.Message("Can't find FULLTEXT index matching the column list", nil),
+ ErrLockOrActiveTransaction: mysql.Message("Can't execute the given command because you have active locked tables or an active transaction", nil),
+ ErrUnknownSystemVariable: mysql.Message("Unknown system variable '%-.64s'", nil),
+ ErrCrashedOnUsage: mysql.Message("Table '%-.192s' is marked as crashed and should be repaired", nil),
+ ErrCrashedOnRepair: mysql.Message("Table '%-.192s' is marked as crashed and last (automatic?) repair failed", nil),
+ ErrWarningNotCompleteRollback: mysql.Message("Some non-transactional changed tables couldn't be rolled back", nil),
+ ErrTransCacheFull: mysql.Message("Multi-statement transaction required more than 'maxBinlogCacheSize' bytes of storage; increase this mysqld variable and try again", nil),
+ ErrTooManyUserConnections: mysql.Message("User %-.64s already has more than 'maxUserConnections' active connections", nil),
+ ErrSetConstantsOnly: mysql.Message("You may only use constant expressions with SET", nil),
+ ErrLockWaitTimeout: mysql.Message("Lock wait timeout exceeded; try restarting transaction", nil),
+ ErrLockTableFull: mysql.Message("The total number of locks exceeds the lock table size", nil),
+ ErrReadOnlyTransaction: mysql.Message("Update locks cannot be acquired during a READ UNCOMMITTED transaction", nil),
+ ErrDropDBWithReadLock: mysql.Message("DROP DATABASE not allowed while thread is holding global read lock", nil),
+ ErrCreateDBWithReadLock: mysql.Message("CREATE DATABASE not allowed while thread is holding global read lock", nil),
+ ErrWrongArguments: mysql.Message("Incorrect arguments to %s", nil),
+ ErrNoPermissionToCreateUser: mysql.Message("'%-.48s'@'%-.64s' is not allowed to create new users", nil),
+ ErrUnionTablesInDifferentDir: mysql.Message("Incorrect table definition; all MERGE tables must be in the same database", nil),
+ ErrLockDeadlock: mysql.Message("Deadlock found when trying to get lock; try restarting transaction", nil),
+ ErrTableCantHandleFt: mysql.Message("The used table type doesn't support FULLTEXT indexes", nil),
+ ErrCannotAddForeign: mysql.Message("Cannot add foreign key constraint", nil),
+ ErrNoReferencedRow: mysql.Message("Cannot add or update a child row: a foreign key constraint fails", nil),
+ ErrRowIsReferenced: mysql.Message("Cannot delete or update a parent row: a foreign key constraint fails", nil),
+ ErrErrorWhenExecutingCommand: mysql.Message("Error when executing command %s: %-.128s", nil),
+ ErrWrongUsage: mysql.Message("Incorrect usage of %s and %s", nil),
+ ErrWrongNumberOfColumnsInSelect: mysql.Message("The used SELECT statements have a different number of columns", nil),
+ ErrCantUpdateWithReadlock: mysql.Message("Can't execute the query because you have a conflicting read lock", nil),
+ ErrMixingNotAllowed: mysql.Message("Mixing of transactional and non-transactional tables is disabled", nil),
+ ErrDupArgument: mysql.Message("Option '%s' used twice in statement", nil),
+ ErrUserLimitReached: mysql.Message("User '%-.64s' has exceeded the '%s' resource (current value: %d)", nil),
+ ErrSpecificAccessDenied: mysql.Message("Access denied; you need (at least one of) the %-.128s privilege(s) for this operation", nil),
+ ErrLocalVariable: mysql.Message("Variable '%-.64s' is a SESSION variable and can't be used with SET GLOBAL", nil),
+ ErrGlobalVariable: mysql.Message("Variable '%-.64s' is a GLOBAL variable and should be set with SET GLOBAL", nil),
+ ErrNoDefault: mysql.Message("Variable '%-.64s' doesn't have a default value", nil),
+ ErrWrongValueForVar: mysql.Message("Variable '%-.64s' can't be set to the value of '%-.200s'", nil),
+ ErrWrongTypeForVar: mysql.Message("Incorrect argument type to variable '%-.64s'", nil),
+ ErrVarCantBeRead: mysql.Message("Variable '%-.64s' can only be set, not read", nil),
+ ErrCantUseOptionHere: mysql.Message("Incorrect usage/placement of '%s'", nil),
+ ErrNotSupportedYet: mysql.Message("This version of TiDB doesn't yet support '%s'", nil),
+ ErrIncorrectGlobalLocalVar: mysql.Message("Variable '%-.192s' is a %s variable", nil),
+ ErrWrongFkDef: mysql.Message("Incorrect foreign key definition for '%-.192s': %s", nil),
+ ErrKeyRefDoNotMatchTableRef: mysql.Message("Key reference and table reference don't match", nil),
+ ErrOperandColumns: mysql.Message("Operand should contain %d column(s)", nil),
+ ErrSubqueryNo1Row: mysql.Message("Subquery returns more than 1 row", nil),
+ ErrUnknownStmtHandler: mysql.Message("Unknown prepared statement handler (%.*s) given to %s", nil),
+ ErrCorruptHelpDB: mysql.Message("Help database is corrupt or does not exist", nil),
+ ErrCyclicReference: mysql.Message("Cyclic reference on subqueries", nil),
+ ErrAutoConvert: mysql.Message("Converting column '%s' from %s to %s", nil),
+ ErrIllegalReference: mysql.Message("Reference '%-.64s' not supported (%s)", nil),
+ ErrDerivedMustHaveAlias: mysql.Message("Every derived table must have its own alias", nil),
+ ErrSelectReduced: mysql.Message("Select %d was reduced during optimization", nil),
+ ErrTablenameNotAllowedHere: mysql.Message("Table '%s' from one of the %ss cannot be used in %s", nil),
+ ErrNotSupportedAuthMode: mysql.Message("Client does not support authentication protocol requested by server; consider upgrading MySQL client", nil),
+ ErrSpatialCantHaveNull: mysql.Message("All parts of a SPATIAL index must be NOT NULL", nil),
+ ErrCollationCharsetMismatch: mysql.Message("COLLATION '%s' is not valid for CHARACTER SET '%s'", nil),
+ ErrTooBigForUncompress: mysql.Message("Uncompressed data size too large; the maximum size is %d (probably, length of uncompressed data was corrupted)", nil),
+ ErrZlibZMem: mysql.Message("ZLIB: Not enough memory", nil),
+ ErrZlibZBuf: mysql.Message("ZLIB: Not enough room in the output buffer (probably, length of uncompressed data was corrupted)", nil),
+ ErrZlibZData: mysql.Message("ZLIB: Input data corrupted", nil),
+ ErrCutValueGroupConcat: mysql.Message("Some rows were cut by GROUPCONCAT(%s)", []int{0}),
+ ErrWarnTooFewRecords: mysql.Message("Row %d doesn't contain data for all columns", nil),
+ ErrWarnTooManyRecords: mysql.Message("Row %d was truncated; it contained more data than there were input columns", nil),
+ ErrWarnNullToNotnull: mysql.Message("Column set to default value; NULL supplied to NOT NULL column '%s' at row %d", nil),
+ ErrWarnDataOutOfRange: mysql.Message("Out of range value for column '%s' at row %d", nil),
+ WarnDataTruncated: mysql.Message("Data truncated for column '%s' at row %d", nil),
+ ErrWarnUsingOtherHandler: mysql.Message("Using storage engine %s for table '%s'", nil),
+ ErrCantAggregate2collations: mysql.Message("Illegal mix of collations (%s,%s) and (%s,%s) for operation '%s'", nil),
+ ErrDropUser: mysql.Message("Cannot drop one or more of the requested users", nil),
+ ErrRevokeGrants: mysql.Message("Can't revoke all privileges for one or more of the requested users", nil),
+ ErrCantAggregate3collations: mysql.Message("Illegal mix of collations (%s,%s), (%s,%s), (%s,%s) for operation '%s'", nil),
+ ErrCantAggregateNcollations: mysql.Message("Illegal mix of collations for operation '%s'", nil),
+ ErrVariableIsNotStruct: mysql.Message("Variable '%-.64s' is not a variable component (can't be used as XXXX.variableName)", nil),
+ ErrUnknownCollation: mysql.Message("Unknown collation: '%-.64s'", nil),
+ ErrServerIsInSecureAuthMode: mysql.Message("Server is running in --secure-auth mode, but '%s'@'%s' has a password in the old format; please change the password to the new format", nil),
+ ErrWarnFieldResolved: mysql.Message("Field or reference '%-.192s%s%-.192s%s%-.192s' of SELECT #%d was resolved in SELECT #%d", nil),
+ ErrUntilCondIgnored: mysql.Message("SQL thread is not to be started so UNTIL options are ignored", nil),
+ ErrWrongNameForIndex: mysql.Message("Incorrect index name '%-.100s'", nil),
+ ErrWrongNameForCatalog: mysql.Message("Incorrect catalog name '%-.100s'", nil),
+ ErrWarnQcResize: mysql.Message("Query cache failed to set size %d; new query cache size is %d", nil),
+ ErrBadFtColumn: mysql.Message("Column '%-.192s' cannot be part of FULLTEXT index", nil),
+ ErrUnknownKeyCache: mysql.Message("Unknown key cache '%-.100s'", nil),
+ ErrWarnHostnameWontWork: mysql.Message("MySQL is started in --skip-name-resolve mode; you must restart it without this switch for this grant to work", nil),
+ ErrUnknownStorageEngine: mysql.Message("Unknown storage engine '%s'", nil),
+ ErrWarnDeprecatedSyntax: mysql.Message("'%s' is deprecated and will be removed in a future release. Please use %s instead", nil),
+ ErrNonUpdatableTable: mysql.Message("The target table %-.100s of the %s is not updatable", nil),
+ ErrFeatureDisabled: mysql.Message("The '%s' feature is disabled; you need MySQL built with '%s' to have it working", nil),
+ ErrOptionPreventsStatement: mysql.Message("The MySQL server is running with the %s option so it cannot execute this statement", nil),
+ ErrDuplicatedValueInType: mysql.Message("Column '%-.100s' has duplicated value '%-.64s' in %s", []int{1}),
+ ErrTruncatedWrongValue: mysql.Message("Truncated incorrect %-.64s value: '%-.128s'", []int{1}),
+ ErrTooMuchAutoTimestampCols: mysql.Message("Incorrect table definition; there can be only one TIMESTAMP column with CURRENTTIMESTAMP in DEFAULT or ON UPDATE clause", nil),
+ ErrInvalidOnUpdate: mysql.Message("Invalid ON UPDATE clause for '%-.192s' column", nil),
+ ErrUnsupportedPs: mysql.Message("This command is not supported in the prepared statement protocol yet", nil),
+ ErrGetErrmsg: mysql.Message("Got error %d '%-.100s' from %s", nil),
+ ErrGetTemporaryErrmsg: mysql.Message("Got temporary error %d '%-.100s' from %s", nil),
+ ErrUnknownTimeZone: mysql.Message("Unknown or incorrect time zone: '%-.64s'", nil),
+ ErrWarnInvalidTimestamp: mysql.Message("Invalid TIMESTAMP value in column '%s' at row %d", nil),
+ ErrInvalidCharacterString: mysql.Message("Invalid %s character string: '%.64s'", []int{1}),
+ ErrWarnAllowedPacketOverflowed: mysql.Message("Result of %s() was larger than max_allowed_packet (%d) - truncated", nil),
+ ErrConflictingDeclarations: mysql.Message("Conflicting declarations: '%s%s' and '%s%s'", nil),
+ ErrSpNoRecursiveCreate: mysql.Message("Can't create a %s from within another stored routine", nil),
+ ErrSpAlreadyExists: mysql.Message("%s %s already exists", nil),
+ ErrSpDoesNotExist: mysql.Message("%s %s does not exist", nil),
+ ErrSpDropFailed: mysql.Message("Failed to DROP %s %s", nil),
+ ErrSpStoreFailed: mysql.Message("Failed to CREATE %s %s", nil),
+ ErrSpLilabelMismatch: mysql.Message("%s with no matching label: %s", nil),
+ ErrSpLabelRedefine: mysql.Message("Redefining label %s", nil),
+ ErrSpLabelMismatch: mysql.Message("End-label %s without match", nil),
+ ErrSpUninitVar: mysql.Message("Referring to uninitialized variable %s", nil),
+ ErrSpBadselect: mysql.Message("PROCEDURE %s can't return a result set in the given context", nil),
+ ErrSpBadreturn: mysql.Message("RETURN is only allowed in a FUNCTION", nil),
+ ErrSpBadstatement: mysql.Message("%s is not allowed in stored procedures", nil),
+ ErrUpdateLogDeprecatedIgnored: mysql.Message("The update log is deprecated and replaced by the binary log; SET SQLLOGUPDATE has been ignored.", nil),
+ ErrUpdateLogDeprecatedTranslated: mysql.Message("The update log is deprecated and replaced by the binary log; SET SQLLOGUPDATE has been translated to SET SQLLOGBIN.", nil),
+ ErrQueryInterrupted: mysql.Message("Query execution was interrupted", nil),
+ ErrSpWrongNoOfArgs: mysql.Message("Incorrect number of arguments for %s %s; expected %d, got %d", nil),
+ ErrSpCondMismatch: mysql.Message("Undefined CONDITION: %s", nil),
+ ErrSpNoreturn: mysql.Message("No RETURN found in FUNCTION %s", nil),
+ ErrSpNoreturnend: mysql.Message("FUNCTION %s ended without RETURN", nil),
+ ErrSpBadCursorQuery: mysql.Message("Cursor statement must be a SELECT", nil),
+ ErrSpBadCursorSelect: mysql.Message("Cursor SELECT must not have INTO", nil),
+ ErrSpCursorMismatch: mysql.Message("Undefined CURSOR: %s", nil),
+ ErrSpCursorAlreadyOpen: mysql.Message("Cursor is already open", nil),
+ ErrSpCursorNotOpen: mysql.Message("Cursor is not open", nil),
+ ErrSpUndeclaredVar: mysql.Message("Undeclared variable: %s", nil),
+ ErrSpWrongNoOfFetchArgs: mysql.Message("Incorrect number of FETCH variables", nil),
+ ErrSpFetchNoData: mysql.Message("No data - zero rows fetched, selected, or processed", nil),
+ ErrSpDupParam: mysql.Message("Duplicate parameter: %s", nil),
+ ErrSpDupVar: mysql.Message("Duplicate variable: %s", nil),
+ ErrSpDupCond: mysql.Message("Duplicate condition: %s", nil),
+ ErrSpDupCurs: mysql.Message("Duplicate cursor: %s", nil),
+ ErrSpCantAlter: mysql.Message("Failed to ALTER %s %s", nil),
+ ErrSpSubselectNyi: mysql.Message("Subquery value not supported", nil),
+ ErrStmtNotAllowedInSfOrTrg: mysql.Message("%s is not allowed in stored function or trigger", nil),
+ ErrSpVarcondAfterCurshndlr: mysql.Message("Variable or condition declaration after cursor or handler declaration", nil),
+ ErrSpCursorAfterHandler: mysql.Message("Cursor declaration after handler declaration", nil),
+ ErrSpCaseNotFound: mysql.Message("Case not found for CASE statement", nil),
+ ErrFparserTooBigFile: mysql.Message("Configuration file '%-.192s' is too big", nil),
+ ErrFparserBadHeader: mysql.Message("Malformed file type header in file '%-.192s'", nil),
+ ErrFparserEOFInComment: mysql.Message("Unexpected end of file while parsing comment '%-.200s'", nil),
+ ErrFparserErrorInParameter: mysql.Message("Error while parsing parameter '%-.192s' (line: '%-.192s')", nil),
+ ErrFparserEOFInUnknownParameter: mysql.Message("Unexpected end of file while skipping unknown parameter '%-.192s'", nil),
+ ErrViewNoExplain: mysql.Message("EXPLAIN/SHOW can not be issued; lacking privileges for underlying table", nil),
+ ErrFrmUnknownType: mysql.Message("File '%-.192s' has unknown type '%-.64s' in its header", nil),
+ ErrWrongObject: mysql.Message("'%-.192s.%-.192s' is not %s", nil),
+ ErrNonupdateableColumn: mysql.Message("Column '%-.192s' is not updatable", nil),
+ ErrViewSelectDerived: mysql.Message("View's SELECT contains a subquery in the FROM clause", nil),
+ ErrViewSelectClause: mysql.Message("View's SELECT contains a '%s' clause", nil),
+ ErrViewSelectVariable: mysql.Message("View's SELECT contains a variable or parameter", nil),
+ ErrViewSelectTmptable: mysql.Message("View's SELECT refers to a temporary table '%-.192s'", nil),
+ ErrViewWrongList: mysql.Message("View's SELECT and view's field list have different column counts", nil),
+ ErrWarnViewMerge: mysql.Message("View merge algorithm can't be used here for now (assumed undefined algorithm)", nil),
+ ErrWarnViewWithoutKey: mysql.Message("View being updated does not have complete key of underlying table in it", nil),
+ ErrViewInvalid: mysql.Message("View '%-.192s.%-.192s' references invalid table(s) or column(s) or function(s) or definer/invoker of view lack rights to use them", nil),
+ ErrSpNoDropSp: mysql.Message("Can't drop or alter a %s from within another stored routine", nil),
+ ErrSpGotoInHndlr: mysql.Message("GOTO is not allowed in a stored procedure handler", nil),
+ ErrTrgAlreadyExists: mysql.Message("Trigger already exists", nil),
+ ErrTrgDoesNotExist: mysql.Message("Trigger does not exist", nil),
+ ErrTrgOnViewOrTempTable: mysql.Message("Trigger's '%-.192s' is view or temporary table", nil),
+ ErrTrgCantChangeRow: mysql.Message("Updating of %s row is not allowed in %strigger", nil),
+ ErrTrgNoSuchRowInTrg: mysql.Message("There is no %s row in %s trigger", nil),
+ ErrNoDefaultForField: mysql.Message("Field '%-.192s' doesn't have a default value", nil),
+ ErrDivisionByZero: mysql.Message("Division by 0", nil),
+ ErrTruncatedWrongValueForField: mysql.Message("Incorrect %-.32s value: '%-.128s' for column '%.192s' at row %d", []int{0, 1}),
+ ErrIllegalValueForType: mysql.Message("Illegal %s '%-.192s' value found during parsing", []int{1}),
+ ErrViewNonupdCheck: mysql.Message("CHECK OPTION on non-updatable view '%-.192s.%-.192s'", nil),
+ ErrViewCheckFailed: mysql.Message("CHECK OPTION failed '%-.192s.%-.192s'", nil),
+ ErrProcaccessDenied: mysql.Message("%-.16s command denied to user '%-.48s'@'%-.64s' for routine '%-.192s'", nil),
+ ErrRelayLogFail: mysql.Message("Failed purging old relay logs: %s", nil),
+ ErrPasswdLength: mysql.Message("Password hash should be a %d-digit hexadecimal number", nil),
+ ErrUnknownTargetBinlog: mysql.Message("Target log not found in binlog index", nil),
+ ErrIoErrLogIndexRead: mysql.Message("I/O error reading log index file", nil),
+ ErrBinlogPurgeProhibited: mysql.Message("Server configuration does not permit binlog purge", nil),
+ ErrFseekFail: mysql.Message("Failed on fseek()", nil),
+ ErrBinlogPurgeFatalErr: mysql.Message("Fatal error during log purge", nil),
+ ErrLogInUse: mysql.Message("A purgeable log is in use, will not purge", nil),
+ ErrLogPurgeUnknownErr: mysql.Message("Unknown error during log purge", nil),
+ ErrRelayLogInit: mysql.Message("Failed initializing relay log position: %s", nil),
+ ErrNoBinaryLogging: mysql.Message("You are not using binary logging", nil),
+ ErrReservedSyntax: mysql.Message("The '%-.64s' syntax is reserved for purposes internal to the MySQL server", nil),
+ ErrWsasFailed: mysql.Message("WSAStartup Failed", nil),
+ ErrDiffGroupsProc: mysql.Message("Can't handle procedures with different groups yet", nil),
+ ErrNoGroupForProc: mysql.Message("Select must have a group with this procedure", nil),
+ ErrOrderWithProc: mysql.Message("Can't use ORDER clause with this procedure", nil),
+ ErrLoggingProhibitChangingOf: mysql.Message("Binary logging and replication forbid changing the global server %s", nil),
+ ErrNoFileMapping: mysql.Message("Can't map file: %-.200s, errno: %d", nil),
+ ErrWrongMagic: mysql.Message("Wrong magic in %-.64s", nil),
+ ErrPsManyParam: mysql.Message("Prepared statement contains too many placeholders", nil),
+ ErrKeyPart0: mysql.Message("Key part '%-.192s' length cannot be 0", nil),
+ ErrViewChecksum: mysql.Message("View text checksum failed", nil),
+ ErrViewMultiupdate: mysql.Message("Can not modify more than one base table through a join view '%-.192s.%-.192s'", nil),
+ ErrViewNoInsertFieldList: mysql.Message("Can not insert into join view '%-.192s.%-.192s' without fields list", nil),
+ ErrViewDeleteMergeView: mysql.Message("Can not delete from join view '%-.192s.%-.192s'", nil),
+ ErrCannotUser: mysql.Message("Operation %s failed for %.256s", nil),
+ ErrXaerNota: mysql.Message("XAERNOTA: Unknown XID", nil),
+ ErrXaerInval: mysql.Message("XAERINVAL: Invalid arguments (or unsupported command)", nil),
+ ErrXaerRmfail: mysql.Message("XAERRMFAIL: The command cannot be executed when global transaction is in the %.64s state", nil),
+ ErrXaerOutside: mysql.Message("XAEROUTSIDE: Some work is done outside global transaction", nil),
+ ErrXaerRmerr: mysql.Message("XAERRMERR: Fatal error occurred in the transaction branch - check your data for consistency", nil),
+ ErrXaRbrollback: mysql.Message("XARBROLLBACK: Transaction branch was rolled back", nil),
+ ErrNonexistingProcGrant: mysql.Message("There is no such grant defined for user '%-.48s' on host '%-.64s' on routine '%-.192s'", nil),
+ ErrProcAutoGrantFail: mysql.Message("Failed to grant EXECUTE and ALTER ROUTINE privileges", nil),
+ ErrProcAutoRevokeFail: mysql.Message("Failed to revoke all privileges to dropped routine", nil),
+ ErrDataTooLong: mysql.Message("Data too long for column '%s' at row %d", nil),
+ ErrSpBadSQLstate: mysql.Message("Bad SQLSTATE: '%s'", nil),
+ ErrStartup: mysql.Message("%s: ready for connections.\nVersion: '%s' socket: '%s' port: %d %s", nil),
+ ErrLoadFromFixedSizeRowsToVar: mysql.Message("Can't load value from file with fixed size rows to variable", nil),
+ ErrCantCreateUserWithGrant: mysql.Message("You are not allowed to create a user with GRANT", nil),
+ ErrWrongValueForType: mysql.Message("Incorrect %-.32s value: '%-.128s' for function %-.32s", nil),
+ ErrTableDefChanged: mysql.Message("Table definition has changed, please retry transaction", nil),
+ ErrSpDupHandler: mysql.Message("Duplicate handler declared in the same block", nil),
+ ErrSpNotVarArg: mysql.Message("OUT or INOUT argument %d for routine %s is not a variable or NEW pseudo-variable in BEFORE trigger", nil),
+ ErrSpNoRetset: mysql.Message("Not allowed to return a result set from a %s", nil),
+ ErrCantCreateGeometryObject: mysql.Message("Cannot get geometry object from data you send to the GEOMETRY field", nil),
+ ErrFailedRoutineBreakBinlog: mysql.Message("A routine failed and has neither NO SQL nor READS SQL DATA in its declaration and binary logging is enabled; if non-transactional tables were updated, the binary log will miss their changes", nil),
+ ErrBinlogUnsafeRoutine: mysql.Message("This function has none of DETERMINISTIC, NO SQL, or READS SQL DATA in its declaration and binary logging is enabled (you *might* want to use the less safe logBinTrustFunctionCreators variable)", nil),
+ ErrBinlogCreateRoutineNeedSuper: mysql.Message("You do not have the SUPER privilege and binary logging is enabled (you *might* want to use the less safe logBinTrustFunctionCreators variable)", nil),
+ ErrExecStmtWithOpenCursor: mysql.Message("You can't execute a prepared statement which has an open cursor associated with it. Reset the statement to re-execute it.", nil),
+ ErrStmtHasNoOpenCursor: mysql.Message("The statement (%d) has no open cursor.", nil),
+ ErrCommitNotAllowedInSfOrTrg: mysql.Message("Explicit or implicit commit is not allowed in stored function or trigger.", nil),
+ ErrNoDefaultForViewField: mysql.Message("Field of view '%-.192s.%-.192s' underlying table doesn't have a default value", nil),
+ ErrSpNoRecursion: mysql.Message("Recursive stored functions and triggers are not allowed.", nil),
+ ErrTooBigScale: mysql.Message("Too big scale %d specified for column '%-.192s'. Maximum is %d.", nil),
+ ErrTooBigPrecision: mysql.Message("Too big precision %d specified for column '%-.192s'. Maximum is %d.", nil),
+ ErrMBiggerThanD: mysql.Message("For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column '%-.192s').", nil),
+ ErrWrongLockOfSystemTable: mysql.Message("You can't combine write-locking of system tables with other tables or lock types", nil),
+ ErrConnectToForeignDataSource: mysql.Message("Unable to connect to foreign data source: %.64s", nil),
+ ErrQueryOnForeignDataSource: mysql.Message("There was a problem processing the query on the foreign data source. Data source : %-.64s", nil),
+ ErrForeignDataSourceDoesntExist: mysql.Message("The foreign data source you are trying to reference does not exist. Data source : %-.64s", nil),
+ ErrForeignDataStringInvalidCantCreate: mysql.Message("Can't create federated table. The data source connection string '%-.64s' is not in the correct format", nil),
+ ErrForeignDataStringInvalid: mysql.Message("The data source connection string '%-.64s' is not in the correct format", nil),
+ ErrCantCreateFederatedTable: mysql.Message("Can't create federated table. Foreign data src : %-.64s", nil),
+ ErrTrgInWrongSchema: mysql.Message("Trigger in wrong schema", nil),
+ ErrStackOverrunNeedMore: mysql.Message("Thread stack overrun: %d bytes used of a %d byte stack, and %d bytes needed. Use 'mysqld --threadStack=#' to specify a bigger stack.", nil),
+ ErrTooLongBody: mysql.Message("Routine body for '%-.100s' is too long", nil),
+ ErrWarnCantDropDefaultKeycache: mysql.Message("Cannot drop default keycache", nil),
+ ErrTooBigDisplaywidth: mysql.Message("Display width out of range for column '%-.192s' (max = %d)", nil),
+ ErrXaerDupid: mysql.Message("XAERDUPID: The XID already exists", nil),
+ ErrDatetimeFunctionOverflow: mysql.Message("Datetime function: %-.32s field overflow", nil),
+ ErrCantUpdateUsedTableInSfOrTrg: mysql.Message("Can't update table '%-.192s' in stored function/trigger because it is already used by statement which invoked this stored function/trigger.", nil),
+ ErrViewPreventUpdate: mysql.Message("The definition of table '%-.192s' prevents operation %.192s on table '%-.192s'.", nil),
+ ErrPsNoRecursion: mysql.Message("The prepared statement contains a stored routine call that refers to that same statement. It's not allowed to execute a prepared statement in such a recursive manner", nil),
+ ErrSpCantSetAutocommit: mysql.Message("Not allowed to set autocommit from a stored function or trigger", nil),
+ ErrMalformedDefiner: mysql.Message("Definer is not fully qualified", nil),
+ ErrViewFrmNoUser: mysql.Message("View '%-.192s'.'%-.192s' has no definer information (old table format). Current user is used as definer. Please recreate the view!", nil),
+ ErrViewOtherUser: mysql.Message("You need the SUPER privilege for creation view with '%-.192s'@'%-.192s' definer", nil),
+ ErrNoSuchUser: mysql.Message("The user specified as a definer ('%-.64s'@'%-.64s') does not exist", nil),
+ ErrForbidSchemaChange: mysql.Message("Changing schema from '%-.192s' to '%-.192s' is not allowed.", nil),
+ ErrRowIsReferenced2: mysql.Message("Cannot delete or update a parent row: a foreign key constraint fails (%.192s)", nil),
+ ErrNoReferencedRow2: mysql.Message("Cannot add or update a child row: a foreign key constraint fails (%.192s)", nil),
+ ErrSpBadVarShadow: mysql.Message("Variable '%-.64s' must be quoted with `...`, or renamed", nil),
+ ErrTrgNoDefiner: mysql.Message("No definer attribute for trigger '%-.192s'.'%-.192s'. The trigger will be activated under the authorization of the invoker, which may have insufficient privileges. Please recreate the trigger.", nil),
+ ErrOldFileFormat: mysql.Message("'%-.192s' has an old format, you should re-create the '%s' object(s)", nil),
+ ErrSpRecursionLimit: mysql.Message("Recursive limit %d (as set by the maxSpRecursionDepth variable) was exceeded for routine %.192s", nil),
+ ErrSpProcTableCorrupt: mysql.Message("Failed to load routine %-.192s. The table mysql.proc is missing, corrupt, or contains bad data (internal code %d)", nil),
+ ErrSpWrongName: mysql.Message("Incorrect routine name '%-.192s'", nil),
+ ErrTableNeedsUpgrade: mysql.Message("Table upgrade required. Please do \"REPAIR TABLE `%-.32s`\"", nil),
+ ErrSpNoAggregate: mysql.Message("AGGREGATE is not supported for stored functions", nil),
+ ErrMaxPreparedStmtCountReached: mysql.Message("Can't create more than maxPreparedStmtCount statements (current value: %d)", nil),
+ ErrViewRecursive: mysql.Message("`%-.192s`.`%-.192s` contains view recursion", nil),
+ ErrNonGroupingFieldUsed: mysql.Message("Non-grouping field '%-.192s' is used in %-.64s clause", nil),
+ ErrTableCantHandleSpkeys: mysql.Message("The used table type doesn't support SPATIAL indexes", nil),
+ ErrNoTriggersOnSystemSchema: mysql.Message("Triggers can not be created on system tables", nil),
+ ErrRemovedSpaces: mysql.Message("Leading spaces are removed from name '%s'", nil),
+ ErrAutoincReadFailed: mysql.Message("Failed to read auto-increment value from storage engine", nil),
+ ErrUsername: mysql.Message("user name", nil),
+ ErrHostname: mysql.Message("host name", nil),
+ ErrWrongStringLength: mysql.Message("String '%-.70s' is too long for %s (should be no longer than %d)", nil),
+ ErrNonInsertableTable: mysql.Message("The target table %-.100s of the %s is not insertable-into", nil),
+ ErrAdminWrongMrgTable: mysql.Message("Table '%-.64s' is differently defined or of non-MyISAM type or doesn't exist", nil),
+ ErrTooHighLevelOfNestingForSelect: mysql.Message("Too high level of nesting for select", nil),
+ ErrNameBecomesEmpty: mysql.Message("Name '%-.64s' has become ''", nil),
+ ErrAmbiguousFieldTerm: mysql.Message("First character of the FIELDS TERMINATED string is ambiguous; please use non-optional and non-empty FIELDS ENCLOSED BY", nil),
+ ErrForeignServerExists: mysql.Message("The foreign server, %s, you are trying to create already exists.", nil),
+ ErrForeignServerDoesntExist: mysql.Message("The foreign server name you are trying to reference does not exist. Data source : %-.64s", nil),
+ ErrIllegalHaCreateOption: mysql.Message("Table storage engine '%-.64s' does not support the create option '%.64s'", nil),
+ ErrPartitionRequiresValues: mysql.Message("Syntax : %-.64s PARTITIONING requires definition of VALUES %-.64s for each partition", nil),
+ ErrPartitionWrongValues: mysql.Message("Only %-.64s PARTITIONING can use VALUES %-.64s in partition definition", []int{1}),
+ ErrPartitionMaxvalue: mysql.Message("MAXVALUE can only be used in last partition definition", nil),
+ ErrPartitionSubpartition: mysql.Message("Subpartitions can only be hash partitions and by key", nil),
+ ErrPartitionSubpartMix: mysql.Message("Must define subpartitions on all partitions if on one partition", nil),
+ ErrPartitionWrongNoPart: mysql.Message("Wrong number of partitions defined, mismatch with previous setting", nil),
+ ErrPartitionWrongNoSubpart: mysql.Message("Wrong number of subpartitions defined, mismatch with previous setting", nil),
+ ErrWrongExprInPartitionFunc: mysql.Message("Constant, random or timezone-dependent expressions in (sub)partitioning function are not allowed", nil),
+ ErrNoConstExprInRangeOrList: mysql.Message("Expression in RANGE/LIST VALUES must be constant", nil),
+ ErrFieldNotFoundPart: mysql.Message("Field in list of fields for partition function not found in table", nil),
+ ErrListOfFieldsOnlyInHash: mysql.Message("List of fields is only allowed in KEY partitions", nil),
+ ErrInconsistentPartitionInfo: mysql.Message("The partition info in the frm file is not consistent with what can be written into the frm file", nil),
+ ErrPartitionFuncNotAllowed: mysql.Message("The %-.192s function returns the wrong type", nil),
+ ErrPartitionsMustBeDefined: mysql.Message("For %-.64s partitions each partition must be defined", nil),
+ ErrRangeNotIncreasing: mysql.Message("VALUES LESS THAN value must be strictly increasing for each partition", nil),
+ ErrInconsistentTypeOfFunctions: mysql.Message("VALUES value must be of same type as partition function", nil),
+ ErrMultipleDefConstInListPart: mysql.Message("Multiple definition of same constant in list partitioning", nil),
+ ErrPartitionEntry: mysql.Message("Partitioning can not be used stand-alone in query", nil),
+ ErrMixHandler: mysql.Message("The mix of handlers in the partitions is not allowed in this version of MySQL", nil),
+ ErrPartitionNotDefined: mysql.Message("For the partitioned engine it is necessary to define all %-.64s", nil),
+ ErrTooManyPartitions: mysql.Message("Too many partitions (including subpartitions) were defined", nil),
+ ErrSubpartition: mysql.Message("It is only possible to mix RANGE/LIST partitioning with HASH/KEY partitioning for subpartitioning", nil),
+ ErrCantCreateHandlerFile: mysql.Message("Failed to create specific handler file", nil),
+ ErrBlobFieldInPartFunc: mysql.Message("A BLOB field is not allowed in partition function", nil),
+ ErrUniqueKeyNeedAllFieldsInPf: mysql.Message("A %-.192s must include all columns in the table's partitioning function", nil),
+ ErrNoParts: mysql.Message("Number of %-.64s = 0 is not an allowed value", []int{0}),
+ ErrPartitionMgmtOnNonpartitioned: mysql.Message("Partition management on a not partitioned table is not possible", nil),
+ ErrForeignKeyOnPartitioned: mysql.Message("Foreign key clause is not yet supported in conjunction with partitioning", nil),
+ ErrDropPartitionNonExistent: mysql.Message("Error in list of partitions to %-.64s", nil),
+ ErrDropLastPartition: mysql.Message("Cannot remove all partitions, use DROP TABLE instead", nil),
+ ErrCoalesceOnlyOnHashPartition: mysql.Message("COALESCE PARTITION can only be used on HASH/KEY partitions", nil),
+ ErrReorgHashOnlyOnSameNo: mysql.Message("REORGANIZE PARTITION can only be used to reorganize partitions not to change their numbers", nil),
+ ErrReorgNoParam: mysql.Message("REORGANIZE PARTITION without parameters can only be used on auto-partitioned tables using HASH PARTITIONs", nil),
+ ErrOnlyOnRangeListPartition: mysql.Message("%-.64s PARTITION can only be used on RANGE/LIST partitions", nil),
+ ErrAddPartitionSubpart: mysql.Message("Trying to Add partition(s) with wrong number of subpartitions", nil),
+ ErrAddPartitionNoNewPartition: mysql.Message("At least one partition must be added", nil),
+ ErrCoalescePartitionNoPartition: mysql.Message("At least one partition must be coalesced", nil),
+ ErrReorgPartitionNotExist: mysql.Message("More partitions to reorganize than there are partitions", nil),
+ ErrSameNamePartition: mysql.Message("Duplicate partition name %-.192s", nil),
+ ErrNoBinlog: mysql.Message("It is not allowed to shut off binlog on this command", nil),
+ ErrConsecutiveReorgPartitions: mysql.Message("When reorganizing a set of partitions they must be in consecutive order", nil),
+ ErrReorgOutsideRange: mysql.Message("Reorganize of range partitions cannot change total ranges except for last partition where it can extend the range", nil),
+ ErrPartitionFunctionFailure: mysql.Message("Partition function not supported in this version for this handler", nil),
+ ErrPartState: mysql.Message("Partition state cannot be defined from CREATE/ALTER TABLE", nil),
+ ErrLimitedPartRange: mysql.Message("The %-.64s handler only supports 32 bit integers in VALUES", nil),
+ ErrPluginIsNotLoaded: mysql.Message("Plugin '%-.192s' is not loaded", nil),
+ ErrWrongValue: mysql.Message("Incorrect %-.32s value: '%-.128s'", []int{1}),
+ ErrNoPartitionForGivenValue: mysql.Message("Table has no partition for value %-.64s", []int{0}),
+ ErrFilegroupOptionOnlyOnce: mysql.Message("It is not allowed to specify %s more than once", nil),
+ ErrCreateFilegroupFailed: mysql.Message("Failed to create %s", nil),
+ ErrDropFilegroupFailed: mysql.Message("Failed to drop %s", nil),
+ ErrTablespaceAutoExtend: mysql.Message("The handler doesn't support autoextend of tablespaces", nil),
+ ErrWrongSizeNumber: mysql.Message("A size parameter was incorrectly specified, either number or on the form 10M", nil),
+ ErrSizeOverflow: mysql.Message("The size number was correct but we don't allow the digit part to be more than 2 billion", nil),
+ ErrAlterFilegroupFailed: mysql.Message("Failed to alter: %s", nil),
+ ErrBinlogRowLoggingFailed: mysql.Message("Writing one row to the row-based binary log failed", nil),
+ ErrEventAlreadyExists: mysql.Message("Event '%-.192s' already exists", nil),
+ ErrEventStoreFailed: mysql.Message("Failed to store event %s. Error code %d from storage engine.", nil),
+ ErrEventDoesNotExist: mysql.Message("Unknown event '%-.192s'", nil),
+ ErrEventCantAlter: mysql.Message("Failed to alter event '%-.192s'", nil),
+ ErrEventDropFailed: mysql.Message("Failed to drop %s", nil),
+ ErrEventIntervalNotPositiveOrTooBig: mysql.Message("INTERVAL is either not positive or too big", nil),
+ ErrEventEndsBeforeStarts: mysql.Message("ENDS is either invalid or before STARTS", nil),
+ ErrEventExecTimeInThePast: mysql.Message("Event execution time is in the past. Event has been disabled", nil),
+ ErrEventOpenTableFailed: mysql.Message("Failed to open mysql.event", nil),
+ ErrEventNeitherMExprNorMAt: mysql.Message("No datetime expression provided", nil),
+ ErrObsoleteColCountDoesntMatchCorrupted: mysql.Message("Column count of mysql.%s is wrong. Expected %d, found %d. The table is probably corrupted", nil),
+ ErrObsoleteCannotLoadFromTable: mysql.Message("Cannot load from mysql.%s. The table is probably corrupted", nil),
+ ErrEventCannotDelete: mysql.Message("Failed to delete the event from mysql.event", nil),
+ ErrEventCompile: mysql.Message("Error during compilation of event's body", nil),
+ ErrEventSameName: mysql.Message("Same old and new event name", nil),
+ ErrEventDataTooLong: mysql.Message("Data for column '%s' too long", nil),
+ ErrDropIndexFk: mysql.Message("Cannot drop index '%-.192s': needed in a foreign key constraint", nil),
+ ErrWarnDeprecatedSyntaxWithVer: mysql.Message("The syntax '%s' is deprecated and will be removed in MySQL %s. Please use %s instead", nil),
+ ErrCantWriteLockLogTable: mysql.Message("You can't write-lock a log table. Only read access is possible", nil),
+ ErrCantLockLogTable: mysql.Message("You can't use locks with log tables.", nil),
+ ErrForeignDuplicateKeyOldUnused: mysql.Message("Upholding foreign key constraints for table '%.192s', entry '%-.192s', key %d would lead to a duplicate entry", nil),
+ ErrColCountDoesntMatchPleaseUpdate: mysql.Message("Column count of mysql.%s is wrong. Expected %d, found %d. Created with MySQL %d, now running %d. Please use mysqlUpgrade to fix this error.", nil),
+ ErrTempTablePreventsSwitchOutOfRbr: mysql.Message("Cannot switch out of the row-based binary log format when the session has open temporary tables", nil),
+ ErrStoredFunctionPreventsSwitchBinlogFormat: mysql.Message("Cannot change the binary logging format inside a stored function or trigger", nil),
+ ErrNdbCantSwitchBinlogFormat: mysql.Message("The NDB cluster engine does not support changing the binlog format on the fly yet", nil),
+ ErrPartitionNoTemporary: mysql.Message("Cannot create temporary table with partitions", nil),
+ ErrPartitionConstDomain: mysql.Message("Partition constant is out of partition function domain", nil),
+ ErrPartitionFunctionIsNotAllowed: mysql.Message("This partition function is not allowed", nil),
+ ErrDdlLog: mysql.Message("Error in DDL log", nil),
+ ErrNullInValuesLessThan: mysql.Message("Not allowed to use NULL value in VALUES LESS THAN", nil),
+ ErrWrongPartitionName: mysql.Message("Incorrect partition name", nil),
+ ErrCantChangeTxCharacteristics: mysql.Message("Transaction characteristics can't be changed while a transaction is in progress", nil),
+ ErrDupEntryAutoincrementCase: mysql.Message("ALTER TABLE causes autoIncrement resequencing, resulting in duplicate entry '%-.192s' for key '%-.192s'", nil),
+ ErrEventModifyQueue: mysql.Message("Internal scheduler error %d", nil),
+ ErrEventSetVar: mysql.Message("Error during starting/stopping of the scheduler. Error code %d", nil),
+ ErrPartitionMerge: mysql.Message("Engine cannot be used in partitioned tables", nil),
+ ErrCantActivateLog: mysql.Message("Cannot activate '%-.64s' log", nil),
+ ErrRbrNotAvailable: mysql.Message("The server was not built with row-based replication", nil),
+ ErrBase64Decode: mysql.Message("Decoding of base64 string failed", nil),
+ ErrEventRecursionForbidden: mysql.Message("Recursion of EVENT DDL statements is forbidden when body is present", nil),
+ ErrEventsDB: mysql.Message("Cannot proceed because system tables used by Event Scheduler were found damaged at server start", nil),
+ ErrOnlyIntegersAllowed: mysql.Message("Only integers allowed as number here", nil),
+ ErrUnsuportedLogEngine: mysql.Message("This storage engine cannot be used for log tables\"", nil),
+ ErrBadLogStatement: mysql.Message("You cannot '%s' a log table if logging is enabled", nil),
+ ErrCantRenameLogTable: mysql.Message("Cannot rename '%s'. When logging enabled, rename to/from log table must rename two tables: the log table to an archive table and another table back to '%s'", nil),
+ ErrWrongParamcountToNativeFct: mysql.Message("Incorrect parameter count in the call to native function '%-.192s'", nil),
+ ErrWrongParametersToNativeFct: mysql.Message("Incorrect parameters in the call to native function '%-.192s'", nil),
+ ErrWrongParametersToStoredFct: mysql.Message("Incorrect parameters in the call to stored function '%-.192s'", nil),
+ ErrNativeFctNameCollision: mysql.Message("This function '%-.192s' has the same name as a native function", nil),
+ ErrDupEntryWithKeyName: mysql.Message("Duplicate entry '%-.64s' for key '%-.192s'", nil),
+ ErrBinlogPurgeEmFile: mysql.Message("Too many files opened, please execute the command again", nil),
+ ErrEventCannotCreateInThePast: mysql.Message("Event execution time is in the past and ON COMPLETION NOT PRESERVE is set. The event was dropped immediately after creation.", nil),
+ ErrEventCannotAlterInThePast: mysql.Message("Event execution time is in the past and ON COMPLETION NOT PRESERVE is set. The event was not changed. Specify a time in the future.", nil),
+ ErrNoPartitionForGivenValueSilent: mysql.Message("Table has no partition for some existing values", nil),
+ ErrBinlogUnsafeStatement: mysql.Message("Unsafe statement written to the binary log using statement format since BINLOGFORMAT = STATEMENT. %s", nil),
+ ErrBinlogLoggingImpossible: mysql.Message("Binary logging not possible. Message: %s", nil),
+ ErrViewNoCreationCtx: mysql.Message("View `%-.64s`.`%-.64s` has no creation context", nil),
+ ErrViewInvalidCreationCtx: mysql.Message("Creation context of view `%-.64s`.`%-.64s' is invalid", nil),
+ ErrSrInvalidCreationCtx: mysql.Message("Creation context of stored routine `%-.64s`.`%-.64s` is invalid", nil),
+ ErrTrgCorruptedFile: mysql.Message("Corrupted TRG file for table `%-.64s`.`%-.64s`", nil),
+ ErrTrgNoCreationCtx: mysql.Message("Triggers for table `%-.64s`.`%-.64s` have no creation context", nil),
+ ErrTrgInvalidCreationCtx: mysql.Message("Trigger creation context of table `%-.64s`.`%-.64s` is invalid", nil),
+ ErrEventInvalidCreationCtx: mysql.Message("Creation context of event `%-.64s`.`%-.64s` is invalid", nil),
+ ErrTrgCantOpenTable: mysql.Message("Cannot open table for trigger `%-.64s`.`%-.64s`", nil),
+ ErrCantCreateSroutine: mysql.Message("Cannot create stored routine `%-.64s`. Check warnings", nil),
+ ErrNoFormatDescriptionEventBeforeBinlogStatement: mysql.Message("The BINLOG statement of type `%s` was not preceded by a format description BINLOG statement.", nil),
+ ErrLoadDataInvalidColumn: mysql.Message("Invalid column reference (%-.64s) in LOAD DATA", nil),
+ ErrLogPurgeNoFile: mysql.Message("Being purged log %s was not found", nil),
+ ErrXaRbtimeout: mysql.Message("XARBTIMEOUT: Transaction branch was rolled back: took too long", nil),
+ ErrXaRbdeadlock: mysql.Message("XARBDEADLOCK: Transaction branch was rolled back: deadlock was detected", nil),
+ ErrNeedReprepare: mysql.Message("Prepared statement needs to be re-prepared", nil),
+ ErrDelayedNotSupported: mysql.Message("DELAYED option not supported for table '%-.192s'", nil),
+ WarnOptionIgnored: mysql.Message("<%-.64s> option ignored", nil),
+ WarnPluginDeleteBuiltin: mysql.Message("Built-in plugins cannot be deleted", nil),
+ WarnPluginBusy: mysql.Message("Plugin is busy and will be uninstalled on shutdown", nil),
+ ErrVariableIsReadonly: mysql.Message("%s variable '%s' is read-only. Use SET %s to assign the value", nil),
+ ErrWarnEngineTransactionRollback: mysql.Message("Storage engine %s does not support rollback for this statement. Transaction rolled back and must be restarted", nil),
+ ErrNdbReplicationSchema: mysql.Message("Bad schema for mysql.ndbReplication table. Message: %-.64s", nil),
+ ErrConflictFnParse: mysql.Message("Error in parsing conflict function. Message: %-.64s", nil),
+ ErrExceptionsWrite: mysql.Message("Write to exceptions table failed. Message: %-.128s\"", nil),
+ ErrTooLongTableComment: mysql.Message("Comment for table '%-.64s' is too long (max = %d)", nil),
+ ErrTooLongFieldComment: mysql.Message("Comment for field '%-.64s' is too long (max = %d)", nil),
+ ErrFuncInexistentNameCollision: mysql.Message("FUNCTION %s does not exist. Check the 'Function Name Parsing and Resolution' section in the Reference Manual", nil),
+ ErrDatabaseName: mysql.Message("Database", nil),
+ ErrTableName: mysql.Message("Table", nil),
+ ErrPartitionName: mysql.Message("Partition", nil),
+ ErrSubpartitionName: mysql.Message("Subpartition", nil),
+ ErrTemporaryName: mysql.Message("Temporary", nil),
+ ErrRenamedName: mysql.Message("Renamed", nil),
+ ErrTooManyConcurrentTrxs: mysql.Message("Too many active concurrent transactions", nil),
+ WarnNonASCIISeparatorNotImplemented: mysql.Message("Non-ASCII separator arguments are not fully supported", nil),
+ ErrDebugSyncTimeout: mysql.Message("debug sync point wait timed out", nil),
+ ErrDebugSyncHitLimit: mysql.Message("debug sync point hit limit reached", nil),
+ ErrDupSignalSet: mysql.Message("Duplicate condition information item '%s'", nil),
+ ErrSignalWarn: mysql.Message("Unhandled user-defined warning condition", nil),
+ ErrSignalNotFound: mysql.Message("Unhandled user-defined not found condition", nil),
+ ErrSignalException: mysql.Message("Unhandled user-defined exception condition", nil),
+ ErrResignalWithoutActiveHandler: mysql.Message("RESIGNAL when handler not active", nil),
+ ErrSignalBadConditionType: mysql.Message("SIGNAL/RESIGNAL can only use a CONDITION defined with SQLSTATE", nil),
+ WarnCondItemTruncated: mysql.Message("Data truncated for condition item '%s'", nil),
+ ErrCondItemTooLong: mysql.Message("Data too long for condition item '%s'", nil),
+ ErrUnknownLocale: mysql.Message("Unknown locale: '%-.64s'", nil),
+ ErrQueryCacheDisabled: mysql.Message("Query cache is disabled; restart the server with queryCacheType=1 to enable it", nil),
+ ErrSameNamePartitionField: mysql.Message("Duplicate partition field name '%-.192s'", nil),
+ ErrPartitionColumnList: mysql.Message("Inconsistency in usage of column lists for partitioning", nil),
+ ErrWrongTypeColumnValue: mysql.Message("Partition column values of incorrect type", nil),
+ ErrTooManyPartitionFuncFields: mysql.Message("Too many fields in '%-.192s'", nil),
+ ErrMaxvalueInValuesIn: mysql.Message("Cannot use MAXVALUE as value in VALUES IN", nil),
+ ErrTooManyValues: mysql.Message("Cannot have more than one value for this type of %-.64s partitioning", nil),
+ ErrRowSinglePartitionField: mysql.Message("Row expressions in VALUES IN only allowed for multi-field column partitioning", nil),
+ ErrFieldTypeNotAllowedAsPartitionField: mysql.Message("Field '%-.192s' is of a not allowed type for this type of partitioning", nil),
+ ErrPartitionFieldsTooLong: mysql.Message("The total length of the partitioning fields is too large", nil),
+ ErrBinlogRowEngineAndStmtEngine: mysql.Message("Cannot execute statement: impossible to write to binary log since both row-incapable engines and statement-incapable engines are involved.", nil),
+ ErrBinlogRowModeAndStmtEngine: mysql.Message("Cannot execute statement: impossible to write to binary log since BINLOGFORMAT = ROW and at least one table uses a storage engine limited to statement-based logging.", nil),
+ ErrBinlogUnsafeAndStmtEngine: mysql.Message("Cannot execute statement: impossible to write to binary log since statement is unsafe, storage engine is limited to statement-based logging, and BINLOGFORMAT = MIXED. %s", nil),
+ ErrBinlogRowInjectionAndStmtEngine: mysql.Message("Cannot execute statement: impossible to write to binary log since statement is in row format and at least one table uses a storage engine limited to statement-based logging.", nil),
+ ErrBinlogStmtModeAndRowEngine: mysql.Message("Cannot execute statement: impossible to write to binary log since BINLOGFORMAT = STATEMENT and at least one table uses a storage engine limited to row-based logging.%s", nil),
+ ErrBinlogRowInjectionAndStmtMode: mysql.Message("Cannot execute statement: impossible to write to binary log since statement is in row format and BINLOGFORMAT = STATEMENT.", nil),
+ ErrBinlogMultipleEnginesAndSelfLoggingEngine: mysql.Message("Cannot execute statement: impossible to write to binary log since more than one engine is involved and at least one engine is self-logging.", nil),
+ ErrBinlogUnsafeLimit: mysql.Message("The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted.", nil),
+ ErrBinlogUnsafeInsertDelayed: mysql.Message("The statement is unsafe because it uses INSERT DELAYED. This is unsafe because the times when rows are inserted cannot be predicted.", nil),
+ ErrBinlogUnsafeAutoincColumns: mysql.Message("Statement is unsafe because it invokes a trigger or a stored function that inserts into an AUTOINCREMENT column. Inserted values cannot be logged correctly.", nil),
+ ErrBinlogUnsafeNontransAfterTrans: mysql.Message("Statement is unsafe because it accesses a non-transactional table after accessing a transactional table within the same transaction.", nil),
+ ErrMessageAndStatement: mysql.Message("%s Statement: %s", nil),
+ ErrInsideTransactionPreventsSwitchBinlogFormat: mysql.Message("Cannot modify @@session.binlogFormat inside a transaction", nil),
+ ErrPathLength: mysql.Message("The path specified for %.64s is too long.", nil),
+ ErrWarnDeprecatedSyntaxNoReplacement: mysql.Message("'%s' is deprecated and will be removed in a future release.", nil),
+ ErrWrongNativeTableStructure: mysql.Message("Native table '%-.64s'.'%-.64s' has the wrong structure", nil),
+ ErrWrongPerfSchemaUsage: mysql.Message("Invalid performanceSchema usage.", nil),
+ ErrWarnISSkippedTable: mysql.Message("Table '%s'.'%s' was skipped since its definition is being modified by concurrent DDL statement", nil),
+ ErrInsideTransactionPreventsSwitchBinlogDirect: mysql.Message("Cannot modify @@session.binlogDirectNonTransactionalUpdates inside a transaction", nil),
+ ErrStoredFunctionPreventsSwitchBinlogDirect: mysql.Message("Cannot change the binlog direct flag inside a stored function or trigger", nil),
+ ErrSpatialMustHaveGeomCol: mysql.Message("A SPATIAL index may only contain a geometrical type column", nil),
+ ErrTooLongIndexComment: mysql.Message("Comment for index '%-.64s' is too long (max = %d)", nil),
+ ErrLockAborted: mysql.Message("Wait on a lock was aborted due to a pending exclusive lock", nil),
+ ErrDataOutOfRange: mysql.Message("%s value is out of range in '%s'", []int{1}),
+ ErrWrongSpvarTypeInLimit: mysql.Message("A variable of a non-integer based type in LIMIT clause", nil),
+ ErrBinlogUnsafeMultipleEnginesAndSelfLoggingEngine: mysql.Message("Mixing self-logging and non-self-logging engines in a statement is unsafe.", nil),
+ ErrBinlogUnsafeMixedStatement: mysql.Message("Statement accesses nontransactional table as well as transactional or temporary table, and writes to any of them.", nil),
+ ErrInsideTransactionPreventsSwitchSQLLogBin: mysql.Message("Cannot modify @@session.sqlLogBin inside a transaction", nil),
+ ErrStoredFunctionPreventsSwitchSQLLogBin: mysql.Message("Cannot change the sqlLogBin inside a stored function or trigger", nil),
+ ErrFailedReadFromParFile: mysql.Message("Failed to read from the .par file", nil),
+ ErrValuesIsNotIntType: mysql.Message("VALUES value for partition '%-.64s' must have type INT", nil),
+ ErrAccessDeniedNoPassword: mysql.Message("Access denied for user '%-.48s'@'%-.64s'", nil),
+ ErrSetPasswordAuthPlugin: mysql.Message("SET PASSWORD has no significance for users authenticating via plugins", nil),
+ ErrGrantPluginUserExists: mysql.Message("GRANT with IDENTIFIED WITH is illegal because the user %-.*s already exists", nil),
+ ErrTruncateIllegalFk: mysql.Message("Cannot truncate a table referenced in a foreign key constraint (%.192s)", nil),
+ ErrPluginIsPermanent: mysql.Message("Plugin '%s' is forcePlusPermanent and can not be unloaded", nil),
+ ErrStmtCacheFull: mysql.Message("Multi-row statements required more than 'maxBinlogStmtCacheSize' bytes of storage; increase this mysqld variable and try again", nil),
+ ErrMultiUpdateKeyConflict: mysql.Message("Primary key/partition key update is not allowed since the table is updated both as '%-.192s' and '%-.192s'.", nil),
+ ErrTableNeedsRebuild: mysql.Message("Table rebuild required. Please do \"ALTER TABLE `%-.32s` FORCE\" or dump/reload to fix it!", nil),
+ WarnOptionBelowLimit: mysql.Message("The value of '%s' should be no less than the value of '%s'", nil),
+ ErrIndexColumnTooLong: mysql.Message("Index column size too large. The maximum column size is %d bytes.", nil),
+ ErrErrorInTriggerBody: mysql.Message("Trigger '%-.64s' has an error in its body: '%-.256s'", nil),
+ ErrErrorInUnknownTriggerBody: mysql.Message("Unknown trigger has an error in its body: '%-.256s'", nil),
+ ErrIndexCorrupt: mysql.Message("Index %s is corrupted", nil),
+ ErrUndoRecordTooBig: mysql.Message("Undo log record is too big.", nil),
+ ErrPluginNoUninstall: mysql.Message("Plugin '%s' is marked as not dynamically uninstallable. You have to stop the server to uninstall it.", nil),
+ ErrPluginNoInstall: mysql.Message("Plugin '%s' is marked as not dynamically installable. You have to stop the server to install it.", nil),
+ ErrBinlogUnsafeInsertTwoKeys: mysql.Message("INSERT... ON DUPLICATE KEY UPDATE on a table with more than one UNIQUE KEY is unsafe", nil),
+ ErrTableInFkCheck: mysql.Message("Table is being used in foreign key check.", nil),
+ ErrUnsupportedEngine: mysql.Message("Storage engine '%s' does not support system tables. [%s.%s]", nil),
+ ErrBinlogUnsafeAutoincNotFirst: mysql.Message("INSERT into autoincrement field which is not the first part in the composed primary key is unsafe.", nil),
+ ErrCannotLoadFromTableV2: mysql.Message("Cannot load from %s.%s. The table is probably corrupted", nil),
+ ErrOnlyFdAndRbrEventsAllowedInBinlogStatement: mysql.Message("Only FormatDescriptionLogEvent and row events are allowed in BINLOG statements (but %s was provided)", nil),
+ ErrPartitionExchangeDifferentOption: mysql.Message("Non matching attribute '%-.64s' between partition and table", nil),
+ ErrPartitionExchangePartTable: mysql.Message("Table to exchange with partition is partitioned: '%-.64s'", nil),
+ ErrPartitionExchangeTempTable: mysql.Message("Table to exchange with partition is temporary: '%-.64s'", nil),
+ ErrPartitionInsteadOfSubpartition: mysql.Message("Subpartitioned table, use subpartition instead of partition", nil),
+ ErrUnknownPartition: mysql.Message("Unknown partition '%-.64s' in table '%-.64s'", nil),
+ ErrTablesDifferentMetadata: mysql.Message("Tables have different definitions", nil),
+ ErrRowDoesNotMatchPartition: mysql.Message("Found a row that does not match the partition", nil),
+ ErrBinlogCacheSizeGreaterThanMax: mysql.Message("Option binlogCacheSize (%d) is greater than maxBinlogCacheSize (%d); setting binlogCacheSize equal to maxBinlogCacheSize.", nil),
+ ErrWarnIndexNotApplicable: mysql.Message("Cannot use %-.64s access on index '%-.64s' due to type or collation conversion on field '%-.64s'", nil),
+ ErrPartitionExchangeForeignKey: mysql.Message("Table to exchange with partition has foreign key references: '%-.64s'", nil),
+ ErrNoSuchKeyValue: mysql.Message("Key value '%-.192s' was not found in table '%-.192s.%-.192s'", nil),
+ ErrRplInfoDataTooLong: mysql.Message("Data for column '%s' too long", nil),
+ ErrNetworkReadEventChecksumFailure: mysql.Message("Replication event checksum verification failed while reading from network.", nil),
+ ErrBinlogReadEventChecksumFailure: mysql.Message("Replication event checksum verification failed while reading from a log file.", nil),
+ ErrBinlogStmtCacheSizeGreaterThanMax: mysql.Message("Option binlogStmtCacheSize (%d) is greater than maxBinlogStmtCacheSize (%d); setting binlogStmtCacheSize equal to maxBinlogStmtCacheSize.", nil),
+ ErrCantUpdateTableInCreateTableSelect: mysql.Message("Can't update table '%-.192s' while '%-.192s' is being created.", nil),
+ ErrPartitionClauseOnNonpartitioned: mysql.Message("PARTITION () clause on non partitioned table", nil),
+ ErrRowDoesNotMatchGivenPartitionSet: mysql.Message("Found a row not matching the given partition set", nil),
+ ErrNoSuchPartitionunused: mysql.Message("partition '%-.64s' doesn't exist", nil),
+ ErrChangeRplInfoRepositoryFailure: mysql.Message("Failure while changing the type of replication repository: %s.", nil),
+ ErrWarningNotCompleteRollbackWithCreatedTempTable: mysql.Message("The creation of some temporary tables could not be rolled back.", nil),
+ ErrWarningNotCompleteRollbackWithDroppedTempTable: mysql.Message("Some temporary tables were dropped, but these operations could not be rolled back.", nil),
+ ErrMtsUpdatedDBsGreaterMax: mysql.Message("The number of modified databases exceeds the maximum %d; the database names will not be included in the replication event metadata.", nil),
+ ErrMtsCantParallel: mysql.Message("Cannot execute the current event group in the parallel mode. Encountered event %s, relay-log name %s, position %s which prevents execution of this event group in parallel mode. Reason: %s.", nil),
+ ErrMtsInconsistentData: mysql.Message("%s", nil),
+ ErrFulltextNotSupportedWithPartitioning: mysql.Message("FULLTEXT index is not supported for partitioned tables.", nil),
+ ErrDaInvalidConditionNumber: mysql.Message("Invalid condition number", nil),
+ ErrInsecurePlainText: mysql.Message("Sending passwords in plain text without SSL/TLS is extremely insecure.", nil),
+ ErrForeignDuplicateKeyWithChildInfo: mysql.Message("Foreign key constraint for table '%.192s', record '%-.192s' would lead to a duplicate entry in table '%.192s', key '%.192s'", nil),
+ ErrForeignDuplicateKeyWithoutChildInfo: mysql.Message("Foreign key constraint for table '%.192s', record '%-.192s' would lead to a duplicate entry in a child table", nil),
+ ErrTableHasNoFt: mysql.Message("The table does not have FULLTEXT index to support this query", nil),
+ ErrVariableNotSettableInSfOrTrigger: mysql.Message("The system variable %.200s cannot be set in stored functions or triggers.", nil),
+ ErrVariableNotSettableInTransaction: mysql.Message("The system variable %.200s cannot be set when there is an ongoing transaction.", nil),
+ ErrGtidNextIsNotInGtidNextList: mysql.Message("The system variable @@SESSION.GTIDNEXT has the value %.200s, which is not listed in @@SESSION.GTIDNEXTLIST.", nil),
+ ErrCantChangeGtidNextInTransactionWhenGtidNextListIsNull: mysql.Message("When @@SESSION.GTIDNEXTLIST == NULL, the system variable @@SESSION.GTIDNEXT cannot change inside a transaction.", nil),
+ ErrSetStatementCannotInvokeFunction: mysql.Message("The statement 'SET %.200s' cannot invoke a stored function.", nil),
+ ErrGtidNextCantBeAutomaticIfGtidNextListIsNonNull: mysql.Message("The system variable @@SESSION.GTIDNEXT cannot be 'AUTOMATIC' when @@SESSION.GTIDNEXTLIST is non-NULL.", nil),
+ ErrSkippingLoggedTransaction: mysql.Message("Skipping transaction %.200s because it has already been executed and logged.", nil),
+ ErrMalformedGtidSetSpecification: mysql.Message("Malformed GTID set specification '%.200s'.", nil),
+ ErrMalformedGtidSetEncoding: mysql.Message("Malformed GTID set encoding.", nil),
+ ErrMalformedGtidSpecification: mysql.Message("Malformed GTID specification '%.200s'.", nil),
+ ErrGnoExhausted: mysql.Message("Impossible to generate Global Transaction Identifier: the integer component reached the maximal value. Restart the server with a new serverUuid.", nil),
+ ErrCantDoImplicitCommitInTrxWhenGtidNextIsSet: mysql.Message("Cannot execute statements with implicit commit inside a transaction when @@SESSION.GTIDNEXT != AUTOMATIC or @@SESSION.GTIDNEXTLIST != NULL.", nil),
+ ErrGtidMode2Or3RequiresEnforceGtidConsistencyOn: mysql.Message("@@GLOBAL.GTIDMODE = ON or UPGRADESTEP2 requires @@GLOBAL.ENFORCEGTIDCONSISTENCY = 1.", nil),
+ ErrCantSetGtidNextToGtidWhenGtidModeIsOff: mysql.Message("@@SESSION.GTIDNEXT cannot be set to UUID:NUMBER when @@GLOBAL.GTIDMODE = OFF.", nil),
+ ErrCantSetGtidNextToAnonymousWhenGtidModeIsOn: mysql.Message("@@SESSION.GTIDNEXT cannot be set to ANONYMOUS when @@GLOBAL.GTIDMODE = ON.", nil),
+ ErrCantSetGtidNextListToNonNullWhenGtidModeIsOff: mysql.Message("@@SESSION.GTIDNEXTLIST cannot be set to a non-NULL value when @@GLOBAL.GTIDMODE = OFF.", nil),
+ ErrFoundGtidEventWhenGtidModeIsOff: mysql.Message("Found a GtidLogEvent or PreviousGtidsLogEvent when @@GLOBAL.GTIDMODE = OFF.", nil),
+ ErrGtidUnsafeNonTransactionalTable: mysql.Message("When @@GLOBAL.ENFORCEGTIDCONSISTENCY = 1, updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables.", nil),
+ ErrGtidUnsafeCreateSelect: mysql.Message("CREATE TABLE ... SELECT is forbidden when @@GLOBAL.ENFORCEGTIDCONSISTENCY = 1.", nil),
+ ErrGtidUnsafeCreateDropTemporaryTableInTransaction: mysql.Message("When @@GLOBAL.ENFORCEGTIDCONSISTENCY = 1, the statements CREATE TEMPORARY TABLE and DROP TEMPORARY TABLE can be executed in a non-transactional context only, and require that AUTOCOMMIT = 1.", nil),
+ ErrGtidModeCanOnlyChangeOneStepAtATime: mysql.Message("The value of @@GLOBAL.GTIDMODE can only change one step at a time: OFF <-> UPGRADESTEP1 <-> UPGRADESTEP2 <-> ON. Also note that this value must be stepped up or down simultaneously on all servers; see the Manual for instructions.", nil),
+ ErrCantSetGtidNextWhenOwningGtid: mysql.Message("@@SESSION.GTIDNEXT cannot be changed by a client that owns a GTID. The client owns %s. Ownership is released on COMMIT or ROLLBACK.", nil),
+ ErrUnknownExplainFormat: mysql.Message("Unknown EXPLAIN format name: '%s'", nil),
+ ErrCantExecuteInReadOnlyTransaction: mysql.Message("Cannot execute statement in a READ ONLY transaction.", nil),
+ ErrTooLongTablePartitionComment: mysql.Message("Comment for table partition '%-.64s' is too long (max = %d)", nil),
+ ErrInnodbFtLimit: mysql.Message("InnoDB presently supports one FULLTEXT index creation at a time", nil),
+ ErrInnodbNoFtTempTable: mysql.Message("Cannot create FULLTEXT index on temporary InnoDB table", nil),
+ ErrInnodbFtWrongDocidColumn: mysql.Message("Column '%-.192s' is of wrong type for an InnoDB FULLTEXT index", nil),
+ ErrInnodbFtWrongDocidIndex: mysql.Message("Index '%-.192s' is of wrong type for an InnoDB FULLTEXT index", nil),
+ ErrInnodbOnlineLogTooBig: mysql.Message("Creating index '%-.192s' required more than 'innodbOnlineAlterLogMaxSize' bytes of modification log. Please try again.", nil),
+ ErrUnknownAlterAlgorithm: mysql.Message("Unknown ALGORITHM '%s'", nil),
+ ErrUnknownAlterLock: mysql.Message("Unknown LOCK type '%s'", nil),
+ ErrMtsResetWorkers: mysql.Message("Cannot clean up worker info tables. Additional error messages can be found in the MySQL error log.", nil),
+ ErrColCountDoesntMatchCorruptedV2: mysql.Message("Column count of %s.%s is wrong. Expected %d, found %d. The table is probably corrupted", nil),
+ ErrDiscardFkChecksRunning: mysql.Message("There is a foreign key check running on table '%-.192s'. Cannot discard the table.", nil),
+ ErrTableSchemaMismatch: mysql.Message("Schema mismatch (%s)", nil),
+ ErrTableInSystemTablespace: mysql.Message("Table '%-.192s' in system tablespace", nil),
+ ErrIoRead: mysql.Message("IO Read : (%d, %s) %s", nil),
+ ErrIoWrite: mysql.Message("IO Write : (%d, %s) %s", nil),
+ ErrTablespaceMissing: mysql.Message("Tablespace is missing for table '%-.192s'", nil),
+ ErrTablespaceExists: mysql.Message("Tablespace for table '%-.192s' exists. Please DISCARD the tablespace before IMPORT.", nil),
+ ErrTablespaceDiscarded: mysql.Message("Tablespace has been discarded for table '%-.192s'", nil),
+ ErrInternal: mysql.Message("Internal : %s", nil),
+ ErrInnodbImport: mysql.Message("ALTER TABLE '%-.192s' IMPORT TABLESPACE failed with error %d : '%s'", nil),
+ ErrInnodbIndexCorrupt: mysql.Message("Index corrupt: %s", nil),
+ ErrInvalidYearColumnLength: mysql.Message("Supports only YEAR or YEAR(4) column", nil),
+ ErrNotValidPassword: mysql.Message("Your password does not satisfy the current policy requirements", nil),
+ ErrMustChangePassword: mysql.Message("You must SET PASSWORD before executing this statement", nil),
+ ErrFkNoIndexChild: mysql.Message("Failed to add the foreign key constaint. Missing index for constraint '%s' in the foreign table '%s'", nil),
+ ErrFkNoIndexParent: mysql.Message("Failed to add the foreign key constaint. Missing index for constraint '%s' in the referenced table '%s'", nil),
+ ErrFkFailAddSystem: mysql.Message("Failed to add the foreign key constraint '%s' to system tables", nil),
+ ErrFkCannotOpenParent: mysql.Message("Failed to open the referenced table '%s'", nil),
+ ErrFkIncorrectOption: mysql.Message("Failed to add the foreign key constraint on table '%s'. Incorrect options in FOREIGN KEY constraint '%s'", nil),
+ ErrFkDupName: mysql.Message("Duplicate foreign key constraint name '%s'", nil),
+ ErrPasswordFormat: mysql.Message("The password hash doesn't have the expected format. Check if the correct password algorithm is being used with the PASSWORD() function.", nil),
+ ErrFkColumnCannotDrop: mysql.Message("Cannot drop column '%-.192s': needed in a foreign key constraint '%-.192s'", nil),
+ ErrFkColumnCannotDropChild: mysql.Message("Cannot drop column '%-.192s': needed in a foreign key constraint '%-.192s' of table '%-.192s'", nil),
+ ErrFkColumnNotNull: mysql.Message("Column '%-.192s' cannot be NOT NULL: needed in a foreign key constraint '%-.192s' SET NULL", nil),
+ ErrDupIndex: mysql.Message("Duplicate index '%-.64s' defined on the table '%-.64s.%-.64s'. This is deprecated and will be disallowed in a future release.", nil),
+ ErrFkColumnCannotChange: mysql.Message("Cannot change column '%-.192s': used in a foreign key constraint '%-.192s'", nil),
+ ErrFkColumnCannotChangeChild: mysql.Message("Cannot change column '%-.192s': used in a foreign key constraint '%-.192s' of table '%-.192s'", nil),
+ ErrFkCannotDeleteParent: mysql.Message("Cannot delete rows from table which is parent in a foreign key constraint '%-.192s' of table '%-.192s'", nil),
+ ErrMalformedPacket: mysql.Message("Malformed communication packet.", nil),
+ ErrReadOnlyMode: mysql.Message("Running in read-only mode", nil),
+ ErrVariableNotSettableInSp: mysql.Message("The system variable %.200s cannot be set in stored procedures.", nil),
+ ErrCantSetGtidPurgedWhenGtidModeIsOff: mysql.Message("@@GLOBAL.GTIDPURGED can only be set when @@GLOBAL.GTIDMODE = ON.", nil),
+ ErrCantSetGtidPurgedWhenGtidExecutedIsNotEmpty: mysql.Message("@@GLOBAL.GTIDPURGED can only be set when @@GLOBAL.GTIDEXECUTED is empty.", nil),
+ ErrCantSetGtidPurgedWhenOwnedGtidsIsNotEmpty: mysql.Message("@@GLOBAL.GTIDPURGED can only be set when there are no ongoing transactions (not even in other clients).", nil),
+ ErrGtidPurgedWasChanged: mysql.Message("@@GLOBAL.GTIDPURGED was changed from '%s' to '%s'.", nil),
+ ErrGtidExecutedWasChanged: mysql.Message("@@GLOBAL.GTIDEXECUTED was changed from '%s' to '%s'.", nil),
+ ErrBinlogStmtModeAndNoReplTables: mysql.Message("Cannot execute statement: impossible to write to binary log since BINLOGFORMAT = STATEMENT, and both replicated and non replicated tables are written to.", nil),
+ ErrAlterOperationNotSupported: mysql.Message("%s is not supported for this operation. Try %s.", nil),
+ ErrAlterOperationNotSupportedReason: mysql.Message("%s is not supported. Reason: %s. Try %s.", nil),
+ ErrAlterOperationNotSupportedReasonCopy: mysql.Message("COPY algorithm requires a lock", nil),
+ ErrAlterOperationNotSupportedReasonPartition: mysql.Message("Partition specific operations do not yet support LOCK/ALGORITHM", nil),
+ ErrAlterOperationNotSupportedReasonFkRename: mysql.Message("Columns participating in a foreign key are renamed", nil),
+ ErrAlterOperationNotSupportedReasonColumnType: mysql.Message("Cannot change column type INPLACE", nil),
+ ErrAlterOperationNotSupportedReasonFkCheck: mysql.Message("Adding foreign keys needs foreignKeyChecks=OFF", nil),
+ ErrAlterOperationNotSupportedReasonIgnore: mysql.Message("Creating unique indexes with IGNORE requires COPY algorithm to remove duplicate rows", nil),
+ ErrAlterOperationNotSupportedReasonNopk: mysql.Message("Dropping a primary key is not allowed without also adding a new primary key", nil),
+ ErrAlterOperationNotSupportedReasonAutoinc: mysql.Message("Adding an auto-increment column requires a lock", nil),
+ ErrAlterOperationNotSupportedReasonHiddenFts: mysql.Message("Cannot replace hidden FTSDOCID with a user-visible one", nil),
+ ErrAlterOperationNotSupportedReasonChangeFts: mysql.Message("Cannot drop or rename FTSDOCID", nil),
+ ErrAlterOperationNotSupportedReasonFts: mysql.Message("Fulltext index creation requires a lock", nil),
+ ErrDupUnknownInIndex: mysql.Message("Duplicate entry for key '%-.192s'", nil),
+ ErrIdentCausesTooLongPath: mysql.Message("Long database name and identifier for object resulted in path length exceeding %d characters. Path: '%s'.", nil),
+ ErrAlterOperationNotSupportedReasonNotNull: mysql.Message("cannot silently convert NULL values, as required in this SQLMODE", nil),
+ ErrMustChangePasswordLogin: mysql.Message("Your password has expired. To log in you must change it using a client that supports expired passwords.", nil),
+ ErrRowInWrongPartition: mysql.Message("Found a row in wrong partition %s", []int{0}),
+ ErrGeneratedColumnFunctionIsNotAllowed: mysql.Message("Expression of generated column '%s' contains a disallowed function.", nil),
+ ErrGeneratedColumnRowValueIsNotAllowed: mysql.Message("Expression of generated column '%s' cannot refer to a row value", nil),
+ ErrUnsupportedAlterInplaceOnVirtualColumn: mysql.Message("INPLACE ADD or DROP of virtual columns cannot be combined with other ALTER TABLE actions.", nil),
+ ErrWrongFKOptionForGeneratedColumn: mysql.Message("Cannot define foreign key with %s clause on a generated column.", nil),
+ ErrBadGeneratedColumn: mysql.Message("The value specified for generated column '%s' in table '%s' is not allowed.", nil),
+ ErrUnsupportedOnGeneratedColumn: mysql.Message("'%s' is not supported for generated columns.", nil),
+ ErrGeneratedColumnNonPrior: mysql.Message("Generated column can refer only to generated columns defined prior to it.", nil),
+ ErrDependentByGeneratedColumn: mysql.Message("Column '%s' has a generated column dependency.", nil),
+ ErrGeneratedColumnRefAutoInc: mysql.Message("Generated column '%s' cannot refer to auto-increment column.", nil),
+ ErrWarnConflictingHint: mysql.Message("Hint %s is ignored as conflicting/duplicated.", nil),
+ ErrUnresolvedHintName: mysql.Message("Unresolved name '%s' for %s hint", nil),
+ ErrInvalidFieldSize: mysql.Message("Invalid size for column '%s'.", nil),
+ ErrInvalidArgumentForLogarithm: mysql.Message("Invalid argument for logarithm", nil),
+ ErrAggregateOrderNonAggQuery: mysql.Message("Expression #%d of ORDER BY contains aggregate function and applies to the result of a non-aggregated query", nil),
+ ErrIncorrectType: mysql.Message("Incorrect type for argument %s in function %s.", nil),
+ ErrFieldInOrderNotSelect: mysql.Message("Expression #%d of ORDER BY clause is not in SELECT list, references column '%s' which is not in SELECT list; this is incompatible with %s", nil),
+ ErrAggregateInOrderNotSelect: mysql.Message("Expression #%d of ORDER BY clause is not in SELECT list, contains aggregate function; this is incompatible with %s", nil),
+ ErrInvalidJSONData: mysql.Message("Invalid JSON data provided to function %s: %s", nil),
+ ErrInvalidJSONText: mysql.Message("Invalid JSON text: %-.192s", []int{0}),
+ ErrInvalidJSONPath: mysql.Message("Invalid JSON path expression %s.", nil),
+ ErrInvalidTypeForJSON: mysql.Message("Invalid data type for JSON data in argument %d to function %s; a JSON string or JSON type is required.", nil),
+ ErrInvalidJSONPathWildcard: mysql.Message("In this situation, path expressions may not contain the * and ** tokens.", nil),
+ ErrInvalidJSONContainsPathType: mysql.Message("The second argument can only be either 'one' or 'all'.", nil),
+ ErrJSONUsedAsKey: mysql.Message("JSON column '%-.192s' cannot be used in key specification.", nil),
+ ErrJSONDocumentNULLKey: mysql.Message("JSON documents may not contain NULL member names.", nil),
+ ErrSecureTransportRequired: mysql.Message("Connections using insecure transport are prohibited while --require_secure_transport=ON.", nil),
+ ErrBadUser: mysql.Message("User %s does not exist.", nil),
+ ErrUserAlreadyExists: mysql.Message("User %s already exists.", nil),
+ ErrInvalidJSONPathArrayCell: mysql.Message("A path expression is not a path to a cell in an array.", nil),
+ ErrInvalidEncryptionOption: mysql.Message("Invalid encryption option.", nil),
+ ErrTooLongValueForType: mysql.Message("Too long enumeration/set value for column %s.", nil),
+ ErrPKIndexCantBeInvisible: mysql.Message("A primary key index cannot be invisible", nil),
+ ErrWindowNoSuchWindow: mysql.Message("Window name '%s' is not defined.", nil),
+ ErrWindowCircularityInWindowGraph: mysql.Message("There is a circularity in the window dependency graph.", nil),
+ ErrWindowNoChildPartitioning: mysql.Message("A window which depends on another cannot define partitioning.", nil),
+ ErrWindowNoInherentFrame: mysql.Message("Window '%s' has a frame definition, so cannot be referenced by another window.", nil),
+ ErrWindowNoRedefineOrderBy: mysql.Message("Window '%s' cannot inherit '%s' since both contain an ORDER BY clause.", nil),
+ ErrWindowFrameStartIllegal: mysql.Message("Window '%s': frame start cannot be UNBOUNDED FOLLOWING.", nil),
+ ErrWindowFrameEndIllegal: mysql.Message("Window '%s': frame end cannot be UNBOUNDED PRECEDING.", nil),
+ ErrWindowFrameIllegal: mysql.Message("Window '%s': frame start or end is negative, NULL or of non-integral type", nil),
+ ErrWindowRangeFrameOrderType: mysql.Message("Window '%s' with RANGE N PRECEDING/FOLLOWING frame requires exactly one ORDER BY expression, of numeric or temporal type", nil),
+ ErrWindowRangeFrameTemporalType: mysql.Message("Window '%s' with RANGE frame has ORDER BY expression of datetime type. Only INTERVAL bound value allowed.", nil),
+ ErrWindowRangeFrameNumericType: mysql.Message("Window '%s' with RANGE frame has ORDER BY expression of numeric type, INTERVAL bound value not allowed.", nil),
+ ErrWindowRangeBoundNotConstant: mysql.Message("Window '%s' has a non-constant frame bound.", nil),
+ ErrWindowDuplicateName: mysql.Message("Window '%s' is defined twice.", nil),
+ ErrWindowIllegalOrderBy: mysql.Message("Window '%s': ORDER BY or PARTITION BY uses legacy position indication which is not supported, use expression.", nil),
+ ErrWindowInvalidWindowFuncUse: mysql.Message("You cannot use the window function '%s' in this context.'", nil),
+ ErrWindowInvalidWindowFuncAliasUse: mysql.Message("You cannot use the alias '%s' of an expression containing a window function in this context.'", nil),
+ ErrWindowNestedWindowFuncUseInWindowSpec: mysql.Message("You cannot nest a window function in the specification of window '%s'.", nil),
+ ErrWindowRowsIntervalUse: mysql.Message("Window '%s': INTERVAL can only be used with RANGE frames.", nil),
+ ErrWindowNoGroupOrderUnused: mysql.Message("ASC or DESC with GROUP BY isn't allowed with window functions; put ASC or DESC in ORDER BY", nil),
+ ErrWindowExplainJSON: mysql.Message("To get information about window functions use EXPLAIN FORMAT=JSON", nil),
+ ErrWindowFunctionIgnoresFrame: mysql.Message("Window function '%s' ignores the frame clause of window '%s' and aggregates over the whole partition", nil),
+ ErrRoleNotGranted: mysql.Message("%s is is not granted to %s", nil),
+ ErrMaxExecTimeExceeded: mysql.Message("Query execution was interrupted, max_execution_time exceeded.", nil),
+ ErrLockAcquireFailAndNoWaitSet: mysql.Message("Statement aborted because lock(s) could not be acquired immediately and NOWAIT is set.", nil),
+ ErrNotHintUpdatable: mysql.Message("Variable '%s' cannot be set using SET_VAR hint.", nil),
+ ErrDataTruncatedFunctionalIndex: mysql.Message("Data truncated for expression index '%s' at row %d", nil),
+ ErrDataOutOfRangeFunctionalIndex: mysql.Message("Value is out of range for expression index '%s' at row %d", nil),
+ ErrFunctionalIndexOnJSONOrGeometryFunction: mysql.Message("Cannot create an expression index on a function that returns a JSON or GEOMETRY value", nil),
+ ErrFunctionalIndexRefAutoIncrement: mysql.Message("Expression index '%s' cannot refer to an auto-increment column", nil),
+ ErrCannotDropColumnFunctionalIndex: mysql.Message("Cannot drop column '%s' because it is used by an expression index. In order to drop the column, you must remove the expression index", nil),
+ ErrFunctionalIndexPrimaryKey: mysql.Message("The primary key cannot be an expression index", nil),
+ ErrFunctionalIndexOnLob: mysql.Message("Cannot create an expression index on an expression that returns a BLOB or TEXT. Please consider using CAST", nil),
+ ErrFunctionalIndexFunctionIsNotAllowed: mysql.Message("Expression of expression index '%s' contains a disallowed function", nil),
+ ErrFulltextFunctionalIndex: mysql.Message("Fulltext expression index is not supported", nil),
+ ErrSpatialFunctionalIndex: mysql.Message("Spatial expression index is not supported", nil),
+ ErrWrongKeyColumnFunctionalIndex: mysql.Message("The used storage engine cannot index the expression '%s'", nil),
+ ErrFunctionalIndexOnField: mysql.Message("Expression index on a column is not supported. Consider using a regular index instead", nil),
+ ErrFKIncompatibleColumns: mysql.Message("Referencing column '%s' in foreign key constraint '%s' are incompatible", nil),
+ ErrFunctionalIndexRowValueIsNotAllowed: mysql.Message("Expression of expression index '%s' cannot refer to a row value", nil),
+ ErrDependentByFunctionalIndex: mysql.Message("Column '%s' has an expression index dependency and cannot be dropped or renamed", nil),
+ ErrInvalidJSONValueForFuncIndex: mysql.Message("Invalid JSON value for CAST for expression index '%s'", nil),
+ ErrJSONValueOutOfRangeForFuncIndex: mysql.Message("Out of range JSON value for CAST for expression index '%s'", nil),
+ ErrFunctionalIndexDataIsTooLong: mysql.Message("Data too long for expression index '%s'", nil),
+ ErrFunctionalIndexNotApplicable: mysql.Message("Cannot use expression index '%s' due to type or collation conversion", nil),
+ ErrUnsupportedConstraintCheck: mysql.Message("%s is not supported", nil),
+ // MariaDB errors.
+ ErrOnlyOneDefaultPartionAllowed: mysql.Message("Only one DEFAULT partition allowed", nil),
+ ErrWrongPartitionTypeExpectedSystemTime: mysql.Message("Wrong partitioning type, expected type: `SYSTEM_TIME`", nil),
+ ErrSystemVersioningWrongPartitions: mysql.Message("Wrong Partitions: must have at least one HISTORY and exactly one last CURRENT", nil),
+ ErrSequenceRunOut: mysql.Message("Sequence '%-.64s.%-.64s' has run out", nil),
+ ErrSequenceInvalidData: mysql.Message("Sequence '%-.64s.%-.64s' values are conflicting", nil),
+ ErrSequenceAccessFail: mysql.Message("Sequence '%-.64s.%-.64s' access error", nil),
+ ErrNotSequence: mysql.Message("'%-.64s.%-.64s' is not a SEQUENCE", nil),
+ ErrUnknownSequence: mysql.Message("Unknown SEQUENCE: '%-.300s'", nil),
+ ErrWrongInsertIntoSequence: mysql.Message("Wrong INSERT into a SEQUENCE. One can only do single table INSERT into a sequence object (like with mysqldump). If you want to change the SEQUENCE, use ALTER SEQUENCE instead.", nil),
+ ErrSequenceInvalidTableStructure: mysql.Message("Sequence '%-.64s.%-.64s' table structure is invalid (%s)", nil),
+
+ // TiDB errors.
+ ErrMemExceedThreshold: mysql.Message("%s holds %dB memory, exceeds threshold %dB.%s", nil),
+ ErrForUpdateCantRetry: mysql.Message("[%d] can not retry select for update statement", nil),
+ ErrAdminCheckTable: mysql.Message("TiDB admin check table failed.", nil),
+ ErrTxnTooLarge: mysql.Message("Transaction is too large, size: %d", nil),
+ ErrWriteConflictInTiDB: mysql.Message("Write conflict, txnStartTS %d is stale", nil),
+ ErrInvalidPluginID: mysql.Message("Wrong plugin id: %s, valid plugin id is [name]-[version], both name and version should not contain '-'", nil),
+ ErrInvalidPluginManifest: mysql.Message("Cannot read plugin %s's manifest", nil),
+ ErrInvalidPluginName: mysql.Message("Plugin load with %s but got wrong name %s", nil),
+ ErrInvalidPluginVersion: mysql.Message("Plugin load with %s but got %s", nil),
+ ErrDuplicatePlugin: mysql.Message("Plugin [%s] is redeclared", nil),
+ ErrInvalidPluginSysVarName: mysql.Message("Plugin %s's sysVar %s must start with its plugin name %s", nil),
+ ErrRequireVersionCheckFail: mysql.Message("Plugin %s require %s be %v but got %v", nil),
+ ErrUnsupportedReloadPlugin: mysql.Message("Plugin %s isn't loaded so cannot be reloaded", nil),
+ ErrUnsupportedReloadPluginVar: mysql.Message("Reload plugin with different sysVar is unsupported %v", nil),
+ ErrTableLocked: mysql.Message("Table '%s' was locked in %s by %v", nil),
+ ErrNotExist: mysql.Message("Error: key not exist", nil),
+ ErrTxnRetryable: mysql.Message("Error: KV error safe to retry %s ", []int{0}),
+ ErrCannotSetNilValue: mysql.Message("can not set nil value", nil),
+ ErrInvalidTxn: mysql.Message("invalid transaction", nil),
+ ErrEntryTooLarge: mysql.Message("entry too large, the max entry size is %d, the size of data is %d", nil),
+ ErrNotImplemented: mysql.Message("not implemented", nil),
+ ErrInfoSchemaExpired: mysql.Message("Information schema is out of date: schema failed to update in 1 lease, please make sure TiDB can connect to TiKV", nil),
+ ErrInfoSchemaChanged: mysql.Message("Information schema is changed during the execution of the statement(for example, table definition may be updated by other DDL ran in parallel). If you see this error often, try increasing `tidb_max_delta_schema_count`", nil),
+ ErrBadNumber: mysql.Message("Bad Number", nil),
+ ErrCastAsSignedOverflow: mysql.Message("Cast to signed converted positive out-of-range integer to it's negative complement", nil),
+ ErrCastNegIntAsUnsigned: mysql.Message("Cast to unsigned converted negative integer to it's positive complement", nil),
+ ErrInvalidYearFormat: mysql.Message("invalid year format", nil),
+ ErrInvalidYear: mysql.Message("invalid year", nil),
+ ErrIncorrectDatetimeValue: mysql.Message("Incorrect datetime value: '%s'", []int{0}),
+ ErrInvalidTimeFormat: mysql.Message("invalid time format: '%v'", []int{0}),
+ ErrInvalidWeekModeFormat: mysql.Message("invalid week mode format: '%v'", nil),
+ ErrFieldGetDefaultFailed: mysql.Message("Field '%s' get default value fail", nil),
+ ErrIndexOutBound: mysql.Message("Index column %s offset out of bound, offset: %d, row: %v", []int{2}),
+ ErrUnsupportedOp: mysql.Message("operation not supported", nil),
+ ErrRowNotFound: mysql.Message("can not find the row: %s", []int{0}),
+ ErrTableStateCantNone: mysql.Message("table %s can't be in none state", nil),
+ ErrColumnStateCantNone: mysql.Message("column %s can't be in none state", nil),
+ ErrColumnStateNonPublic: mysql.Message("can not use non-public column", nil),
+ ErrIndexStateCantNone: mysql.Message("index %s can't be in none state", nil),
+ ErrInvalidRecordKey: mysql.Message("invalid record key", nil),
+ ErrUnsupportedValueForVar: mysql.Message("variable '%s' does not yet support value: %s", nil),
+ ErrUnsupportedIsolationLevel: mysql.Message("The isolation level '%s' is not supported. Set tidb_skip_isolation_level_check=1 to skip this error", nil),
+ ErrInvalidDDLWorker: mysql.Message("Invalid DDL worker", nil),
+ ErrUnsupportedDDLOperation: mysql.Message("Unsupported %s", nil),
+ ErrNotOwner: mysql.Message("TiDB server is not a DDL owner", nil),
+ ErrCantDecodeRecord: mysql.Message("Cannot decode %s value, because %v", nil),
+ ErrInvalidDDLJob: mysql.Message("Invalid DDL job", nil),
+ ErrInvalidDDLJobFlag: mysql.Message("Invalid DDL job flag", nil),
+ ErrWaitReorgTimeout: mysql.Message("Timeout waiting for data reorganization", nil),
+ ErrInvalidStoreVersion: mysql.Message("Invalid storage current version: %d", nil),
+ ErrUnknownTypeLength: mysql.Message("Unknown length for type %d", nil),
+ ErrUnknownFractionLength: mysql.Message("Unknown length for type %d and fraction %d", nil),
+ ErrInvalidDDLJobVersion: mysql.Message("Version %d of DDL job is greater than current one: %d", nil),
+ ErrInvalidSplitRegionRanges: mysql.Message("Failed to split region ranges", nil),
+ ErrReorgPanic: mysql.Message("Reorg worker panic", nil),
+ ErrInvalidDDLState: mysql.Message("Invalid %s state: %v", nil),
+ ErrCancelledDDLJob: mysql.Message("Cancelled DDL job", nil),
+ ErrRepairTable: mysql.Message("Failed to repair table: %s", nil),
+ ErrLoadPrivilege: mysql.Message("Load privilege table fail: %s", nil),
+ ErrInvalidPrivilegeType: mysql.Message("unknown privilege type %s", nil),
+ ErrUnknownFieldType: mysql.Message("unknown field type", nil),
+ ErrInvalidSequence: mysql.Message("invalid sequence", nil),
+ ErrInvalidType: mysql.Message("invalid type", nil),
+ ErrCantGetValidID: mysql.Message("Cannot get a valid auto-ID when retrying the statement", nil),
+ ErrCantSetToNull: mysql.Message("cannot set variable to null", nil),
+ ErrSnapshotTooOld: mysql.Message("snapshot is older than GC safe point %s", nil),
+ ErrInvalidTableID: mysql.Message("invalid TableID", nil),
+ ErrInvalidAutoRandom: mysql.Message("Invalid auto random: %s", nil),
+ ErrInvalidHashKeyFlag: mysql.Message("invalid encoded hash key flag", nil),
+ ErrInvalidListIndex: mysql.Message("invalid list index", nil),
+ ErrInvalidListMetaData: mysql.Message("invalid list meta data", nil),
+ ErrWriteOnSnapshot: mysql.Message("write on snapshot", nil),
+ ErrInvalidKey: mysql.Message("invalid key", nil),
+ ErrInvalidIndexKey: mysql.Message("invalid index key", nil),
+ ErrDataInConsistent: mysql.Message("data isn't equal", nil),
+ ErrDDLReorgElementNotExist: mysql.Message("DDL reorg element does not exist", nil),
+ ErrDDLJobNotFound: mysql.Message("DDL Job:%v not found", nil),
+ ErrCancelFinishedDDLJob: mysql.Message("This job:%v is finished, so can't be cancelled", nil),
+ ErrCannotCancelDDLJob: mysql.Message("This job:%v is almost finished, can't be cancelled now", nil),
+ ErrUnknownAllocatorType: mysql.Message("Invalid allocator type", nil),
+ ErrAutoRandReadFailed: mysql.Message("Failed to read auto-random value from storage engine", nil),
+ ErrInvalidIncrementAndOffset: mysql.Message("Invalid auto_increment settings: auto_increment_increment: %d, auto_increment_offset: %d, both of them must be in range [1..65535]", nil),
+
+ ErrWarnOptimizerHintInvalidInteger: mysql.Message("integer value is out of range in '%s'", nil),
+ ErrWarnOptimizerHintUnsupportedHint: mysql.Message("Optimizer hint %s is not supported by TiDB and is ignored", nil),
+ ErrWarnOptimizerHintInvalidToken: mysql.Message("Cannot use %s '%s' (tok = %d) in an optimizer hint", nil),
+ ErrWarnMemoryQuotaOverflow: mysql.Message("Max value of MEMORY_QUOTA is %d bytes, ignore this invalid limit", nil),
+ ErrWarnOptimizerHintParseError: mysql.Message("Optimizer hint syntax error at %v", nil),
+
+ ErrSequenceUnsupportedTableOption: mysql.Message("Unsupported sequence table-option %s", nil),
+ ErrColumnTypeUnsupportedNextValue: mysql.Message("Unsupported sequence default value for column type '%s'", nil),
+ ErrAddColumnWithSequenceAsDefault: mysql.Message("Unsupported using sequence as default value in add column '%s'", nil),
+ ErrUnsupportedType: mysql.Message("Unsupported type %T", nil),
+ ErrAnalyzeMissIndex: mysql.Message("Index '%s' in field list does not exist in table '%s'", nil),
+ ErrCartesianProductUnsupported: mysql.Message("Cartesian product is unsupported", nil),
+ ErrPreparedStmtNotFound: mysql.Message("Prepared statement not found", nil),
+ ErrWrongParamCount: mysql.Message("Wrong parameter count", nil),
+ ErrSchemaChanged: mysql.Message("Schema has changed", nil),
+ ErrUnknownPlan: mysql.Message("Unknown plan", nil),
+ ErrPrepareMulti: mysql.Message("Can not prepare multiple statements", nil),
+ ErrPrepareDDL: mysql.Message("Can not prepare DDL statements with parameters", nil),
+ ErrResultIsEmpty: mysql.Message("Result is empty", nil),
+ ErrBuildExecutor: mysql.Message("Failed to build executor", nil),
+ ErrBatchInsertFail: mysql.Message("Batch insert failed, please clean the table and try again.", nil),
+ ErrGetStartTS: mysql.Message("Can not get start ts", nil),
+ ErrPrivilegeCheckFail: mysql.Message("privilege check fail", nil), // this error message should begin lowercased to be compatible with the test
+ ErrInvalidWildCard: mysql.Message("Wildcard fields without any table name appears in wrong place", nil),
+ ErrMixOfGroupFuncAndFieldsIncompatible: mysql.Message("In aggregated query without GROUP BY, expression #%d of SELECT list contains nonaggregated column '%s'; this is incompatible with sql_mode=only_full_group_by", nil),
+ ErrUnsupportedSecondArgumentType: mysql.Message("JSON_OBJECTAGG: unsupported second argument type %v", nil),
+ ErrLockExpire: mysql.Message("TTL manager has timed out, pessimistic locks may expire, please commit or rollback this transaction", nil),
+ ErrTableOptionUnionUnsupported: mysql.Message("CREATE/ALTER table with union option is not supported", nil),
+ ErrTableOptionInsertMethodUnsupported: mysql.Message("CREATE/ALTER table with insert method option is not supported", nil),
+
+ ErrBRIEBackupFailed: mysql.Message("Backup failed: %s", nil),
+ ErrBRIERestoreFailed: mysql.Message("Restore failed: %s", nil),
+ ErrBRIEImportFailed: mysql.Message("Import failed: %s", nil),
+ ErrBRIEExportFailed: mysql.Message("Export failed: %s", nil),
+
+ ErrInvalidTableSample: mysql.Message("Invalid TABLESAMPLE: %s", nil),
+
+ ErrJSONObjectKeyTooLong: mysql.Message("TiDB does not yet support JSON objects with the key length >= 65536", nil),
+ ErrPartitionStatsMissing: mysql.Message("Build table: %s global-level stats failed due to missing partition-level stats", nil),
+
+ ErrInvalidPlacementSpec: mysql.Message("Invalid placement policy '%s': %s", nil),
+ ErrPlacementPolicyCheck: mysql.Message("Placement policy didn't meet the constraint, reason: %s", nil),
+ ErrMultiStatementDisabled: mysql.Message("client has multi-statement capability disabled. Run SET GLOBAL tidb_multi_statement_mode='ON' after you understand the security risk", nil),
+
+ // TiKV/PD errors.
+ ErrPDServerTimeout: mysql.Message("PD server timeout", nil),
+ ErrTiKVServerTimeout: mysql.Message("TiKV server timeout", nil),
+ ErrTiKVServerBusy: mysql.Message("TiKV server is busy", nil),
+ ErrTiFlashServerTimeout: mysql.Message("TiFlash server timeout", nil),
+ ErrTiFlashServerBusy: mysql.Message("TiFlash server is busy", nil),
+ ErrResolveLockTimeout: mysql.Message("Resolve lock timeout", nil),
+ ErrRegionUnavailable: mysql.Message("Region is unavailable", nil),
+ ErrGCTooEarly: mysql.Message("GC life time is shorter than transaction duration, transaction starts at %v, GC safe point is %v", nil),
+ ErrWriteConflict: mysql.Message("Write conflict, txnStartTS=%d, conflictStartTS=%d, conflictCommitTS=%d, key=%s", []int{3}),
+ ErrTiKVStoreLimit: mysql.Message("Store token is up to the limit, store id = %d", nil),
+ ErrPrometheusAddrIsNotSet: mysql.Message("Prometheus address is not set in PD and etcd", nil),
+ ErrTiKVStaleCommand: mysql.Message("TiKV server reports stale command", nil),
+ ErrTiKVMaxTimestampNotSynced: mysql.Message("TiKV max timestamp is not synced", nil),
+}
diff --git a/pkg/errno/infoschema.go b/pkg/errno/infoschema.go
new file mode 100644
index 0000000000000000000000000000000000000000..224d500d062f558db14bfee01b3b045e01e375e7
--- /dev/null
+++ b/pkg/errno/infoschema.go
@@ -0,0 +1,144 @@
+package errno
+
+import (
+ "sync"
+ "time"
+)
+
+// The error summary is protected by a mutex for simplicity.
+// It is not expected to be hot unless there are concurrent workloads
+// that are generating high error/warning counts, in which case
+// the system probably has other issues already.
+
+// ErrorSummary summarizes errors and warnings
+type ErrorSummary struct {
+ ErrorCount int
+ WarningCount int
+ FirstSeen time.Time
+ LastSeen time.Time
+}
+
+// instanceStatistics provide statistics for a tidb-server instance.
+type instanceStatistics struct {
+ sync.Mutex
+ global map[uint16]*ErrorSummary
+ users map[string]map[uint16]*ErrorSummary
+ hosts map[string]map[uint16]*ErrorSummary
+}
+
+var stats instanceStatistics
+
+func init() {
+ FlushStats()
+}
+
+// FlushStats resets errors and warnings across global/users/hosts
+func FlushStats() {
+ stats.Lock()
+ defer stats.Unlock()
+ stats.global = make(map[uint16]*ErrorSummary)
+ stats.users = make(map[string]map[uint16]*ErrorSummary)
+ stats.hosts = make(map[string]map[uint16]*ErrorSummary)
+}
+
+func copyMap(oldMap map[uint16]*ErrorSummary) map[uint16]*ErrorSummary {
+ newMap := make(map[uint16]*ErrorSummary, len(oldMap))
+ for k, v := range oldMap {
+ newMap[k] = &ErrorSummary{
+ ErrorCount: v.ErrorCount,
+ WarningCount: v.WarningCount,
+ FirstSeen: v.FirstSeen,
+ LastSeen: v.LastSeen,
+ }
+ }
+ return newMap
+}
+
+// GlobalStats summarizes errors and warnings across all users/hosts
+func GlobalStats() map[uint16]*ErrorSummary {
+ stats.Lock()
+ defer stats.Unlock()
+ return copyMap(stats.global)
+}
+
+// UserStats summarizes per-user
+func UserStats() map[string]map[uint16]*ErrorSummary {
+ stats.Lock()
+ defer stats.Unlock()
+ newMap := make(map[string]map[uint16]*ErrorSummary, len(stats.users))
+ for k, v := range stats.users {
+ newMap[k] = copyMap(v)
+ }
+ return newMap
+}
+
+// HostStats summarizes per remote-host
+func HostStats() map[string]map[uint16]*ErrorSummary {
+ stats.Lock()
+ defer stats.Unlock()
+ newMap := make(map[string]map[uint16]*ErrorSummary, len(stats.hosts))
+ for k, v := range stats.hosts {
+ newMap[k] = copyMap(v)
+ }
+ return newMap
+}
+
+func initCounters(errCode uint16, user, host string) {
+ seen := time.Now()
+ stats.Lock()
+ defer stats.Unlock()
+
+ if _, ok := stats.global[errCode]; !ok {
+ stats.global[errCode] = &ErrorSummary{FirstSeen: seen}
+ }
+ if _, ok := stats.users[user]; !ok {
+ stats.users[user] = make(map[uint16]*ErrorSummary)
+ }
+ if _, ok := stats.users[user][errCode]; !ok {
+ stats.users[user][errCode] = &ErrorSummary{FirstSeen: seen}
+ }
+ if _, ok := stats.hosts[host]; !ok {
+ stats.hosts[host] = make(map[uint16]*ErrorSummary)
+ }
+ if _, ok := stats.hosts[host][errCode]; !ok {
+ stats.hosts[host][errCode] = &ErrorSummary{FirstSeen: seen}
+ }
+}
+
+// IncrementError increments the global/user/host statistics for an errCode
+func IncrementError(errCode uint16, user, host string) {
+ seen := time.Now()
+ initCounters(errCode, user, host)
+
+ stats.Lock()
+ defer stats.Unlock()
+
+ // Increment counter + update last seen
+ stats.global[errCode].ErrorCount++
+ stats.global[errCode].LastSeen = seen
+ // Increment counter + update last seen
+ stats.users[user][errCode].ErrorCount++
+ stats.users[user][errCode].LastSeen = seen
+ // Increment counter + update last seen
+ stats.hosts[host][errCode].ErrorCount++
+ stats.hosts[host][errCode].LastSeen = seen
+}
+
+// IncrementWarning increments the global/user/host statistics for an errCode
+func IncrementWarning(errCode uint16, user, host string) {
+ seen := time.Now()
+ initCounters(errCode, user, host)
+
+ stats.Lock()
+ defer stats.Unlock()
+
+ // Increment counter + update last seen
+ stats.global[errCode].WarningCount++
+ stats.global[errCode].LastSeen = seen
+ // Increment counter + update last seen
+ stats.users[user][errCode].WarningCount++
+ stats.users[user][errCode].LastSeen = seen
+ // Increment counter + update last seen
+ stats.hosts[host][errCode].WarningCount++
+ stats.hosts[host][errCode].LastSeen = seen
+}
diff --git a/pkg/server/buffered_conn_reader.go b/pkg/server/buffered_conn_reader.go
new file mode 100644
index 0000000000000000000000000000000000000000..11430bfff72718a73b17316a1c597e5376daabdf
--- /dev/null
+++ b/pkg/server/buffered_conn_reader.go
@@ -0,0 +1,25 @@
+package server
+
+import (
+ "bufio"
+ "net"
+)
+
+const defaultReaderSize = 16 * 1024
+
+// bufferedConnReader is a net.Conn compatible structure that reads from bufio.Reader.
+type bufferedConnReader struct {
+ net.Conn
+ rb *bufio.Reader
+}
+
+func (conn bufferedConnReader) Read(b []byte) (n int, err error) {
+ return conn.rb.Read(b)
+}
+
+func newBufferedConnReader(conn net.Conn) *bufferedConnReader {
+ return &bufferedConnReader{
+ Conn: conn,
+ rb: bufio.NewReaderSize(conn, defaultReaderSize),
+ }
+}
diff --git a/pkg/server/chunkio.go b/pkg/server/chunkio.go
new file mode 100644
index 0000000000000000000000000000000000000000..0e8d74c2642948106642f7e1f4613eb232449ed5
--- /dev/null
+++ b/pkg/server/chunkio.go
@@ -0,0 +1,140 @@
+package server
+
+import (
+ "bufio"
+ "errors"
+ "fmt"
+ "io"
+ "time"
+
+ "github.com/pingcap/parser/mysql"
+)
+
+const defaultWriterSize = 16 * 1024
+
+// packetIO is a helper to read and write data in packet format.
+type packetIO struct {
+ bufReader *bufferedConnReader
+ bufWriter *bufio.Writer
+ sequence uint8
+ readTimeout time.Duration
+}
+
+func newPacketIO(bufReader *bufferedConnReader) *packetIO {
+ p := &packetIO{sequence: 0}
+ p.setBufReader(bufReader)
+ return p
+}
+
+func (p *packetIO) setBufReader(bufReader *bufferedConnReader) {
+ p.bufReader = bufReader
+ p.bufWriter = bufio.NewWriterSize(bufReader, defaultWriterSize)
+}
+
+func (p *packetIO) setReadTimeout(timeout time.Duration) {
+ p.readTimeout = timeout
+}
+
+func (p *packetIO) readOne() ([]byte, error) {
+ var header [4]byte
+ if p.readTimeout > 0 {
+ if err := p.bufReader.SetReadDeadline(time.Now().Add(p.readTimeout)); err != nil {
+ return nil, err
+ }
+ }
+ if _, err := io.ReadFull(p.bufReader, header[:]); err != nil {
+ return nil, err
+ }
+
+ sequence := header[3]
+ if sequence != p.sequence {
+ return nil, errors.New(fmt.Sprintf("invalid sequence %d != %d", sequence, p.sequence))
+ }
+
+ p.sequence++
+
+ length := int(uint32(header[0]) | uint32(header[1])<<8 | uint32(header[2])<<16)
+
+ data := make([]byte, length)
+ if p.readTimeout > 0 {
+ if err := p.bufReader.SetReadDeadline(time.Now().Add(p.readTimeout)); err != nil {
+ return nil, err
+ }
+ }
+ if _, err := io.ReadFull(p.bufReader, data); err != nil {
+ return nil, err
+ }
+ return data, nil
+}
+
+func (p *packetIO) readFull() ([]byte, error) {
+ data, err := p.readOne()
+ if err != nil {
+ return nil, err
+ }
+
+ if len(data) < mysql.MaxPayloadLen {
+ return data, nil
+ }
+
+ // handle multi-chunk
+ for {
+ buf, err := p.readOne()
+ if err != nil {
+ return nil, err
+ }
+
+ data = append(data, buf...)
+
+ if len(buf) < mysql.MaxPayloadLen {
+ break
+ }
+ }
+
+ return data, nil
+}
+
+// write writes data that already have header
+func (p *packetIO) write(data []byte) error {
+ length := len(data) - 4
+
+ for length >= mysql.MaxPayloadLen {
+ data[0] = 0xff
+ data[1] = 0xff
+ data[2] = 0xff
+
+ data[3] = p.sequence
+
+ if n, err := p.bufWriter.Write(data[:4+mysql.MaxPayloadLen]); err != nil {
+ return mysql.ErrBadConn
+ } else if n != (4 + mysql.MaxPayloadLen) {
+ return mysql.ErrBadConn
+ } else {
+ p.sequence++
+ length -= mysql.MaxPayloadLen
+ data = data[mysql.MaxPayloadLen:]
+ }
+ }
+
+ data[0] = byte(length)
+ data[1] = byte(length >> 8)
+ data[2] = byte(length >> 16)
+ data[3] = p.sequence
+
+ if n, err := p.bufWriter.Write(data); err != nil {
+ return mysql.ErrBadConn
+ } else if n != len(data) {
+ return mysql.ErrBadConn
+ } else {
+ p.sequence++
+ return nil
+ }
+}
+
+func (p *packetIO) flush() error {
+ err := p.bufWriter.Flush()
+ if err != nil {
+ return err
+ }
+ return err
+}
diff --git a/pkg/server/client_conn.go b/pkg/server/client_conn.go
new file mode 100644
index 0000000000000000000000000000000000000000..76467768005fc3304739147e37ac9a1eff5fa1b7
--- /dev/null
+++ b/pkg/server/client_conn.go
@@ -0,0 +1,1054 @@
+package server
+
+import (
+ "bytes"
+ "context"
+ "crypto/tls"
+ "encoding/binary"
+ "fmt"
+ "io"
+ "net"
+ "runtime"
+ "runtime/trace"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "github.com/pingcap/errors"
+
+ "github.com/pingcap/parser/auth"
+ "github.com/pingcap/parser/mysql"
+ "github.com/pingcap/parser/terror"
+ log "github.com/sirupsen/logrus"
+ "go.uber.org/zap"
+ "matrixbase/pkg/config"
+ "matrixbase/pkg/errno"
+ "matrixbase/pkg/sessionctx/variable"
+ "matrixbase/pkg/util/arena"
+ "matrixbase/pkg/util/hack"
+)
+
+const (
+ connStatusDispatching int32 = iota
+ connStatusReading
+ connStatusShutdown // Closed by server.
+ connStatusWaitShutdown // Notified by server to close.
+)
+
+// newClientConn creates a *clientConn object.
+func newClientConn(s *Server) *clientConn {
+ return &clientConn{
+ server: s,
+ connectionID: s.globalConnID.NextID(),
+ collation: mysql.DefaultCollationID,
+ alloc: arena.NewAllocator(32 * 1024),
+ status: connStatusDispatching,
+ lastActive: time.Now(),
+ }
+}
+
+// clientConn represents a connection between server and client, it maintains connection specific state,
+// handles client query.
+type clientConn struct {
+ pkt *packetIO // a helper to read and write data in packet format.
+ bufReader *bufferedConnReader // a buffered-read net.Conn or buffered-read tls.Conn.
+ tlsConn *tls.Conn // TLS connection, nil if not TLS.
+ server *Server // a reference of server instance.
+ capability uint32 // client capability affects the way server handles client request.
+ connectionID uint64 // atomically allocated by a global variable, unique in process scope.
+ user string // user of the client.
+ dbname string // default database name.
+ salt []byte // random bytes used for authentication.
+ alloc arena.Allocator // an memory allocator for reducing memory allocation.
+ lastPacket []byte // latest sql query string, currently used for logging error.
+ ctx *DBContext // an interface to execute sql statements.
+ attrs map[string]string // attributes parsed from client handshake response, not used for now.
+ peerHost string // peer host
+ peerPort string // peer port
+ status int32 // dispatching/reading/shutdown/waitshutdown
+ lastCode uint16 // last error code
+ collation uint8 // collation used by client, may be different from the collation used by database.
+ lastActive time.Time
+
+ // mu is used for cancelling the execution of current transaction.
+ mu struct {
+ sync.RWMutex
+ cancelFunc context.CancelFunc
+ }
+}
+
+func (cc *clientConn) String() string {
+ collationStr := mysql.Collations[cc.collation]
+ return fmt.Sprintf("id:%d, addr:%s, collation:%s, user:%s",
+ cc.connectionID, cc.bufReader.RemoteAddr(), collationStr, cc.user,
+ )
+}
+
+// authSwitchRequest is used when the client asked to speak something
+// other than mysql_native_password. The server is allowed to ask
+// the client to switch, so lets ask for mysql_native_password
+// https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::AuthSwitchRequest
+func (cc *clientConn) authSwitchRequest(ctx context.Context) ([]byte, error) {
+ enclen := 1 + len(mysql.AuthNativePassword) + 1 + len(cc.salt) + 1
+ data := cc.alloc.AllocWithLen(4, enclen)
+ data = append(data, mysql.AuthSwitchRequest) // switch request
+ data = append(data, []byte(mysql.AuthNativePassword)...)
+ data = append(data, byte(0x00)) // requires null
+ data = append(data, cc.salt...)
+ data = append(data, 0)
+ err := cc.writePacket(data)
+ if err != nil {
+ log.Debugf("write response to client failed %v", zap.Error(err))
+ return nil, err
+ }
+ err = cc.flush(ctx)
+ if err != nil {
+ log.Debugf("flush response to client failed %v", zap.Error(err))
+ return nil, err
+ }
+ resp, err := cc.readPacket()
+ if err != nil {
+ if err == io.EOF {
+ log.Warnf("authSwitchRequest response fail due to connection has be closed by client-side")
+ } else {
+ log.Warnf("authSwitchRequest response fail %v", zap.Error(err))
+ }
+ return nil, err
+ }
+ return resp, nil
+}
+
+// handshake works like TCP handshake, but in a higher level, it first writes initial packet to client,
+// during handshake, client and server negotiate compatible features and do authentication.
+// After handshake, client can send sql query to server.
+func (cc *clientConn) handshake(ctx context.Context) error {
+ if err := cc.writeInitialHandshake(ctx); err != nil {
+ if err == io.EOF {
+ log.Debugf("Could not send handshake due to connection has be closed by client-side")
+ } else {
+ log.Debugf("Write init handshake to client fail %v", zap.Error(err))
+ }
+ return err
+ }
+ if err := cc.readOptionalSSLRequestAndHandshakeResponse(ctx); err != nil {
+ err1 := cc.writeError(ctx, err)
+ if err1 != nil {
+ log.Debugf("writeError failed %v", zap.Error(err1))
+ }
+ return err
+ }
+ data := cc.alloc.AllocWithLen(4, 32)
+ data = append(data, mysql.OKHeader)
+ data = append(data, 0, 0)
+ if cc.capability&mysql.ClientProtocol41 > 0 {
+ data = append(data, byte(mysql.ServerStatusAutocommit), byte(mysql.ServerStatusAutocommit>>8))
+ data = append(data, 0, 0)
+ }
+
+ err := cc.writePacket(data)
+ cc.pkt.sequence = 0
+ if err != nil {
+ log.Debugf("write response to client failed %v", zap.Error(err))
+ return err
+ }
+
+ err = cc.flush(ctx)
+ if err != nil {
+ log.Debugf("flush response to client failed %v", zap.Error(err))
+ return err
+ }
+ return err
+}
+
+func (cc *clientConn) Close() error {
+ cc.server.rwlock.Lock()
+ delete(cc.server.clients, cc.connectionID)
+ connections := len(cc.server.clients)
+ cc.server.rwlock.Unlock()
+ return closeConn(cc, connections)
+}
+
+func closeConn(cc *clientConn, connections int) error {
+ err := cc.bufReader.Close()
+ terror.Log(err)
+ return nil
+}
+
+func (cc *clientConn) closeWithoutLock() error {
+ delete(cc.server.clients, cc.connectionID)
+ return closeConn(cc, len(cc.server.clients))
+}
+
+// writeInitialHandshake sends server version, connection ID, server capability, collation, server status
+// and auth salt to the client.
+func (cc *clientConn) writeInitialHandshake(ctx context.Context) error {
+ data := make([]byte, 4, 128)
+
+ // min version 10
+ data = append(data, 10)
+ // server version[00]
+ data = append(data, mysql.ServerVersion...)
+ data = append(data, 0)
+ // connection id
+ data = append(data, byte(cc.connectionID), byte(cc.connectionID>>8), byte(cc.connectionID>>16), byte(cc.connectionID>>24))
+ // auth-plugin-data-part-1
+ data = append(data, cc.salt[0:8]...)
+ // filler [00]
+ data = append(data, 0)
+ // capability flag lower 2 bytes, using default capability here
+ data = append(data, byte(cc.server.capability), byte(cc.server.capability>>8))
+ // charset
+ if cc.collation == 0 {
+ cc.collation = uint8(mysql.DefaultCollationID)
+ }
+ data = append(data, cc.collation)
+ // status
+ data = append(data, byte(mysql.ServerStatusAutocommit), byte(mysql.ServerStatusAutocommit>>8))
+ // below 13 byte may not be used
+ // capability flag upper 2 bytes, using default capability here
+ data = append(data, byte(cc.server.capability>>16), byte(cc.server.capability>>24))
+ // length of auth-plugin-data
+ data = append(data, byte(len(cc.salt)+1))
+ // reserved 10 [00]
+ data = append(data, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+ // auth-plugin-data-part-2
+ data = append(data, cc.salt[8:]...)
+ data = append(data, 0)
+ // auth-plugin name
+ data = append(data, []byte(mysql.AuthNativePassword)...)
+ data = append(data, 0)
+ err := cc.writePacket(data)
+ if err != nil {
+ return err
+ }
+ return cc.flush(ctx)
+}
+
+func (cc *clientConn) readPacket() ([]byte, error) {
+ return cc.pkt.readFull()
+}
+
+func (cc *clientConn) writePacket(data []byte) error {
+ return cc.pkt.write(data)
+}
+
+// getSessionVarsWaitTimeout get session variable wait_timeout
+func (cc *clientConn) getSessionVarsWaitTimeout(ctx context.Context) uint64 {
+ return 0
+}
+
+type handshakeResponse41 struct {
+ Capability uint32
+ Collation uint8
+ User string
+ DBName string
+ Auth []byte
+ AuthPlugin string
+ Attrs map[string]string
+}
+
+// parseOldHandshakeResponseHeader parses the old version handshake header HandshakeResponse320
+func parseOldHandshakeResponseHeader(ctx context.Context, packet *handshakeResponse41, data []byte) (parsedBytes int, err error) {
+ // Ensure there are enough data to read:
+ // https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::HandshakeResponse320
+ log.Debugf("try to parse hanshake response as Protocol::HandshakeResponse320 %v", zap.ByteString("packetData", data))
+ if len(data) < 2+3 {
+ log.Errorf("got malformed handshake response %v", zap.ByteString("packetData", data))
+ return 0, mysql.ErrMalformPacket
+ }
+ offset := 0
+ // capability
+ capability := binary.LittleEndian.Uint16(data[:2])
+ packet.Capability = uint32(capability)
+
+ // be compatible with Protocol::HandshakeResponse41
+ packet.Capability |= mysql.ClientProtocol41
+
+ offset += 2
+ // skip max packet size
+ offset += 3
+ // usa default CharsetID
+ packet.Collation = mysql.CollationNames["utf8mb4_general_ci"]
+
+ return offset, nil
+}
+
+// parseOldHandshakeResponseBody parse the HandshakeResponse for Protocol::HandshakeResponse320 (except the common header part).
+func parseOldHandshakeResponseBody(ctx context.Context, packet *handshakeResponse41, data []byte, offset int) (err error) {
+ defer func() {
+ // Check malformat packet cause out of range is disgusting, but don't panic!
+ if r := recover(); r != nil {
+ log.Errorf("handshake panic %v %v", zap.ByteString("packetData", data), zap.Stack("stack"))
+ err = mysql.ErrMalformPacket
+ }
+ }()
+ // user name
+ packet.User = string(data[offset : offset+bytes.IndexByte(data[offset:], 0)])
+ offset += len(packet.User) + 1
+
+ if packet.Capability&mysql.ClientConnectWithDB > 0 {
+ if len(data[offset:]) > 0 {
+ idx := bytes.IndexByte(data[offset:], 0)
+ packet.DBName = string(data[offset : offset+idx])
+ offset = offset + idx + 1
+ }
+ if len(data[offset:]) > 0 {
+ packet.Auth = data[offset : offset+bytes.IndexByte(data[offset:], 0)]
+ }
+ } else {
+ packet.Auth = data[offset : offset+bytes.IndexByte(data[offset:], 0)]
+ }
+
+ return nil
+}
+
+// parseHandshakeResponseHeader parses the common header of SSLRequest and HandshakeResponse41.
+func parseHandshakeResponseHeader(ctx context.Context, packet *handshakeResponse41, data []byte) (parsedBytes int, err error) {
+ // Ensure there are enough data to read:
+ // http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::SSLRequest
+ if len(data) < 4+4+1+23 {
+ log.Errorf("got malformed handshake response %v %v", zap.ByteString("packetData", data))
+ return 0, mysql.ErrMalformPacket
+ }
+
+ offset := 0
+ // capability
+ capability := binary.LittleEndian.Uint32(data[:4])
+ packet.Capability = capability
+ offset += 4
+ // skip max packet size
+ offset += 4
+ // charset, skip, if you want to use another charset, use set names
+ packet.Collation = data[offset]
+ offset++
+ // skip reserved 23[00]
+ offset += 23
+
+ return offset, nil
+}
+
+// parseHandshakeResponseBody parse the HandshakeResponse (except the common header part).
+func parseHandshakeResponseBody(ctx context.Context, packet *handshakeResponse41, data []byte, offset int) (err error) {
+ defer func() {
+ // Check malformat packet cause out of range is disgusting, but don't panic!
+ if r := recover(); r != nil {
+ log.Errorf("handshake panic %v", zap.ByteString("packetData", data))
+ err = mysql.ErrMalformPacket
+ }
+ }()
+ // user name
+ packet.User = string(data[offset : offset+bytes.IndexByte(data[offset:], 0)])
+ offset += len(packet.User) + 1
+
+ if packet.Capability&mysql.ClientPluginAuthLenencClientData > 0 {
+ // MySQL client sets the wrong capability, it will set this bit even server doesn't
+ // support ClientPluginAuthLenencClientData.
+ // https://github.com/mysql/mysql-server/blob/5.7/sql-common/client.c#L3478
+ num, null, off := parseLengthEncodedInt(data[offset:])
+ offset += off
+ if !null {
+ packet.Auth = data[offset : offset+int(num)]
+ offset += int(num)
+ }
+ } else if packet.Capability&mysql.ClientSecureConnection > 0 {
+ // auth length and auth
+ authLen := int(data[offset])
+ offset++
+ packet.Auth = data[offset : offset+authLen]
+ offset += authLen
+ } else {
+ packet.Auth = data[offset : offset+bytes.IndexByte(data[offset:], 0)]
+ offset += len(packet.Auth) + 1
+ }
+
+ if packet.Capability&mysql.ClientConnectWithDB > 0 {
+ if len(data[offset:]) > 0 {
+ idx := bytes.IndexByte(data[offset:], 0)
+ packet.DBName = string(data[offset : offset+idx])
+ offset += idx + 1
+ }
+ }
+
+ if packet.Capability&mysql.ClientPluginAuth > 0 {
+ idx := bytes.IndexByte(data[offset:], 0)
+ s := offset
+ f := offset + idx
+ if s < f { // handle unexpected bad packets
+ packet.AuthPlugin = string(data[s:f])
+ }
+ offset += idx + 1
+ }
+
+ if packet.Capability&mysql.ClientConnectAtts > 0 {
+ if len(data[offset:]) == 0 {
+ // Defend some ill-formated packet, connection attribute is not important and can be ignored.
+ return nil
+ }
+ if num, null, off := parseLengthEncodedInt(data[offset:]); !null {
+ offset += off
+ row := data[offset : offset+int(num)]
+ attrs, err := parseAttrs(row)
+ if err != nil {
+ log.Warnf("parse attrs failed %v", zap.Error(err))
+ return nil
+ }
+ packet.Attrs = attrs
+ }
+ }
+
+ return nil
+}
+
+func parseAttrs(data []byte) (map[string]string, error) {
+ attrs := make(map[string]string)
+ pos := 0
+ for pos < len(data) {
+ key, _, off, err := parseLengthEncodedBytes(data[pos:])
+ if err != nil {
+ return attrs, err
+ }
+ pos += off
+ value, _, off, err := parseLengthEncodedBytes(data[pos:])
+ if err != nil {
+ return attrs, err
+ }
+ pos += off
+
+ attrs[string(key)] = string(value)
+ }
+ return attrs, nil
+}
+
+func (cc *clientConn) readOptionalSSLRequestAndHandshakeResponse(ctx context.Context) error {
+ // Read a packet. It may be a SSLRequest or HandshakeResponse.
+ data, err := cc.readPacket()
+ if err != nil {
+ if err == io.EOF {
+ log.Debugf("wait handshake response fail due to connection has be closed by client-side")
+ } else {
+ log.Debugf("wait handshake response fail %v", zap.Error(err))
+ }
+ return err
+ }
+
+ isOldVersion := false
+
+ var resp handshakeResponse41
+ var pos int
+
+ if len(data) < 2 {
+ log.Errorf("got malformed handshake response %v", zap.ByteString("packetData", data))
+ return mysql.ErrMalformPacket
+ }
+
+ capability := uint32(binary.LittleEndian.Uint16(data[:2]))
+ if capability&mysql.ClientProtocol41 > 0 {
+ pos, err = parseHandshakeResponseHeader(ctx, &resp, data)
+ } else {
+ pos, err = parseOldHandshakeResponseHeader(ctx, &resp, data)
+ isOldVersion = true
+ }
+
+ if err != nil {
+ terror.Log(err)
+ return err
+ }
+
+ if resp.Capability&mysql.ClientSSL > 0 {
+ tlsConfig := (*tls.Config)(atomic.LoadPointer(&cc.server.tlsConfig))
+ if tlsConfig != nil {
+ // The packet is a SSLRequest, let's switch to TLS.
+ if err = cc.upgradeToTLS(tlsConfig); err != nil {
+ return err
+ }
+ // Read the following HandshakeResponse packet.
+ data, err = cc.readPacket()
+ if err != nil {
+ log.Warnf("read handshake response failure after upgrade to TLS %v", zap.Error(err))
+ return err
+ }
+ if isOldVersion {
+ pos, err = parseOldHandshakeResponseHeader(ctx, &resp, data)
+ } else {
+ pos, err = parseHandshakeResponseHeader(ctx, &resp, data)
+ }
+ if err != nil {
+ terror.Log(err)
+ return err
+ }
+ }
+ } else if config.GetGlobalConfig().Security.RequireSecureTransport {
+ err := errSecureTransportRequired.FastGenByArgs()
+ terror.Log(err)
+ return err
+ }
+
+ // Read the remaining part of the packet.
+ if isOldVersion {
+ err = parseOldHandshakeResponseBody(ctx, &resp, data, pos)
+ } else {
+ err = parseHandshakeResponseBody(ctx, &resp, data, pos)
+ }
+ if err != nil {
+ terror.Log(err)
+ return err
+ }
+
+ // switching from other methods should work, but not tested
+ if resp.AuthPlugin == mysql.AuthCachingSha2Password {
+ resp.Auth, err = cc.authSwitchRequest(ctx)
+ if err != nil {
+ // logutil.Logger(ctx).Warn("attempt to send auth switch request packet failed", zap.Error(err))
+ return err
+ }
+ }
+ cc.capability = resp.Capability & cc.server.capability
+ cc.user = resp.User
+ cc.dbname = resp.DBName
+ cc.collation = resp.Collation
+ cc.attrs = resp.Attrs
+
+ err = cc.openSessionAndDoAuth(resp.Auth)
+ if err != nil {
+ // logutil.Logger(ctx).Warn("open new session failure", zap.Error(err))
+ }
+ return err
+}
+
+func (cc *clientConn) openSessionAndDoAuth(authData []byte) error {
+ var tlsStatePtr *tls.ConnectionState
+ if cc.tlsConn != nil {
+ tlsState := cc.tlsConn.ConnectionState()
+ tlsStatePtr = &tlsState
+ }
+ var err error
+ cc.ctx, err = cc.server.driver.OpenCtx(cc.connectionID, cc.capability, cc.collation, cc.dbname, tlsStatePtr)
+ if err != nil {
+ return err
+ }
+
+ if err = cc.server.checkConnectionCount(); err != nil {
+ return err
+ }
+ hasPassword := "YES"
+ if len(authData) == 0 {
+ hasPassword = "NO"
+ }
+ host, port, err := cc.PeerHost(hasPassword)
+ if err != nil {
+ return err
+ }
+ if !cc.ctx.Auth(&auth.UserIdentity{Username: cc.user, Hostname: host}, authData, cc.salt) {
+ return errAccessDenied.FastGenByArgs(cc.user, host, hasPassword)
+ }
+ cc.ctx.SetPort(port)
+ if cc.dbname != "" {
+ err = cc.useDB(context.Background(), cc.dbname)
+ if err != nil {
+ return err
+ }
+ }
+ cc.ctx.SetSessionManager(cc.server)
+ return nil
+}
+
+func (cc *clientConn) PeerHost(hasPassword string) (host, port string, err error) {
+ if len(cc.peerHost) > 0 {
+ return cc.peerHost, "", nil
+ }
+ host = variable.DefHostname
+ if cc.server.isUnixSocket() {
+ cc.peerHost = host
+ return
+ }
+ addr := cc.bufReader.RemoteAddr().String()
+ host, port, err = net.SplitHostPort(addr)
+ if err != nil {
+ err = errAccessDenied.GenWithStackByArgs(cc.user, addr, hasPassword)
+ return
+ }
+ cc.peerHost = host
+ cc.peerPort = port
+ return
+}
+
+// Run reads client query and writes query result to client in for loop, if there is a panic during query handling,
+// it will be recovered and log the panic error.
+// This function returns and the connection is closed if there is an IO error or there is a panic.
+func (cc *clientConn) Run(ctx context.Context) {
+ const size = 4096
+ defer func() {
+ r := recover()
+ if r != nil {
+ buf := make([]byte, size)
+ stackSize := runtime.Stack(buf, false)
+ buf = buf[:stackSize]
+ // logutil.Logger(ctx).Error("connection running loop panic",
+ // zap.Stringer("lastSQL", getLastStmtInConn{cc}),
+ // zap.String("err", fmt.Sprintf("%v", r)),
+ // zap.String("stack", string(buf)),
+ // )
+ err := cc.writeError(ctx, errors.New(fmt.Sprintf("%v", r)))
+ terror.Log(err)
+ }
+ if atomic.LoadInt32(&cc.status) != connStatusShutdown {
+ err := cc.Close()
+ terror.Log(err)
+ }
+ }()
+ // Usually, client connection status changes between [dispatching] <=> [reading].
+ // When some event happens, server may notify this client connection by setting
+ // the status to special values, for example: kill or graceful shutdown.
+ // The client connection would detect the events when it fails to change status
+ // by CAS operation, it would then take some actions accordingly.
+ for {
+ if !atomic.CompareAndSwapInt32(&cc.status, connStatusDispatching, connStatusReading) ||
+ // The judge below will not be hit by all means,
+ // But keep it stayed as a reminder and for the code reference for connStatusWaitShutdown.
+ atomic.LoadInt32(&cc.status) == connStatusWaitShutdown {
+ return
+ }
+
+ cc.alloc.Reset()
+ // close connection when idle time is more than wait_timeout
+ waitTimeout := cc.getSessionVarsWaitTimeout(ctx)
+ cc.pkt.setReadTimeout(time.Duration(waitTimeout) * time.Second)
+ start := time.Now()
+ data, err := cc.readPacket()
+ if err != nil {
+ if terror.ErrorNotEqual(err, io.EOF) {
+ if netErr, isNetErr := err.(net.Error); isNetErr && netErr.Timeout() {
+ idleTime := time.Since(start)
+ log.Infof("read packet timeout, close this connection",
+ zap.Duration("idle", idleTime),
+ zap.Uint64("waitTimeout", waitTimeout),
+ zap.Error(err),
+ )
+ } else {
+ // errStack := errors.ErrorStack(err)
+ // if !strings.Contains(errStack, "use of closed network connection") {
+ // log.Warnf("read packet failed, close this connection",
+ // zap.Error(errors.SuspendStack(err)))
+ // }
+ }
+ }
+ return
+ }
+
+ if !atomic.CompareAndSwapInt32(&cc.status, connStatusReading, connStatusDispatching) {
+ return
+ }
+
+ // startTime := time.Now()
+ if err = cc.dispatch(ctx, data); err != nil {
+ if terror.ErrorEqual(err, io.EOF) {
+ return
+ } else if terror.ErrResultUndetermined.Equal(err) {
+ log.Errorf("result undetermined, close this connection", zap.Error(err))
+ return
+ } else if terror.ErrCritical.Equal(err) {
+ log.Fatalf("critical error, stop the server", zap.Error(err))
+ }
+ // logutil.Logger(ctx).Info("command dispatched failed",
+ // zap.String("connInfo", cc.String()),
+ // zap.String("command", mysql.Command2Str[data[0]]),
+ // zap.String("status", cc.SessionStatusToString()),
+ // zap.Stringer("sql", getLastStmtInConn{cc}),
+ // zap.String("err", errStrForLog(err, cc.ctx.GetSessionVars().EnableRedactLog)),
+ // )
+ err1 := cc.writeError(ctx, err)
+ terror.Log(err1)
+ }
+ cc.pkt.sequence = 0
+ }
+}
+
+// ShutdownOrNotify will Shutdown this client connection, or do its best to notify.
+func (cc *clientConn) ShutdownOrNotify() bool {
+ if mysql.ServerStatusInTrans > 0 {
+ return false
+ }
+ // If the client connection status is reading, it's safe to shutdown it.
+ if atomic.CompareAndSwapInt32(&cc.status, connStatusReading, connStatusShutdown) {
+ return true
+ }
+ // If the client connection status is dispatching, we can't shutdown it immediately,
+ // so set the status to WaitShutdown as a notification, the loop in clientConn.Run
+ // will detect it and then exit.
+ atomic.StoreInt32(&cc.status, connStatusWaitShutdown)
+ return false
+}
+
+func queryStrForLog(query string) string {
+ const size = 4096
+ if len(query) > size {
+ return query[:size] + fmt.Sprintf("(len: %d)", len(query))
+ }
+ return query
+}
+
+// func errStrForLog(err error, enableRedactLog bool) string {
+// if enableRedactLog {
+// // currently, only ErrParse is considered when enableRedactLog because it may contain sensitive information like
+// // password or accesskey
+// if parser.ErrParse.Equal(err) {
+// return "fail to parse SQL and can't redact when enable log redaction"
+// }
+// }
+// if kv.ErrKeyExists.Equal(err) || parser.ErrParse.Equal(err) || infoschema.ErrTableNotExists.Equal(err) {
+// // Do not log stack for duplicated entry error.
+// return err.Error()
+// }
+// return errors.ErrorStack(err)
+// }
+
+// dispatch handles client request based on command which is the first byte of the data.
+// It also gets a token from server which is used to limit the concurrently handling clients.
+// The most frequently used command is ComQuery.
+func (cc *clientConn) dispatch(ctx context.Context, data []byte) error {
+ defer func() {
+ // reset killed for each request
+ atomic.StoreUint32(&cc.ctx.GetSessionVars().Killed, 0)
+ }()
+ // t := time.Now()
+
+ var cancelFunc context.CancelFunc
+ ctx, cancelFunc = context.WithCancel(ctx)
+ cc.mu.Lock()
+ cc.mu.cancelFunc = cancelFunc
+ cc.mu.Unlock()
+
+ cc.lastPacket = data
+ cmd := data[0]
+ data = data[1:]
+ defer func() {
+ // if handleChangeUser failed, cc.ctx may be nil
+ // if cc.ctx != nil {
+ // cc.ctx.SetProcessInfo("", t, mysql.ComSleep, 0)
+ // }
+
+ cc.lastActive = time.Now()
+ }()
+
+ vars := cc.ctx.GetSessionVars()
+ // reset killed for each request
+ atomic.StoreUint32(&vars.Killed, 0)
+ if cmd < mysql.ComEnd {
+ cc.ctx.SetCommandValue(cmd)
+ }
+
+ dataStr := string(hack.String(data))
+ switch cmd {
+ case mysql.ComPing, mysql.ComStmtClose, mysql.ComStmtSendLongData, mysql.ComStmtReset,
+ mysql.ComSetOption, mysql.ComChangeUser:
+ // cc.ctx.SetProcessInfo("", t, cmd, 0)
+ case mysql.ComInitDB:
+ // cc.ctx.SetProcessInfo("use "+dataStr, t, cmd, 0)
+ }
+
+ switch cmd {
+ case mysql.ComSleep:
+ // TODO: According to mysql document, this command is supposed to be used only internally.
+ // So it's just a temp fix, not sure if it's done right.
+ // Investigate this command and write test case later.
+ return nil
+ case mysql.ComQuit:
+ return io.EOF
+ case mysql.ComInitDB:
+ if err := cc.useDB(ctx, dataStr); err != nil {
+ return err
+ }
+ return cc.writeOK(ctx)
+ case mysql.ComQuery: // Most frequently used command.
+ // For issue 1989
+ // Input payload may end with byte '\0', we didn't find related mysql document about it, but mysql
+ // implementation accept that case. So trim the last '\0' here as if the payload an EOF string.
+ // See http://dev.mysql.com/doc/internals/en/com-query.html
+ if len(data) > 0 && data[len(data)-1] == 0 {
+ data = data[:len(data)-1]
+ dataStr = string(hack.String(data))
+ }
+ return cc.handleQuery(ctx, dataStr)
+ case mysql.ComFieldList:
+ return cc.handleFieldList(ctx, dataStr)
+ // ComCreateDB, ComDropDB
+ case mysql.ComRefresh:
+ return cc.handleRefresh(ctx, data[0])
+ case mysql.ComShutdown: // redirect to SQL
+ if err := cc.handleQuery(ctx, "SHUTDOWN"); err != nil {
+ return err
+ }
+ return cc.writeOK(ctx)
+ case mysql.ComStatistics:
+ return cc.writeStats(ctx)
+ // ComProcessInfo, ComConnect, ComProcessKill, ComDebug
+ case mysql.ComPing:
+ return cc.writeOK(ctx)
+ // ComTime, ComDelayedInsert
+ case mysql.ComChangeUser:
+ return cc.handleChangeUser(ctx, data)
+ // ComBinlogDump, ComTableDump, ComConnectOut, ComRegisterSlave
+ case mysql.ComStmtPrepare:
+ return cc.handleStmtPrepare(ctx, dataStr)
+ case mysql.ComStmtExecute:
+ return cc.handleStmtExecute(ctx, data)
+ case mysql.ComStmtSendLongData:
+ return cc.handleStmtSendLongData(data)
+ case mysql.ComStmtClose:
+ return cc.handleStmtClose(data)
+ case mysql.ComStmtReset:
+ return cc.handleStmtReset(ctx, data)
+ case mysql.ComSetOption:
+ return cc.handleSetOption(ctx, data)
+ case mysql.ComStmtFetch:
+ return cc.handleStmtFetch(ctx, data)
+ // ComDaemon, ComBinlogDumpGtid
+ case mysql.ComResetConnection:
+ return cc.handleResetConnection(ctx)
+ // ComEnd
+ default:
+ return mysql.NewErrf(mysql.ErrUnknown, "command %d not supported now", nil, cmd)
+ }
+}
+
+func (cc *clientConn) writeStats(ctx context.Context) error {
+ msg := []byte("Uptime: 0 Threads: 0 Questions: 0 Slow queries: 0 Opens: 0 Flush tables: 0 Open tables: 0 Queries per second avg: 0.000")
+ data := cc.alloc.AllocWithLen(4, len(msg))
+ data = append(data, msg...)
+
+ err := cc.writePacket(data)
+ if err != nil {
+ return err
+ }
+
+ return cc.flush(ctx)
+}
+
+func (cc *clientConn) useDB(ctx context.Context, db string) (err error) {
+ // if input is "use `SELECT`", mysql client just send "SELECT"
+ // so we add `` around db.
+ _, err = cc.ctx.Parse(ctx, "use `"+db+"`")
+ if err != nil {
+ return err
+ }
+
+ return mysql.NewErrf(mysql.ErrUnknown, "command %d not supported now", nil, mysql.ComInitDB)
+}
+
+func (cc *clientConn) flush(ctx context.Context) error {
+ defer func() {
+ trace.StartRegion(ctx, "FlushClientConn").End()
+ }()
+ return cc.pkt.flush()
+}
+
+func (cc *clientConn) writeOK(ctx context.Context) error {
+ msg := cc.ctx.LastMessage()
+ return cc.writeOkWith(ctx, msg, cc.ctx.AffectedRows(), cc.ctx.LastInsertID(), cc.ctx.Status(), cc.ctx.WarningCount())
+}
+
+func (cc *clientConn) writeOkWith(ctx context.Context, msg string, affectedRows, lastInsertID uint64, status, warnCnt uint16) error {
+ enclen := 0
+ if len(msg) > 0 {
+ enclen = lengthEncodedIntSize(uint64(len(msg))) + len(msg)
+ }
+
+ data := cc.alloc.AllocWithLen(4, 32+enclen)
+ data = append(data, mysql.OKHeader)
+ data = dumpLengthEncodedInt(data, affectedRows)
+ data = dumpLengthEncodedInt(data, lastInsertID)
+ if cc.capability&mysql.ClientProtocol41 > 0 {
+ data = dumpUint16(data, status)
+ data = dumpUint16(data, warnCnt)
+ }
+ if enclen > 0 {
+ // although MySQL manual says the info message is string<EOF>(https://dev.mysql.com/doc/internals/en/packet-OK_Packet.html),
+ // it is actually string<lenenc>
+ data = dumpLengthEncodedString(data, []byte(msg))
+ }
+
+ err := cc.writePacket(data)
+ if err != nil {
+ return err
+ }
+
+ return cc.flush(ctx)
+}
+
+func (cc *clientConn) writeError(ctx context.Context, e error) error {
+ var (
+ m *mysql.SQLError
+ te *terror.Error
+ ok bool
+ )
+ originErr := errors.Cause(e)
+ if te, ok = originErr.(*terror.Error); ok {
+ m = terror.ToSQLError(te)
+ } else {
+ e := errors.Cause(originErr)
+ switch y := e.(type) {
+ case *terror.Error:
+ m = terror.ToSQLError(y)
+ default:
+ m = mysql.NewErrf(mysql.ErrUnknown, "%s", nil, e.Error())
+ }
+ }
+
+ cc.lastCode = m.Code
+ defer errno.IncrementError(m.Code, cc.user, cc.peerHost)
+ data := cc.alloc.AllocWithLen(4, 16+len(m.Message))
+ data = append(data, mysql.ErrHeader)
+ data = append(data, byte(m.Code), byte(m.Code>>8))
+ if cc.capability&mysql.ClientProtocol41 > 0 {
+ data = append(data, '#')
+ data = append(data, m.State...)
+ }
+
+ data = append(data, m.Message...)
+
+ err := cc.writePacket(data)
+ if err != nil {
+ return err
+ }
+ return cc.flush(ctx)
+}
+
+// writeEOF writes an EOF packet.
+// Note this function won't flush the stream because maybe there are more
+// packets following it.
+// serverStatus, a flag bit represents server information
+// in the packet.
+func (cc *clientConn) writeEOF(serverStatus uint16) error {
+ data := cc.alloc.AllocWithLen(4, 9)
+
+ data = append(data, mysql.EOFHeader)
+ if cc.capability&mysql.ClientProtocol41 > 0 {
+ data = dumpUint16(data, cc.ctx.WarningCount())
+ status := cc.ctx.Status()
+ status |= serverStatus
+ data = dumpUint16(data, status)
+ }
+
+ err := cc.writePacket(data)
+ return err
+}
+
+func (cc *clientConn) writeReq(ctx context.Context, filePath string) error {
+ data := cc.alloc.AllocWithLen(4, 5+len(filePath))
+ data = append(data, mysql.LocalInFileHeader)
+ data = append(data, filePath...)
+
+ err := cc.writePacket(data)
+ if err != nil {
+ return err
+ }
+
+ return cc.flush(ctx)
+}
+
+// handleQuery executes the sql query string and writes result set or result ok to the client.
+func (cc *clientConn) handleQuery(ctx context.Context, sql string) (err error) {
+ _, err = cc.ctx.Parse(ctx, sql)
+ if err != nil {
+ return err
+ }
+
+ return cc.writeOK(ctx)
+}
+
+// handleFieldList returns the field list for a table.
+// The sql string is composed of a table name and a terminating character \x00.
+func (cc *clientConn) handleFieldList(ctx context.Context, sql string) (err error) {
+ return mysql.NewErrf(mysql.ErrUnknown, "command %d not supported now", nil, mysql.ComFieldList)
+}
+
+func (cc *clientConn) setConn(conn net.Conn) {
+ cc.bufReader = newBufferedConnReader(conn)
+ if cc.pkt == nil {
+ cc.pkt = newPacketIO(cc.bufReader)
+ } else {
+ // Preserve current sequence number.
+ cc.pkt.setBufReader(cc.bufReader)
+ }
+}
+
+func (cc *clientConn) upgradeToTLS(tlsConfig *tls.Config) error {
+ // Important: read from buffered reader instead of the original net.Conn because it may contain data we need.
+ tlsConn := tls.Server(cc.bufReader, tlsConfig)
+ if err := tlsConn.Handshake(); err != nil {
+ return err
+ }
+ cc.setConn(tlsConn)
+ cc.tlsConn = tlsConn
+ return nil
+}
+
+func (cc *clientConn) handleChangeUser(ctx context.Context, data []byte) error {
+ user, data := parseNullTermString(data)
+ cc.user = string(hack.String(user))
+ if len(data) < 1 {
+ return mysql.ErrMalformPacket
+ }
+ passLen := int(data[0])
+ data = data[1:]
+ if passLen > len(data) {
+ return mysql.ErrMalformPacket
+ }
+ pass := data[:passLen]
+ data = data[passLen:]
+ dbName, _ := parseNullTermString(data)
+ cc.dbname = string(hack.String(dbName))
+
+ err := cc.ctx.Close()
+ if err != nil {
+ // logutil.Logger(ctx).Debug("close old context failed", zap.Error(err))
+ }
+ err = cc.openSessionAndDoAuth(pass)
+ if err != nil {
+ return err
+ }
+ return cc.handleCommonConnectionReset(ctx)
+}
+
+func (cc *clientConn) handleResetConnection(ctx context.Context) error {
+ user := cc.ctx.GetSessionVars().User
+ err := cc.ctx.Close()
+ if err != nil {
+ // logutil.Logger(ctx).Debug("close old context failed", zap.Error(err))
+ }
+ var tlsStatePtr *tls.ConnectionState
+ if cc.tlsConn != nil {
+ tlsState := cc.tlsConn.ConnectionState()
+ tlsStatePtr = &tlsState
+ }
+ cc.ctx, err = cc.server.driver.OpenCtx(cc.connectionID, cc.capability, cc.collation, cc.dbname, tlsStatePtr)
+ if err != nil {
+ return err
+ }
+ if !cc.ctx.AuthWithoutVerification(user) {
+ return errors.New("Could not reset connection")
+ }
+ if cc.dbname != "" { // Restore the current DB
+ err = cc.useDB(context.Background(), cc.dbname)
+ if err != nil {
+ return err
+ }
+ }
+ cc.ctx.SetSessionManager(cc.server)
+
+ return cc.handleCommonConnectionReset(ctx)
+}
+
+func (cc *clientConn) handleCommonConnectionReset(ctx context.Context) error {
+ return cc.writeOK(ctx)
+}
+
+// safe to noop except 0x01 "FLUSH PRIVILEGES"
+func (cc *clientConn) handleRefresh(ctx context.Context, subCommand byte) error {
+ if subCommand == 0x01 {
+ if err := cc.handleQuery(ctx, "FLUSH PRIVILEGES"); err != nil {
+ return err
+ }
+ }
+ return cc.writeOK(ctx)
+}
diff --git a/pkg/server/conn_stmt.go b/pkg/server/conn_stmt.go
new file mode 100644
index 0000000000000000000000000000000000000000..c2d5ec28cf052a272847b4e24b0dbc38937b0690
--- /dev/null
+++ b/pkg/server/conn_stmt.go
@@ -0,0 +1,55 @@
+package server
+
+import (
+ "context"
+ "encoding/binary"
+
+ "github.com/pingcap/parser/mysql"
+)
+
+func (cc *clientConn) handleStmtPrepare(ctx context.Context, sql string) error {
+ return mysql.NewErrf(mysql.ErrUnknown, "command %d not supported now", nil, mysql.ComStmtPrepare)
+}
+
+func (cc *clientConn) handleStmtExecute(ctx context.Context, data []byte) (err error) {
+ return mysql.NewErrf(mysql.ErrUnknown, "command %d not supported now", nil, mysql.ComStmtExecute)
+}
+
+func (cc *clientConn) handleStmtFetch(ctx context.Context, data []byte) (err error) {
+ return mysql.NewErrf(mysql.ErrUnknown, "command %d not supported now", nil, mysql.ComStmtFetch)
+}
+
+func (cc *clientConn) handleStmtSendLongData(data []byte) (err error) {
+ return mysql.NewErrf(mysql.ErrUnknown, "command %d not supported now", nil, mysql.ComStmtSendLongData)
+}
+
+func (cc *clientConn) handleStmtReset(ctx context.Context, data []byte) (err error) {
+ return mysql.NewErrf(mysql.ErrUnknown, "command %d not supported now", nil, mysql.ComStmtReset)
+}
+
+// handleSetOption refer to https://dev.mysql.com/doc/internals/en/com-set-option.html
+func (cc *clientConn) handleSetOption(ctx context.Context, data []byte) (err error) {
+ if len(data) < 2 {
+ return mysql.ErrMalformPacket
+ }
+
+ switch binary.LittleEndian.Uint16(data[:2]) {
+ case 0:
+ cc.capability |= mysql.ClientMultiStatements
+ cc.ctx.SetClientCapability(cc.capability)
+ case 1:
+ cc.capability &^= mysql.ClientMultiStatements
+ cc.ctx.SetClientCapability(cc.capability)
+ default:
+ return mysql.ErrMalformPacket
+ }
+ if err = cc.writeEOF(0); err != nil {
+ return err
+ }
+
+ return cc.flush(ctx)
+}
+
+func (cc *clientConn) handleStmtClose(data []byte) (err error) {
+ return mysql.NewErrf(mysql.ErrUnknown, "command %d not supported now", nil, mysql.ComStmtClose)
+}
diff --git a/pkg/server/db_driver.go b/pkg/server/db_driver.go
new file mode 100644
index 0000000000000000000000000000000000000000..8adff4416d1dd4852adb84415c7502d751c09e6d
--- /dev/null
+++ b/pkg/server/db_driver.go
@@ -0,0 +1,77 @@
+package server
+
+import (
+ "crypto/tls"
+ "matrixbase/pkg/session"
+ "matrixbase/pkg/sessionctx/stmtctx"
+)
+
+type DBDriver struct {
+}
+
+func NewDBDriver() *DBDriver {
+ driver := &DBDriver{}
+ return driver
+}
+
+type DBContext struct {
+ session.Session
+ currentDB string
+ stmts map[int]*DBStatement
+}
+
+// GetWarnings implements QueryCtx GetWarnings method.
+func (tc *DBContext) GetWarnings() []stmtctx.SQLWarn {
+ return tc.GetSessionVars().StmtCtx.GetWarnings()
+}
+
+// CurrentDB implements QueryCtx CurrentDB method.
+func (tc *DBContext) CurrentDB() string {
+ return tc.currentDB
+}
+
+// WarningCount implements QueryCtx WarningCount method.
+func (tc *DBContext) WarningCount() uint16 {
+ return tc.GetSessionVars().StmtCtx.WarningCount()
+}
+
+type DBStatement struct {
+ id uint32
+ numParams int
+ boundParams [][]byte
+ paramsType []byte
+ ctx *DBContext
+ rs ResultSet
+ sql string
+}
+
+func (ds *DBStatement) ID() int {
+ return int(ds.id)
+}
+
+// OpenCtx implements IDriver.
+func (qd *DBDriver) OpenCtx(connID uint64, capability uint32, collation uint8, dbname string, tlsState *tls.ConnectionState) (*DBContext, error) {
+ se, err := session.CreateSession()
+ if err != nil {
+ return nil, err
+ }
+ se.SetTLSState(tlsState)
+ err = se.SetCollation(int(collation))
+ if err != nil {
+ return nil, err
+ }
+ se.SetClientCapability(capability)
+ se.SetConnectionID(connID)
+ tc := &DBContext{
+ Session: se,
+ currentDB: dbname,
+ stmts: make(map[int]*DBStatement),
+ }
+ return tc, nil
+}
+
+// Close implements QueryCtx Close method.
+func (tc *DBContext) Close() error {
+ tc.Session.Close()
+ return nil
+}
diff --git a/pkg/server/driver.go b/pkg/server/driver.go
new file mode 100644
index 0000000000000000000000000000000000000000..01205bb48cf39452a3fbc9b0ad645efeed5631b0
--- /dev/null
+++ b/pkg/server/driver.go
@@ -0,0 +1,14 @@
+package server
+
+import (
+ "crypto/tls"
+)
+
+// IDriver opens IContext.
+type IDriver interface {
+ // OpenCtx opens an IContext with connection id, client capability, collation, dbname and optionally the tls state.
+ OpenCtx(connID uint64, capability uint32, collation uint8, dbname string, tlsState *tls.ConnectionState) (*DBContext, error)
+}
+
+type ResultSet interface {
+}
diff --git a/pkg/server/server.go b/pkg/server/server.go
new file mode 100644
index 0000000000000000000000000000000000000000..14b239d15bcdb8b339c77f8d3d4edd036c0e4c98
--- /dev/null
+++ b/pkg/server/server.go
@@ -0,0 +1,430 @@
+package server
+
+import (
+ "context"
+ "crypto/tls"
+ "fmt"
+ "github.com/blacktear23/go-proxyprotocol"
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser/mysql"
+ "github.com/pingcap/parser/terror"
+ "io"
+ "math/rand"
+ "matrixbase/pkg/config"
+ "matrixbase/pkg/errno"
+ "matrixbase/pkg/sessionctx/variable"
+ _ "matrixbase/pkg/types/parser_driver"
+ "matrixbase/pkg/util"
+ "matrixbase/pkg/util/dbterror"
+ "net"
+ "os"
+ "os/user"
+ "sync"
+ "sync/atomic"
+ "time"
+ "unsafe"
+)
+
+var (
+ serverPID int
+ osUser string
+)
+
+func init() {
+ serverPID = os.Getpid()
+ currentUser, err := user.Current()
+ if err != nil {
+ osUser = ""
+ } else {
+ osUser = currentUser.Name
+ }
+}
+
+// DefaultCapability is the capability of the server when it is created using the default configuration.
+// When server is configured with SSL, the server will have extra capabilities compared to DefaultCapability.
+const defaultCapability = mysql.ClientLongPassword | mysql.ClientLongFlag |
+ mysql.ClientConnectWithDB | mysql.ClientProtocol41 |
+ mysql.ClientTransactions | mysql.ClientSecureConnection | mysql.ClientFoundRows |
+ mysql.ClientMultiStatements | mysql.ClientMultiResults | mysql.ClientLocalFiles |
+ mysql.ClientConnectAtts | mysql.ClientPluginAuth | mysql.ClientInteractive
+
+// Server is the MySQL protocol server
+type Server struct {
+ cfg *config.Config
+ tlsConfig unsafe.Pointer // *tls.Config
+ driver IDriver
+ listener net.Listener
+ socket net.Listener
+ rwlock sync.RWMutex
+ clients map[uint64]*clientConn
+ capability uint32
+ globalConnID util.GlobalConnID
+
+ statusAddr string
+ statusListener net.Listener
+ inShutdownMode bool
+}
+
+var (
+ errUnknownFieldType = dbterror.ClassServer.NewStd(errno.ErrUnknownFieldType)
+ errInvalidSequence = dbterror.ClassServer.NewStd(errno.ErrInvalidSequence)
+ errInvalidType = dbterror.ClassServer.NewStd(errno.ErrInvalidType)
+ errNotAllowedCommand = dbterror.ClassServer.NewStd(errno.ErrNotAllowedCommand)
+ errAccessDenied = dbterror.ClassServer.NewStd(errno.ErrAccessDenied)
+ errConCount = dbterror.ClassServer.NewStd(errno.ErrConCount)
+ errSecureTransportRequired = dbterror.ClassServer.NewStd(errno.ErrSecureTransportRequired)
+ errMultiStatementDisabled = dbterror.ClassServer.NewStd(errno.ErrMultiStatementDisabled)
+)
+
+func NewServer(cfg *config.Config, driver IDriver) (*Server, error) {
+ s := &Server{
+ cfg: cfg,
+ driver: driver,
+ clients: make(map[uint64]*clientConn),
+ globalConnID: util.GlobalConnID{ServerID: 0, Is64bits: true},
+ }
+
+ tlsConfig, err := util.LoadTLSCertificates(s.cfg.Security.SSLCA, s.cfg.Security.SSLKey, s.cfg.Security.SSLCert)
+ if err != nil {
+ // logutil.BgLogger().Error("secure connection cert/key/ca load fail", zap.Error(err))
+ }
+
+ if tlsConfig != nil {
+ setSSLVariable(s.cfg.Security.SSLCA, s.cfg.Security.SSLKey, s.cfg.Security.SSLCert)
+ atomic.StorePointer(&s.tlsConfig, unsafe.Pointer(tlsConfig))
+ // logutil.BgLogger().Info("mysql protocol server secure connection is enabled", zap.Bool("client verification enabled", len(variable.GetSysVar("ssl_ca").Value) > 0))
+ } else if cfg.Security.RequireSecureTransport {
+ return nil, errSecureTransportRequired.FastGenByArgs()
+ }
+
+ // TODO
+ // setSystemTimeZoneVariable()
+
+ s.capability = defaultCapability
+ if s.tlsConfig != nil {
+ s.capability |= mysql.ClientSSL
+ }
+
+ if s.cfg.Host != "" && (s.cfg.Port != 0) {
+ addr := fmt.Sprintf("%s:%d", s.cfg.Host, s.cfg.Port)
+ tcpProto := "tcp"
+ if s.cfg.EnableTCP4Only {
+ tcpProto = "tcp4"
+ }
+ if s.listener, err = net.Listen(tcpProto, addr); err == nil {
+ // logutil.BgLogger().Info("server is running MySQL protocol", zap.String("addr", addr))
+ if cfg.Socket != "" {
+ if s.socket, err = net.Listen("unix", s.cfg.Socket); err == nil {
+ // logutil.BgLogger().Info("server redirecting", zap.String("from", s.cfg.Socket), zap.String("to", addr))
+ go s.forwardUnixSocketToTCP()
+ }
+ }
+ }
+ } else if cfg.Socket != "" {
+ if s.listener, err = net.Listen("unix", cfg.Socket); err == nil {
+ // logutil.BgLogger().Info("server is running MySQL protocol", zap.String("socket", cfg.Socket))
+ }
+ } else {
+ err = errors.New("Server not configured to listen on either -socket or -host and -port")
+ }
+
+ if cfg.ProxyProtocol.Networks != "" {
+ pplistener, errProxy := proxyprotocol.NewListener(s.listener, cfg.ProxyProtocol.Networks,
+ int(cfg.ProxyProtocol.HeaderTimeout))
+ if errProxy != nil {
+ // logutil.BgLogger().Error("ProxyProtocol networks parameter invalid")
+ return nil, errors.Trace(errProxy)
+ }
+ // logutil.BgLogger().Info("server is running MySQL protocol (through PROXY protocol)", zap.String("host", s.cfg.Host))
+ s.listener = pplistener
+ }
+
+ if err != nil {
+ return nil, errors.Trace(err)
+ }
+
+ // Init rand seed for randomBuf()
+ rand.Seed(time.Now().UTC().UnixNano())
+ return s, nil
+}
+
+func setSSLVariable(ca, key, cert string) {
+ variable.SetSysVar("have_openssl", "YES")
+ variable.SetSysVar("have_ssl", "YES")
+ variable.SetSysVar("ssl_cert", cert)
+ variable.SetSysVar("ssl_key", key)
+ variable.SetSysVar("ssl_ca", ca)
+}
+
+func (s *Server) checkConnectionCount() error {
+ // When the value of MaxServerConnections is 0, the number of connections is unlimited.
+ if int(s.cfg.MaxServerConnections) == 0 {
+ return nil
+ }
+
+ s.rwlock.RLock()
+ conns := len(s.clients)
+ s.rwlock.RUnlock()
+
+ if conns >= int(s.cfg.MaxServerConnections) {
+ // logutil.BgLogger().Error("too many connections",
+ // zap.Uint32("max connections", s.cfg.MaxServerConnections), zap.Error(errConCount))
+ return errConCount
+ }
+ return nil
+}
+
+// Kill implements the SessionManager interface.
+func (s *Server) Kill(connectionID uint64, query bool) {
+ // logutil.BgLogger().Info("kill", zap.Uint64("connID", connectionID), zap.Bool("query", query))
+
+ s.rwlock.RLock()
+ defer s.rwlock.RUnlock()
+ conn, ok := s.clients[connectionID]
+ if !ok {
+ return
+ }
+
+ if !query {
+ // Mark the client connection status as WaitShutdown, when clientConn.Run detect
+ // this, it will end the dispatch loop and exit.
+ atomic.StoreInt32(&conn.status, connStatusWaitShutdown)
+ }
+ killConn(conn)
+}
+
+// UpdateTLSConfig implements the SessionManager interface.
+func (s *Server) UpdateTLSConfig(cfg *tls.Config) {
+ atomic.StorePointer(&s.tlsConfig, unsafe.Pointer(cfg))
+}
+
+func (s *Server) getTLSConfig() *tls.Config {
+ return (*tls.Config)(atomic.LoadPointer(&s.tlsConfig))
+}
+
+// ConnectionCount gets current connection count.
+func (s *Server) ConnectionCount() int {
+ s.rwlock.RLock()
+ cnt := len(s.clients)
+ s.rwlock.RUnlock()
+ return cnt
+}
+
+func killConn(conn *clientConn) {
+ sessVars := conn.ctx.GetSessionVars()
+ atomic.StoreUint32(&sessVars.Killed, 1)
+ conn.mu.RLock()
+ cancelFunc := conn.mu.cancelFunc
+ conn.mu.RUnlock()
+ if cancelFunc != nil {
+ cancelFunc()
+ }
+}
+
+// KillAllConnections kills all connections when server is not gracefully shutdown.
+func (s *Server) KillAllConnections() {
+ // logutil.BgLogger().Info("[server] kill all connections.")
+
+ s.rwlock.RLock()
+ defer s.rwlock.RUnlock()
+ for _, conn := range s.clients {
+ atomic.StoreInt32(&conn.status, connStatusShutdown)
+ if err := conn.closeWithoutLock(); err != nil {
+ terror.Log(err)
+ }
+ killConn(conn)
+ }
+}
+
+// Run runs the server.
+func (s *Server) Run() error {
+ for {
+ conn, err := s.listener.Accept()
+ if err != nil {
+ if opErr, ok := err.(*net.OpError); ok {
+ if opErr.Err.Error() == "use of closed network connection" {
+ return nil
+ }
+ }
+
+ // If we got PROXY protocol error, we should continue accept.
+ if proxyprotocol.IsProxyProtocolError(err) {
+ // logutil.BgLogger().Error("PROXY protocol failed", zap.Error(err))
+ continue
+ }
+
+ // logutil.BgLogger().Error("accept failed", zap.Error(err))
+ return errors.Trace(err)
+ }
+
+ clientConn := s.newConn(conn)
+
+ go s.onConn(clientConn)
+ }
+}
+
+var gracefulCloseConnectionsTimeout = 15 * time.Second
+
+// TryGracefulDown will try to gracefully close all connection first with timeout. if timeout, will close all connection directly.
+func (s *Server) TryGracefulDown() {
+ ctx, cancel := context.WithTimeout(context.Background(), gracefulCloseConnectionsTimeout)
+ defer cancel()
+ done := make(chan struct{})
+ go func() {
+ s.GracefulDown(ctx, done)
+ }()
+ select {
+ case <-ctx.Done():
+ s.KillAllConnections()
+ case <-done:
+ return
+ }
+}
+
+func (s *Server) kickIdleConnection() {
+ var conns []*clientConn
+ s.rwlock.RLock()
+ for _, cc := range s.clients {
+ if cc.ShutdownOrNotify() {
+ // Shutdowned conn will be closed by us, and notified conn will exist themselves.
+ conns = append(conns, cc)
+ }
+ }
+ s.rwlock.RUnlock()
+
+ for _, cc := range conns {
+ err := cc.Close()
+ if err != nil {
+ // logutil.BgLogger().Error("close connection", zap.Error(err))
+ }
+ }
+}
+
+// GracefulDown waits all clients to close.
+func (s *Server) GracefulDown(ctx context.Context, done chan struct{}) {
+ // logutil.Logger(ctx).Info("[server] graceful shutdown.")
+
+ count := s.ConnectionCount()
+ for i := 0; count > 0; i++ {
+ s.kickIdleConnection()
+
+ count = s.ConnectionCount()
+ if count == 0 {
+ break
+ }
+ // Print information for every 30s.
+ if i%30 == 0 {
+ // logutil.Logger(ctx).Info("graceful shutdown...", zap.Int("conn count", count))
+ }
+ ticker := time.After(time.Second)
+ select {
+ case <-ctx.Done():
+ return
+ case <-ticker:
+ }
+ }
+ close(done)
+}
+
+func (s *Server) isUnixSocket() bool {
+ return s.cfg.Socket != ""
+}
+
+func (s *Server) forwardUnixSocketToTCP() {
+ addr := fmt.Sprintf("%s:%d", s.cfg.Host, s.cfg.Port)
+ for {
+ if s.listener == nil {
+ return // server shutdown has started
+ }
+ if uconn, err := s.socket.Accept(); err == nil {
+ // logutil.BgLogger().Info("server socket forwarding", zap.String("from", s.cfg.Socket), zap.String("to", addr))
+ go s.handleForwardedConnection(uconn, addr)
+ } else if s.listener != nil {
+ // logutil.BgLogger().Error("server failed to forward", zap.String("from", s.cfg.Socket), zap.String("to", addr), zap.Error(err))
+ }
+ }
+}
+
+func (s *Server) handleForwardedConnection(uconn net.Conn, addr string) {
+ defer terror.Call(uconn.Close)
+ if tconn, err := net.Dial("tcp", addr); err == nil {
+ go func() {
+ if _, err := io.Copy(uconn, tconn); err != nil {
+ // logutil.BgLogger().Warn("copy server to socket failed", zap.Error(err))
+ }
+ }()
+ if _, err := io.Copy(tconn, uconn); err != nil {
+ // logutil.BgLogger().Warn("socket forward copy failed", zap.Error(err))
+ }
+ } else {
+ // logutil.BgLogger().Warn("socket forward failed: could not connect", zap.String("addr", addr), zap.Error(err))
+ }
+}
+
+func (s *Server) startShutdown() {
+ s.rwlock.RLock()
+ // logutil.BgLogger().Info("setting tidb-server to report unhealthy (shutting-down)")
+ s.inShutdownMode = true
+ s.rwlock.RUnlock()
+ // give the load balancer a chance to receive a few unhealthy health reports
+ // before acquiring the s.rwlock and blocking connections.
+ waitTime := time.Duration(s.cfg.GracefulWaitBeforeShutdown) * time.Second
+ if waitTime > 0 {
+ // logutil.BgLogger().Info("waiting for stray connections before starting shutdown process", zap.Duration("waitTime", waitTime))
+ time.Sleep(waitTime)
+ }
+}
+
+// Close closes the server.
+func (s *Server) Close() {
+ s.startShutdown()
+ s.rwlock.Lock() // prevent new connections
+ defer s.rwlock.Unlock()
+
+ if s.listener != nil {
+ err := s.listener.Close()
+ terror.Log(errors.Trace(err))
+ s.listener = nil
+ }
+ if s.socket != nil {
+ err := s.socket.Close()
+ terror.Log(errors.Trace(err))
+ s.socket = nil
+ }
+}
+
+// newConn creates a new *clientConn from a net.Conn.
+// It allocates a connection ID and random salt data for authentication.
+func (s *Server) newConn(conn net.Conn) *clientConn {
+ cc := newClientConn(s)
+ if tcpConn, ok := conn.(*net.TCPConn); ok {
+ if err := tcpConn.SetKeepAlive(s.cfg.Performance.TCPKeepAlive); err != nil {
+ // logutil.BgLogger().Error("failed to set tcp keep alive option", zap.Error(err))
+ }
+ }
+ cc.setConn(conn)
+ salt := make([]byte, 20)
+ rand.Read(salt)
+ cc.salt = salt
+ return cc
+}
+
+// onConn runs in its own goroutine, handles queries from this connection.
+func (s *Server) onConn(conn *clientConn) {
+ ctx := context.Background()
+ if err := conn.handshake(ctx); err != nil {
+ err = conn.Close()
+ terror.Log(errors.Trace(err))
+ return
+ }
+ // logutil.Logger(ctx).Debug("new connection", zap.String("remoteAddr", conn.bufReadConn.RemoteAddr().String()))
+
+ defer func() {
+ // logutil.Logger(ctx).Debug("connection closed")
+ }()
+ s.rwlock.Lock()
+ s.clients[conn.connectionID] = conn
+ s.rwlock.Unlock()
+
+ conn.Run(ctx)
+}
diff --git a/pkg/server/util.go b/pkg/server/util.go
new file mode 100644
index 0000000000000000000000000000000000000000..8f289f2e02046e91bd644d27e7aaf32509acc728
--- /dev/null
+++ b/pkg/server/util.go
@@ -0,0 +1,219 @@
+package server
+
+import (
+ "bytes"
+ "encoding/binary"
+ "io"
+ "math"
+ "strconv"
+ "time"
+)
+
+func parseNullTermString(b []byte) (str []byte, remain []byte) {
+ off := bytes.IndexByte(b, 0)
+ if off == -1 {
+ return nil, b
+ }
+ return b[:off], b[off+1:]
+}
+
+func parseLengthEncodedInt(b []byte) (num uint64, isNull bool, n int) {
+ switch b[0] {
+ // 251: NULL
+ case 0xfb:
+ n = 1
+ isNull = true
+ return
+
+ // 252: value of following 2
+ case 0xfc:
+ num = uint64(b[1]) | uint64(b[2])<<8
+ n = 3
+ return
+
+ // 253: value of following 3
+ case 0xfd:
+ num = uint64(b[1]) | uint64(b[2])<<8 | uint64(b[3])<<16
+ n = 4
+ return
+
+ // 254: value of following 8
+ case 0xfe:
+ num = uint64(b[1]) | uint64(b[2])<<8 | uint64(b[3])<<16 |
+ uint64(b[4])<<24 | uint64(b[5])<<32 | uint64(b[6])<<40 |
+ uint64(b[7])<<48 | uint64(b[8])<<56
+ n = 9
+ return
+ }
+
+ // https://dev.mysql.com/doc/internals/en/integer.html#length-encoded-integer: If the first byte of a packet is a length-encoded integer and its byte value is 0xfe, you must check the length of the packet to verify that it has enough space for a 8-byte integer.
+ // TODO: 0xff is undefined
+
+ // 0-250: value of first byte
+ num = uint64(b[0])
+ n = 1
+ return
+}
+
+func dumpLengthEncodedInt(buffer []byte, n uint64) []byte {
+ switch {
+ case n <= 250:
+ return append(buffer, byte(n))
+
+ case n <= 0xffff:
+ return append(buffer, 0xfc, byte(n), byte(n>>8))
+
+ case n <= 0xffffff:
+ return append(buffer, 0xfd, byte(n), byte(n>>8), byte(n>>16))
+
+ case n <= 0xffffffffffffffff:
+ return append(buffer, 0xfe, byte(n), byte(n>>8), byte(n>>16), byte(n>>24),
+ byte(n>>32), byte(n>>40), byte(n>>48), byte(n>>56))
+ }
+
+ return buffer
+}
+
+func parseLengthEncodedBytes(b []byte) ([]byte, bool, int, error) {
+ // Get length
+ num, isNull, n := parseLengthEncodedInt(b)
+ if num < 1 {
+ return nil, isNull, n, nil
+ }
+
+ n += int(num)
+
+ // Check data length
+ if len(b) >= n {
+ return b[n-int(num) : n], false, n, nil
+ }
+
+ return nil, false, n, io.EOF
+}
+
+func dumpLengthEncodedString(buffer []byte, bytes []byte) []byte {
+ buffer = dumpLengthEncodedInt(buffer, uint64(len(bytes)))
+ buffer = append(buffer, bytes...)
+ return buffer
+}
+
+func dumpUint16(buffer []byte, n uint16) []byte {
+ buffer = append(buffer, byte(n))
+ buffer = append(buffer, byte(n>>8))
+ return buffer
+}
+
+func dumpUint32(buffer []byte, n uint32) []byte {
+ buffer = append(buffer, byte(n))
+ buffer = append(buffer, byte(n>>8))
+ buffer = append(buffer, byte(n>>16))
+ buffer = append(buffer, byte(n>>24))
+ return buffer
+}
+
+func dumpUint64(buffer []byte, n uint64) []byte {
+ buffer = append(buffer, byte(n))
+ buffer = append(buffer, byte(n>>8))
+ buffer = append(buffer, byte(n>>16))
+ buffer = append(buffer, byte(n>>24))
+ buffer = append(buffer, byte(n>>32))
+ buffer = append(buffer, byte(n>>40))
+ buffer = append(buffer, byte(n>>48))
+ buffer = append(buffer, byte(n>>56))
+ return buffer
+}
+
+func dumpBinaryTime(dur time.Duration) (data []byte) {
+ if dur == 0 {
+ return []byte{0}
+ }
+ data = make([]byte, 13)
+ data[0] = 12
+ if dur < 0 {
+ data[1] = 1
+ dur = -dur
+ }
+ days := dur / (24 * time.Hour)
+ dur -= days * 24 * time.Hour
+ data[2] = byte(days)
+ hours := dur / time.Hour
+ dur -= hours * time.Hour
+ data[6] = byte(hours)
+ minutes := dur / time.Minute
+ dur -= minutes * time.Minute
+ data[7] = byte(minutes)
+ seconds := dur / time.Second
+ dur -= seconds * time.Second
+ data[8] = byte(seconds)
+ if dur == 0 {
+ data[0] = 8
+ return data[:9]
+ }
+ binary.LittleEndian.PutUint32(data[9:13], uint32(dur/time.Microsecond))
+ return
+}
+
+func lengthEncodedIntSize(n uint64) int {
+ switch {
+ case n <= 250:
+ return 1
+
+ case n <= 0xffff:
+ return 3
+
+ case n <= 0xffffff:
+ return 4
+ }
+
+ return 9
+}
+
+const (
+ expFormatBig = 1e15
+ expFormatSmall = 1e-15
+ defaultMySQLPrec = 5
+)
+
+func appendFormatFloat(in []byte, fVal float64, prec, bitSize int) []byte {
+ absVal := math.Abs(fVal)
+ if absVal > math.MaxFloat64 || math.IsNaN(absVal) {
+ return []byte{'0'}
+ }
+ isEFormat := false
+ if bitSize == 32 {
+ isEFormat = float32(absVal) >= expFormatBig || (float32(absVal) != 0 && float32(absVal) < expFormatSmall)
+ } else {
+ isEFormat = absVal >= expFormatBig || (absVal != 0 && absVal < expFormatSmall)
+ }
+ var out []byte
+ if isEFormat {
+ if bitSize == 32 {
+ prec = defaultMySQLPrec
+ }
+ out = strconv.AppendFloat(in, fVal, 'e', prec, bitSize)
+ valStr := out[len(in):]
+ // remove the '+' from the string for compatibility.
+ plusPos := bytes.IndexByte(valStr, '+')
+ if plusPos > 0 {
+ plusPosInOut := len(in) + plusPos
+ out = append(out[:plusPosInOut], out[plusPosInOut+1:]...)
+ }
+ // remove extra '0'
+ ePos := bytes.IndexByte(valStr, 'e')
+ pointPos := bytes.IndexByte(valStr, '.')
+ ePosInOut := len(in) + ePos
+ pointPosInOut := len(in) + pointPos
+ validPos := ePosInOut
+ for i := ePosInOut - 1; i >= pointPosInOut; i-- {
+ if out[i] == '0' || out[i] == '.' {
+ validPos = i
+ } else {
+ break
+ }
+ }
+ out = append(out[:validPos], out[ePosInOut:]...)
+ } else {
+ out = strconv.AppendFloat(in, fVal, 'f', prec, bitSize)
+ }
+ return out
+}
diff --git a/pkg/session/db.go b/pkg/session/db.go
new file mode 100644
index 0000000000000000000000000000000000000000..2034903763784c8e6ca8201ed35fcf0724d00076
--- /dev/null
+++ b/pkg/session/db.go
@@ -0,0 +1,48 @@
+// Copyright 2013 The ql Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSES/QL-LICENSE file.
+
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package session
+
+import (
+ "github.com/pingcap/parser"
+ "github.com/pingcap/parser/ast"
+ "matrixbase/pkg/errno"
+ "matrixbase/pkg/sessionctx"
+ "matrixbase/pkg/util/dbterror"
+)
+
+// Parse parses a query string to raw ast.StmtNode.
+func Parse(ctx sessionctx.Context, src string) ([]ast.StmtNode, error) {
+ // logutil.BgLogger().Debug("compiling", zap.String("source", src))
+ charset, collation := ctx.GetSessionVars().GetCharsetInfo()
+ p := parser.New()
+ p.SetParserConfig(ctx.GetSessionVars().BuildParserConfig())
+ p.SetSQLMode(ctx.GetSessionVars().SQLMode)
+ stmts, warns, err := p.Parse(src, charset, collation)
+ for _, warn := range warns {
+ ctx.GetSessionVars().StmtCtx.AppendWarning(warn)
+ }
+ if err != nil {
+ return nil, err
+ }
+ return stmts, nil
+}
+
+// Session errors.
+var (
+ ErrForUpdateCantRetry = dbterror.ClassSession.NewStd(errno.ErrForUpdateCantRetry)
+)
diff --git a/pkg/session/session.go b/pkg/session/session.go
new file mode 100644
index 0000000000000000000000000000000000000000..de9fdfa0a8bcbc8a069b2f0ba0a7e6b691e04bae
--- /dev/null
+++ b/pkg/session/session.go
@@ -0,0 +1,237 @@
+package session
+
+import (
+ "context"
+ "crypto/tls"
+ "fmt"
+ "github.com/pingcap/parser"
+ "github.com/pingcap/parser/ast"
+ "github.com/pingcap/parser/auth"
+ "github.com/pingcap/parser/charset"
+ "github.com/pingcap/parser/model"
+ "github.com/pingcap/parser/terror"
+ "matrixbase/pkg/sessionctx"
+ "matrixbase/pkg/sessionctx/variable"
+ "matrixbase/pkg/util"
+ "sync"
+ "sync/atomic"
+)
+
+type Session interface {
+ sessionctx.Context
+ Status() uint16 // Flag of current status, such as autocommit.
+ Parse(ctx context.Context, sql string) ([]ast.StmtNode, error)
+ Auth(user *auth.UserIdentity, auth []byte, salt []byte) bool
+ SetPort(port string)
+ SetSessionManager(util.SessionManager)
+ GetSessionManager() util.SessionManager
+ SetCommandValue(byte)
+ LastInsertID() uint64 // LastInsertID is the last inserted auto_increment ID.
+ LastMessage() string // LastMessage is the info message that may be generated by last command
+ AffectedRows() uint64 // Affected rows by latest executed stmt.
+ Close()
+ AuthWithoutVerification(user *auth.UserIdentity) bool
+ SetClientCapability(uint32) // Set client capability flags.
+ SetConnectionID(uint64)
+ SetTLSState(*tls.ConnectionState)
+ SetCollation(coID int) error
+}
+
+type session struct {
+ // processInfo is used by ShowProcess(), and should be modified atomically.
+ processInfo atomic.Value
+
+ mu struct {
+ sync.RWMutex
+ values map[fmt.Stringer]interface{}
+ }
+
+ currentCtx context.Context // only use for runtime.trace, Please NEVER use it.
+ // currentPlan plannercore.Plan
+
+ parser *parser.Parser
+
+ sessionVars *variable.SessionVars
+ sessionManager util.SessionManager
+
+ // lockedTables use to record the table locks hold by the session.
+ lockedTables map[int64]model.TableLockTpInfo
+}
+
+// Opt describes the option for creating session
+type Opt struct {
+}
+
+// CreateSession4TestWithOpt creates a new session environment for test.
+func CreateSession4TestWithOpt(opt *Opt) (*session, error) {
+ s, err := CreateSessionWithOpt(opt)
+ return s, err
+}
+
+// CreateSession creates a new session environment.
+func CreateSession() (*session, error) {
+ return CreateSessionWithOpt(nil)
+}
+
+// CreateSessionWithOpt creates a new session environment with option.
+// Use default option if opt is nil.
+func CreateSessionWithOpt(opt *Opt) (*session, error) {
+ s, err := createSessionWithOpt(opt)
+ if err != nil {
+ return nil, err
+ }
+
+ return s, nil
+}
+
+func createSessionWithOpt(opt *Opt) (*session, error) {
+ s := &session{
+ parser: parser.New(),
+ sessionVars: variable.NewSessionVars(),
+ }
+ s.mu.values = make(map[fmt.Stringer]interface{})
+
+ return s, nil
+}
+
+func (s *session) SetValue(key fmt.Stringer, value interface{}) {
+ s.mu.Lock()
+ s.mu.values[key] = value
+ s.mu.Unlock()
+}
+
+func (s *session) Value(key fmt.Stringer) interface{} {
+ s.mu.RLock()
+ value := s.mu.values[key]
+ s.mu.RUnlock()
+ return value
+}
+
+func (s *session) ClearValue(key fmt.Stringer) {
+ s.mu.Lock()
+ delete(s.mu.values, key)
+ s.mu.Unlock()
+}
+
+func (s *session) Status() uint16 {
+ return s.sessionVars.Status
+}
+
+func (s *session) LastInsertID() uint64 {
+ if s.sessionVars.StmtCtx.LastInsertID > 0 {
+ return s.sessionVars.StmtCtx.LastInsertID
+ }
+ return s.sessionVars.StmtCtx.InsertID
+}
+
+func (s *session) LastMessage() string {
+ return s.sessionVars.StmtCtx.GetMessage()
+}
+
+func (s *session) AffectedRows() uint64 {
+ return s.sessionVars.StmtCtx.AffectedRows()
+}
+
+func (s *session) Close() {
+}
+
+func (s *session) Auth(user *auth.UserIdentity, authentication []byte, salt []byte) bool {
+ return true
+}
+
+// AuthWithoutVerification is required by the ResetConnection RPC
+func (s *session) AuthWithoutVerification(user *auth.UserIdentity) bool {
+ return true
+}
+
+func (s *session) SetSessionManager(sm util.SessionManager) {
+ s.sessionManager = sm
+}
+
+func (s *session) GetSessionManager() util.SessionManager {
+ return s.sessionManager
+}
+
+func (s *session) SetClientCapability(capability uint32) {
+ s.sessionVars.ClientCapability = capability
+}
+
+func (s *session) SetTLSState(tlsState *tls.ConnectionState) {
+ // If user is not connected via TLS, then tlsState == nil.
+ if tlsState != nil {
+ s.sessionVars.TLSConnectionState = tlsState
+ }
+}
+
+func (s *session) SetCollation(coID int) error {
+ cs, co, err := charset.GetCharsetInfoByID(coID)
+ if err != nil {
+ return err
+ }
+ for _, v := range variable.SetNamesVariables {
+ terror.Log(s.sessionVars.SetSystemVar(v, cs))
+ }
+ return s.sessionVars.SetSystemVar(variable.CollationConnection, co)
+}
+
+// GetGlobalSysVar implements GlobalVarAccessor.GetGlobalSysVar interface.
+func (s *session) GetGlobalSysVar(name string) (string, error) {
+ return "", nil
+}
+
+// SetGlobalSysVar implements GlobalVarAccessor.SetGlobalSysVar interface.
+func (s *session) SetGlobalSysVar(name, value string) error {
+ return nil
+}
+
+func (s *session) SetConnectionID(connectionID uint64) {
+ s.sessionVars.ConnectionID = connectionID
+}
+
+// GetSessionVars implements the context.Context interface.
+func (s *session) GetSessionVars() *variable.SessionVars {
+ return s.sessionVars
+}
+
+// rollbackOnError makes sure the next statement starts a new transaction with the latest InfoSchema.
+func (s *session) rollbackOnError(ctx context.Context) {
+}
+
+func (s *session) ParseSQL(ctx context.Context, sql, charset, collation string) ([]ast.StmtNode, []error, error) {
+ s.parser.SetSQLMode(s.sessionVars.SQLMode)
+ s.parser.SetParserConfig(s.sessionVars.BuildParserConfig())
+ return s.parser.Parse(sql, charset, collation)
+}
+
+// Parse parses a query string to raw ast.StmtNode.
+func (s *session) Parse(ctx context.Context, sql string) ([]ast.StmtNode, error) {
+ charsetInfo, collation := s.sessionVars.GetCharsetInfo()
+ stmts, warns, err := s.ParseSQL(ctx, sql, charsetInfo, collation)
+ if err != nil {
+ s.rollbackOnError(ctx)
+
+ // Only print log message when this SQL is from the user.
+ // Mute the warning for internal SQLs.
+ // if !s.sessionVars.InRestrictedSQL {
+ // if s.sessionVars.EnableRedactLog {
+ // logutil.Logger(ctx).Debug("parse SQL failed", zap.Error(err), zap.String("SQL", sql))
+ // } else {
+ // logutil.Logger(ctx).Warn("parse SQL failed", zap.Error(err), zap.String("SQL", sql))
+ // }
+ // }
+ return nil, util.SyntaxError(err)
+ }
+
+ for _, warn := range warns {
+ s.sessionVars.StmtCtx.AppendWarning(util.SyntaxWarn(warn))
+ }
+ return stmts, nil
+}
+
+func (s *session) SetCommandValue(command byte) {
+ atomic.StoreUint32(&s.sessionVars.CommandValue, uint32(command))
+}
+
+func (s *session) SetPort(port string) {
+ s.sessionVars.Port = port
+}
diff --git a/pkg/sessionctx/context.go b/pkg/sessionctx/context.go
new file mode 100644
index 0000000000000000000000000000000000000000..e7259baba8478574bc098bcba2ce59ee92cfd034
--- /dev/null
+++ b/pkg/sessionctx/context.go
@@ -0,0 +1,52 @@
+package sessionctx
+
+import (
+ "fmt"
+
+ "matrixbase/pkg/sessionctx/variable"
+ "matrixbase/pkg/util"
+)
+
+// Context is an interface for transaction and executive args environment.
+type Context interface {
+ // SetValue saves a value associated with this context for key.
+ SetValue(key fmt.Stringer, value interface{})
+
+ // Value returns the value associated with this context for key.
+ Value(key fmt.Stringer) interface{}
+
+ // ClearValue clears the value associated with this context for key.
+ ClearValue(key fmt.Stringer)
+
+ GetSessionVars() *variable.SessionVars
+
+ GetSessionManager() util.SessionManager
+
+ // RefreshVars refreshes modified global variable to current session.
+ // only used to daemon session like `statsHandle` to detect global variable change.
+ // RefreshVars(context.Context) error
+}
+
+type basicCtxType int
+
+func (t basicCtxType) String() string {
+ switch t {
+ case QueryString:
+ return "query_string"
+ case Initing:
+ return "initing"
+ case LastExecuteDDL:
+ return "last_execute_ddl"
+ }
+ return "unknown"
+}
+
+// Context keys.
+const (
+ // QueryString is the key for original query string.
+ QueryString basicCtxType = 1
+ // Initing is the key for indicating if the server is running bootstrap or upgrade job.
+ Initing basicCtxType = 2
+ // LastExecuteDDL is the key for whether the session execute a ddl command last time.
+ LastExecuteDDL basicCtxType = 3
+)
diff --git a/pkg/sessionctx/stmtctx/stmtctx.go b/pkg/sessionctx/stmtctx/stmtctx.go
new file mode 100644
index 0000000000000000000000000000000000000000..7bd5a3693e0934c95efafaeea559e8fe9afe7ed9
--- /dev/null
+++ b/pkg/sessionctx/stmtctx/stmtctx.go
@@ -0,0 +1,613 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package stmtctx
+
+import (
+ "math"
+ "strconv"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "github.com/pingcap/parser"
+ "github.com/pingcap/parser/model"
+ "github.com/pingcap/parser/mysql"
+ "go.uber.org/zap"
+)
+
+const (
+ // WarnLevelError represents level "Error" for 'SHOW WARNINGS' syntax.
+ WarnLevelError = "Error"
+ // WarnLevelWarning represents level "Warning" for 'SHOW WARNINGS' syntax.
+ WarnLevelWarning = "Warning"
+ // WarnLevelNote represents level "Note" for 'SHOW WARNINGS' syntax.
+ WarnLevelNote = "Note"
+)
+
+var taskIDAlloc uint64
+
+// AllocateTaskID allocates a new unique ID for a statement execution
+func AllocateTaskID() uint64 {
+ return atomic.AddUint64(&taskIDAlloc, 1)
+}
+
+// SQLWarn relates a sql warning and it's level.
+type SQLWarn struct {
+ Level string
+ Err error
+}
+
+// StatementContext contains variables for a statement.
+// It should be reset before executing a statement.
+type StatementContext struct {
+ // Set the following variables before execution
+ StmtHints
+
+ // IsDDLJobInQueue is used to mark whether the DDL job is put into the queue.
+ // If IsDDLJobInQueue is true, it means the DDL job is in the queue of storage, and it can be handled by the DDL worker.
+ IsDDLJobInQueue bool
+ InInsertStmt bool
+ InUpdateStmt bool
+ InDeleteStmt bool
+ InSelectStmt bool
+ InLoadDataStmt bool
+ InExplainStmt bool
+ InCreateOrAlterStmt bool
+ IgnoreTruncate bool
+ IgnoreZeroInDate bool
+ DupKeyAsWarning bool
+ BadNullAsWarning bool
+ DividedByZeroAsWarning bool
+ TruncateAsWarning bool
+ OverflowAsWarning bool
+ InShowWarning bool
+ UseCache bool
+ BatchCheck bool
+ InNullRejectCheck bool
+ AllowInvalidDate bool
+ IgnoreNoPartition bool
+ OptimDependOnMutableConst bool
+ IgnoreExplainIDSuffix bool
+
+ // mu struct holds variables that change during execution.
+ mu struct {
+ sync.Mutex
+
+ affectedRows uint64
+ foundRows uint64
+
+ /*
+ following variables are ported from 'COPY_INFO' struct of MySQL server source,
+ they are used to count rows for INSERT/REPLACE/UPDATE queries:
+ If a row is inserted then the copied variable is incremented.
+ If a row is updated by the INSERT ... ON DUPLICATE KEY UPDATE and the
+ new data differs from the old one then the copied and the updated
+ variables are incremented.
+ The touched variable is incremented if a row was touched by the update part
+ of the INSERT ... ON DUPLICATE KEY UPDATE no matter whether the row
+ was actually changed or not.
+
+ see https://github.com/mysql/mysql-server/blob/d2029238d6d9f648077664e4cdd611e231a6dc14/sql/sql_data_change.h#L60 for more details
+ */
+ records uint64
+ updated uint64
+ copied uint64
+ touched uint64
+
+ message string
+ warnings []SQLWarn
+ errorCount uint16
+ histogramsNotLoad bool
+ }
+ // PrevAffectedRows is the affected-rows value(DDL is 0, DML is the number of affected rows).
+ PrevAffectedRows int64
+ // PrevLastInsertID is the last insert ID of previous statement.
+ PrevLastInsertID uint64
+ // LastInsertID is the auto-generated ID in the current statement.
+ LastInsertID uint64
+ // InsertID is the given insert ID of an auto_increment column.
+ InsertID uint64
+
+ BaseRowID int64
+ MaxRowID int64
+
+ // Copied from SessionVars.TimeZone.
+ TimeZone *time.Location
+ Priority mysql.PriorityEnum
+ NotFillCache bool
+ TableIDs []int64
+ IndexNames []string
+ nowTs time.Time // use this variable for now/current_timestamp calculation/cache for one stmt
+ stmtTimeCached bool
+ StmtType string
+ OriginalSQL string
+ digestMemo struct {
+ sync.Once
+ normalized string
+ digest string
+ }
+ // planNormalized use for cache the normalized plan, avoid duplicate builds.
+ planNormalized string
+ planDigest string
+ encodedPlan string
+ planHint string
+ planHintSet bool
+ Tables []TableEntry
+ PointExec bool // for point update cached execution, Constant expression need to set "paramMarker"
+ lockWaitStartTime int64 // LockWaitStartTime stores the pessimistic lock wait start time
+ PessimisticLockWaited int32
+ LockKeysDuration int64
+ LockKeysCount int32
+ TblInfo2UnionScan map[*model.TableInfo]bool
+ TaskID uint64 // unique ID for an execution of a statement
+ TaskMapBakTS uint64 // counter for
+}
+
+// StmtHints are SessionVars related sql hints.
+type StmtHints struct {
+ // Hint Information
+ MemQuotaQuery int64
+ ApplyCacheCapacity int64
+ MaxExecutionTime uint64
+ ReplicaRead byte
+ AllowInSubqToJoinAndAgg bool
+ NoIndexMergeHint bool
+ // EnableCascadesPlanner is use cascades planner for a single query only.
+ EnableCascadesPlanner bool
+ // ForceNthPlan indicates the PlanCounterTp number for finding physical plan.
+ // -1 for disable.
+ ForceNthPlan int64
+
+ // Hint flags
+ HasAllowInSubqToJoinAndAggHint bool
+ HasMemQuotaHint bool
+ HasReplicaReadHint bool
+ HasMaxExecutionTime bool
+ HasEnableCascadesPlannerHint bool
+ SetVars map[string]string
+}
+
+// TaskMapNeedBackUp indicates that whether we need to back up taskMap during physical optimizing.
+func (sh *StmtHints) TaskMapNeedBackUp() bool {
+ return sh.ForceNthPlan != -1
+}
+
+// GetNowTsCached getter for nowTs, if not set get now time and cache it
+func (sc *StatementContext) GetNowTsCached() time.Time {
+ if !sc.stmtTimeCached {
+ now := time.Now()
+ sc.nowTs = now
+ sc.stmtTimeCached = true
+ }
+ return sc.nowTs
+}
+
+// ResetNowTs resetter for nowTs, clear cached time flag
+func (sc *StatementContext) ResetNowTs() {
+ sc.stmtTimeCached = false
+}
+
+// SQLDigest gets normalized and digest for provided sql.
+// it will cache result after first calling.
+func (sc *StatementContext) SQLDigest() (normalized, sqlDigest string) {
+ sc.digestMemo.Do(func() {
+ sc.digestMemo.normalized, sc.digestMemo.digest = parser.NormalizeDigest(sc.OriginalSQL)
+ })
+ return sc.digestMemo.normalized, sc.digestMemo.digest
+}
+
+// InitSQLDigest sets the normalized and digest for sql.
+func (sc *StatementContext) InitSQLDigest(normalized, digest string) {
+ sc.digestMemo.Do(func() {
+ sc.digestMemo.normalized, sc.digestMemo.digest = normalized, digest
+ })
+}
+
+// GetPlanDigest gets the normalized plan and plan digest.
+func (sc *StatementContext) GetPlanDigest() (normalized, planDigest string) {
+ return sc.planNormalized, sc.planDigest
+}
+
+// SetPlanDigest sets the normalized plan and plan digest.
+func (sc *StatementContext) SetPlanDigest(normalized, planDigest string) {
+ sc.planNormalized, sc.planDigest = normalized, planDigest
+}
+
+// GetEncodedPlan gets the encoded plan, it is used to avoid repeated encode.
+func (sc *StatementContext) GetEncodedPlan() string {
+ return sc.encodedPlan
+}
+
+// SetEncodedPlan sets the encoded plan, it is used to avoid repeated encode.
+func (sc *StatementContext) SetEncodedPlan(encodedPlan string) {
+ sc.encodedPlan = encodedPlan
+}
+
+// GetPlanHint gets the hint string generated from the plan.
+func (sc *StatementContext) GetPlanHint() (string, bool) {
+ return sc.planHint, sc.planHintSet
+}
+
+// SetPlanHint sets the hint for the plan.
+func (sc *StatementContext) SetPlanHint(hint string) {
+ sc.planHintSet = true
+ sc.planHint = hint
+}
+
+// TableEntry presents table in db.
+type TableEntry struct {
+ DB string
+ Table string
+}
+
+// AddAffectedRows adds affected rows.
+func (sc *StatementContext) AddAffectedRows(rows uint64) {
+ sc.mu.Lock()
+ sc.mu.affectedRows += rows
+ sc.mu.Unlock()
+}
+
+// AffectedRows gets affected rows.
+func (sc *StatementContext) AffectedRows() uint64 {
+ sc.mu.Lock()
+ rows := sc.mu.affectedRows
+ sc.mu.Unlock()
+ return rows
+}
+
+// FoundRows gets found rows.
+func (sc *StatementContext) FoundRows() uint64 {
+ sc.mu.Lock()
+ rows := sc.mu.foundRows
+ sc.mu.Unlock()
+ return rows
+}
+
+// AddFoundRows adds found rows.
+func (sc *StatementContext) AddFoundRows(rows uint64) {
+ sc.mu.Lock()
+ sc.mu.foundRows += rows
+ sc.mu.Unlock()
+}
+
+// RecordRows is used to generate info message
+func (sc *StatementContext) RecordRows() uint64 {
+ sc.mu.Lock()
+ rows := sc.mu.records
+ sc.mu.Unlock()
+ return rows
+}
+
+// AddRecordRows adds record rows.
+func (sc *StatementContext) AddRecordRows(rows uint64) {
+ sc.mu.Lock()
+ sc.mu.records += rows
+ sc.mu.Unlock()
+}
+
+// UpdatedRows is used to generate info message
+func (sc *StatementContext) UpdatedRows() uint64 {
+ sc.mu.Lock()
+ rows := sc.mu.updated
+ sc.mu.Unlock()
+ return rows
+}
+
+// AddUpdatedRows adds updated rows.
+func (sc *StatementContext) AddUpdatedRows(rows uint64) {
+ sc.mu.Lock()
+ sc.mu.updated += rows
+ sc.mu.Unlock()
+}
+
+// CopiedRows is used to generate info message
+func (sc *StatementContext) CopiedRows() uint64 {
+ sc.mu.Lock()
+ rows := sc.mu.copied
+ sc.mu.Unlock()
+ return rows
+}
+
+// AddCopiedRows adds copied rows.
+func (sc *StatementContext) AddCopiedRows(rows uint64) {
+ sc.mu.Lock()
+ sc.mu.copied += rows
+ sc.mu.Unlock()
+}
+
+// TouchedRows is used to generate info message
+func (sc *StatementContext) TouchedRows() uint64 {
+ sc.mu.Lock()
+ rows := sc.mu.touched
+ sc.mu.Unlock()
+ return rows
+}
+
+// AddTouchedRows adds touched rows.
+func (sc *StatementContext) AddTouchedRows(rows uint64) {
+ sc.mu.Lock()
+ sc.mu.touched += rows
+ sc.mu.Unlock()
+}
+
+// GetMessage returns the extra message of the last executed command, if there is no message, it returns empty string
+func (sc *StatementContext) GetMessage() string {
+ sc.mu.Lock()
+ msg := sc.mu.message
+ sc.mu.Unlock()
+ return msg
+}
+
+// SetMessage sets the info message generated by some commands
+func (sc *StatementContext) SetMessage(msg string) {
+ sc.mu.Lock()
+ sc.mu.message = msg
+ sc.mu.Unlock()
+}
+
+// GetWarnings gets warnings.
+func (sc *StatementContext) GetWarnings() []SQLWarn {
+ sc.mu.Lock()
+ warns := make([]SQLWarn, len(sc.mu.warnings))
+ copy(warns, sc.mu.warnings)
+ sc.mu.Unlock()
+ return warns
+}
+
+// TruncateWarnings truncates wanrings begin from start and returns the truncated warnings.
+func (sc *StatementContext) TruncateWarnings(start int) []SQLWarn {
+ sc.mu.Lock()
+ defer sc.mu.Unlock()
+ sz := len(sc.mu.warnings) - start
+ if sz <= 0 {
+ return nil
+ }
+ ret := make([]SQLWarn, sz)
+ copy(ret, sc.mu.warnings[start:])
+ sc.mu.warnings = sc.mu.warnings[:start]
+ return ret
+}
+
+// WarningCount gets warning count.
+func (sc *StatementContext) WarningCount() uint16 {
+ if sc.InShowWarning {
+ return 0
+ }
+ sc.mu.Lock()
+ wc := uint16(len(sc.mu.warnings))
+ sc.mu.Unlock()
+ return wc
+}
+
+// NumErrorWarnings gets warning and error count.
+func (sc *StatementContext) NumErrorWarnings() (ec uint16, wc int) {
+ sc.mu.Lock()
+ ec = sc.mu.errorCount
+ wc = len(sc.mu.warnings)
+ sc.mu.Unlock()
+ return
+}
+
+// SetWarnings sets warnings.
+func (sc *StatementContext) SetWarnings(warns []SQLWarn) {
+ sc.mu.Lock()
+ sc.mu.warnings = warns
+ for _, w := range warns {
+ if w.Level == WarnLevelError {
+ sc.mu.errorCount++
+ }
+ }
+ sc.mu.Unlock()
+}
+
+// AppendWarning appends a warning with level 'Warning'.
+func (sc *StatementContext) AppendWarning(warn error) {
+ sc.mu.Lock()
+ if len(sc.mu.warnings) < math.MaxUint16 {
+ sc.mu.warnings = append(sc.mu.warnings, SQLWarn{WarnLevelWarning, warn})
+ }
+ sc.mu.Unlock()
+}
+
+// AppendWarnings appends some warnings.
+func (sc *StatementContext) AppendWarnings(warns []SQLWarn) {
+ sc.mu.Lock()
+ if len(sc.mu.warnings) < math.MaxUint16 {
+ sc.mu.warnings = append(sc.mu.warnings, warns...)
+ }
+ sc.mu.Unlock()
+}
+
+// AppendNote appends a warning with level 'Note'.
+func (sc *StatementContext) AppendNote(warn error) {
+ sc.mu.Lock()
+ if len(sc.mu.warnings) < math.MaxUint16 {
+ sc.mu.warnings = append(sc.mu.warnings, SQLWarn{WarnLevelNote, warn})
+ }
+ sc.mu.Unlock()
+}
+
+// AppendError appends a warning with level 'Error'.
+func (sc *StatementContext) AppendError(warn error) {
+ sc.mu.Lock()
+ if len(sc.mu.warnings) < math.MaxUint16 {
+ sc.mu.warnings = append(sc.mu.warnings, SQLWarn{WarnLevelError, warn})
+ sc.mu.errorCount++
+ }
+ sc.mu.Unlock()
+}
+
+// SetHistogramsNotLoad sets histogramsNotLoad.
+func (sc *StatementContext) SetHistogramsNotLoad() {
+ sc.mu.Lock()
+ sc.mu.histogramsNotLoad = true
+ sc.mu.Unlock()
+}
+
+// HandleTruncate ignores or returns the error based on the StatementContext state.
+func (sc *StatementContext) HandleTruncate(err error) error {
+ // TODO: At present we have not checked whether the error can be ignored or treated as warning.
+ // We will do that later, and then append WarnDataTruncated instead of the error itself.
+ if err == nil {
+ return nil
+ }
+ if sc.IgnoreTruncate {
+ return nil
+ }
+ if sc.TruncateAsWarning {
+ sc.AppendWarning(err)
+ return nil
+ }
+ return err
+}
+
+// HandleOverflow treats ErrOverflow as warnings or returns the error based on the StmtCtx.OverflowAsWarning state.
+func (sc *StatementContext) HandleOverflow(err error, warnErr error) error {
+ if err == nil {
+ return nil
+ }
+
+ if sc.OverflowAsWarning {
+ sc.AppendWarning(warnErr)
+ return nil
+ }
+ return err
+}
+
+// ResetForRetry resets the changed states during execution.
+func (sc *StatementContext) ResetForRetry() {
+ sc.mu.Lock()
+ sc.mu.affectedRows = 0
+ sc.mu.foundRows = 0
+ sc.mu.records = 0
+ sc.mu.updated = 0
+ sc.mu.copied = 0
+ sc.mu.touched = 0
+ sc.mu.message = ""
+ sc.mu.errorCount = 0
+ sc.mu.warnings = nil
+ sc.mu.Unlock()
+ sc.MaxRowID = 0
+ sc.BaseRowID = 0
+ sc.TableIDs = sc.TableIDs[:0]
+ sc.IndexNames = sc.IndexNames[:0]
+ sc.TaskID = AllocateTaskID()
+}
+
+// ShouldClipToZero indicates whether values less than 0 should be clipped to 0 for unsigned integer types.
+// This is the case for `insert`, `update`, `alter table`, `create table` and `load data infile` statements, when not in strict SQL mode.
+// see https://dev.mysql.com/doc/refman/5.7/en/out-of-range-and-overflow.html
+func (sc *StatementContext) ShouldClipToZero() bool {
+ return sc.InInsertStmt || sc.InLoadDataStmt || sc.InUpdateStmt || sc.InCreateOrAlterStmt || sc.IsDDLJobInQueue
+}
+
+// ShouldIgnoreOverflowError indicates whether we should ignore the error when type conversion overflows,
+// so we can leave it for further processing like clipping values less than 0 to 0 for unsigned integer types.
+func (sc *StatementContext) ShouldIgnoreOverflowError() bool {
+ if (sc.InInsertStmt && sc.TruncateAsWarning) || sc.InLoadDataStmt {
+ return true
+ }
+ return false
+}
+
+// PushDownFlags converts StatementContext to tipb.SelectRequest.Flags.
+func (sc *StatementContext) PushDownFlags() uint64 {
+ var flags uint64
+ if sc.InInsertStmt {
+ flags |= model.FlagInInsertStmt
+ } else if sc.InUpdateStmt || sc.InDeleteStmt {
+ flags |= model.FlagInUpdateOrDeleteStmt
+ } else if sc.InSelectStmt {
+ flags |= model.FlagInSelectStmt
+ }
+ if sc.IgnoreTruncate {
+ flags |= model.FlagIgnoreTruncate
+ } else if sc.TruncateAsWarning {
+ flags |= model.FlagTruncateAsWarning
+ }
+ if sc.OverflowAsWarning {
+ flags |= model.FlagOverflowAsWarning
+ }
+ if sc.IgnoreZeroInDate {
+ flags |= model.FlagIgnoreZeroInDate
+ }
+ if sc.DividedByZeroAsWarning {
+ flags |= model.FlagDividedByZeroAsWarning
+ }
+ if sc.InLoadDataStmt {
+ flags |= model.FlagInLoadDataStmt
+ }
+ return flags
+}
+
+// SetFlagsFromPBFlag set the flag of StatementContext from a `tipb.SelectRequest.Flags`.
+func (sc *StatementContext) SetFlagsFromPBFlag(flags uint64) {
+ sc.IgnoreTruncate = (flags & model.FlagIgnoreTruncate) > 0
+ sc.TruncateAsWarning = (flags & model.FlagTruncateAsWarning) > 0
+ sc.InInsertStmt = (flags & model.FlagInInsertStmt) > 0
+ sc.InSelectStmt = (flags & model.FlagInSelectStmt) > 0
+ sc.OverflowAsWarning = (flags & model.FlagOverflowAsWarning) > 0
+ sc.IgnoreZeroInDate = (flags & model.FlagIgnoreZeroInDate) > 0
+ sc.DividedByZeroAsWarning = (flags & model.FlagDividedByZeroAsWarning) > 0
+}
+
+// GetLockWaitStartTime returns the statement pessimistic lock wait start time
+func (sc *StatementContext) GetLockWaitStartTime() time.Time {
+ startTime := atomic.LoadInt64(&sc.lockWaitStartTime)
+ if startTime == 0 {
+ startTime = time.Now().UnixNano()
+ atomic.StoreInt64(&sc.lockWaitStartTime, startTime)
+ }
+ return time.Unix(0, startTime)
+}
+
+// CopTasksDetails collects some useful information of cop-tasks during execution.
+type CopTasksDetails struct {
+ NumCopTasks int
+
+ AvgProcessTime time.Duration
+ P90ProcessTime time.Duration
+ MaxProcessAddress string
+ MaxProcessTime time.Duration
+
+ AvgWaitTime time.Duration
+ P90WaitTime time.Duration
+ MaxWaitAddress string
+ MaxWaitTime time.Duration
+
+ MaxBackoffTime map[string]time.Duration
+ MaxBackoffAddress map[string]string
+ AvgBackoffTime map[string]time.Duration
+ P90BackoffTime map[string]time.Duration
+ TotBackoffTime map[string]time.Duration
+ TotBackoffTimes map[string]int
+}
+
+// ToZapFields wraps the CopTasksDetails as zap.Fileds.
+func (d *CopTasksDetails) ToZapFields() (fields []zap.Field) {
+ if d.NumCopTasks == 0 {
+ return
+ }
+ fields = make([]zap.Field, 0, 10)
+ fields = append(fields, zap.Int("num_cop_tasks", d.NumCopTasks))
+ fields = append(fields, zap.String("process_avg_time", strconv.FormatFloat(d.AvgProcessTime.Seconds(), 'f', -1, 64)+"s"))
+ fields = append(fields, zap.String("process_p90_time", strconv.FormatFloat(d.P90ProcessTime.Seconds(), 'f', -1, 64)+"s"))
+ fields = append(fields, zap.String("process_max_time", strconv.FormatFloat(d.MaxProcessTime.Seconds(), 'f', -1, 64)+"s"))
+ fields = append(fields, zap.String("process_max_addr", d.MaxProcessAddress))
+ fields = append(fields, zap.String("wait_avg_time", strconv.FormatFloat(d.AvgWaitTime.Seconds(), 'f', -1, 64)+"s"))
+ fields = append(fields, zap.String("wait_p90_time", strconv.FormatFloat(d.P90WaitTime.Seconds(), 'f', -1, 64)+"s"))
+ fields = append(fields, zap.String("wait_max_time", strconv.FormatFloat(d.MaxWaitTime.Seconds(), 'f', -1, 64)+"s"))
+ fields = append(fields, zap.String("wait_max_addr", d.MaxWaitAddress))
+ return fields
+}
diff --git a/pkg/sessionctx/variable/db_vars.go b/pkg/sessionctx/variable/db_vars.go
new file mode 100644
index 0000000000000000000000000000000000000000..1759637f40adec4d91a4c1a5cb054b57fd7bfe16
--- /dev/null
+++ b/pkg/sessionctx/variable/db_vars.go
@@ -0,0 +1,8 @@
+package variable
+
+// Default DB system variable values.
+const (
+ DefHostname = "localhost"
+ DefAutoIncrementIncrement = 1
+ DefAutoIncrementOffset = 1
+)
diff --git a/pkg/sessionctx/variable/error.go b/pkg/sessionctx/variable/error.go
new file mode 100644
index 0000000000000000000000000000000000000000..ad820866de5a9f13c5ad740b2c0f2dfc8ae50b23
--- /dev/null
+++ b/pkg/sessionctx/variable/error.go
@@ -0,0 +1,22 @@
+package variable
+
+import (
+ mysql "matrixbase/pkg/errno"
+ "matrixbase/pkg/util/dbterror"
+)
+
+// Error instances.
+var (
+ errWarnDeprecatedSyntax = dbterror.ClassVariable.NewStd(mysql.ErrWarnDeprecatedSyntax)
+ ErrSnapshotTooOld = dbterror.ClassVariable.NewStd(mysql.ErrSnapshotTooOld)
+ ErrUnsupportedValueForVar = dbterror.ClassVariable.NewStd(mysql.ErrUnsupportedValueForVar)
+ ErrUnknownSystemVar = dbterror.ClassVariable.NewStd(mysql.ErrUnknownSystemVariable)
+ ErrIncorrectScope = dbterror.ClassVariable.NewStd(mysql.ErrIncorrectGlobalLocalVar)
+ ErrUnknownTimeZone = dbterror.ClassVariable.NewStd(mysql.ErrUnknownTimeZone)
+ ErrReadOnly = dbterror.ClassVariable.NewStd(mysql.ErrVariableIsReadonly)
+ ErrWrongValueForVar = dbterror.ClassVariable.NewStd(mysql.ErrWrongValueForVar)
+ ErrWrongTypeForVar = dbterror.ClassVariable.NewStd(mysql.ErrWrongTypeForVar)
+ ErrTruncatedWrongValue = dbterror.ClassVariable.NewStd(mysql.ErrTruncatedWrongValue)
+ ErrMaxPreparedStmtCountReached = dbterror.ClassVariable.NewStd(mysql.ErrMaxPreparedStmtCountReached)
+ ErrUnsupportedIsolationLevel = dbterror.ClassVariable.NewStd(mysql.ErrUnsupportedIsolationLevel)
+)
diff --git a/pkg/sessionctx/variable/session.go b/pkg/sessionctx/variable/session.go
new file mode 100644
index 0000000000000000000000000000000000000000..d9967b67b67de094df4dc2f56ccad14ea646d77e
--- /dev/null
+++ b/pkg/sessionctx/variable/session.go
@@ -0,0 +1,218 @@
+package variable
+
+import (
+ "crypto/tls"
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser"
+ "github.com/pingcap/parser/auth"
+ "github.com/pingcap/parser/charset"
+ "github.com/pingcap/parser/mysql"
+ "matrixbase/pkg/sessionctx/stmtctx"
+ "strconv"
+ "time"
+)
+
+type SessionVars struct {
+ systems map[string]string
+
+ // EnableWindowFunction enables the window function.
+ EnableWindowFunction bool
+
+ // EnableStrictDoubleTypeCheck enables table field double type check.
+ EnableStrictDoubleTypeCheck bool
+
+ // StmtCtx holds variables for current executing statement.
+ StmtCtx *stmtctx.StatementContext
+
+ // TxnCtx Should be reset on transaction finished.
+ TxnCtx *TransactionContext
+
+ // Status stands for the session status. e.g. in transaction or not, auto commit is on or off, and so on.
+ Status uint16
+
+ SQLMode mysql.SQLMode
+
+ // StrictSQLMode indicates if the session is in strict mode.
+ StrictSQLMode bool
+
+ // Per-connection time zones. Each client that connects has its own time zone setting, given by the session time_zone variable.
+ // See https://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html
+ TimeZone *time.Location
+
+ // AutoIncrementIncrement and AutoIncrementOffset indicates the autoID's start value and increment.
+ AutoIncrementIncrement int
+
+ AutoIncrementOffset int
+
+ // GlobalVarsAccessor is used to set and get global variables.
+ GlobalVarsAccessor GlobalVarAccessor
+
+ // User is the user identity with which the session login.
+ User *auth.UserIdentity
+
+ // ClientCapability is client's capability.
+ ClientCapability uint32
+
+ // ConnectionID is the connection id of the current session.
+ ConnectionID uint64
+
+ // SelectLimit limits the max counts of select statement's output
+ SelectLimit uint64
+
+ // TLSConnectionState is the TLS connection state (nil if not using TLS).
+ TLSConnectionState *tls.ConnectionState
+
+ // CommandValue indicates which command current session is doing.
+ CommandValue uint32
+
+ // Port is the port of the connected socket
+ Port string
+
+ // Killed is a flag to indicate that this query is killed.
+ Killed uint32
+}
+
+type ConnectionInfo struct {
+ ConnectionID uint64
+ ConnectionType string
+ Host string
+ ClientIP string
+ ClientPort string
+ ServerID int
+ ServerPort int
+ Duration float64
+ User string
+ ServerOSLoginUser string
+ OSVersion string
+ ClientVersion string
+ ServerVersion string
+ SSLVersion string
+ PID int
+ DB string
+}
+
+// NewSessionVars creates a session vars object.
+func NewSessionVars() *SessionVars {
+ vars := &SessionVars{
+ systems: make(map[string]string),
+ TxnCtx: &TransactionContext{},
+ StrictSQLMode: true,
+ Status: mysql.ServerStatusAutocommit,
+ StmtCtx: new(stmtctx.StatementContext),
+ }
+ return vars
+}
+
+// TransactionContext is used to store variables that has transaction scope.
+type TransactionContext struct {
+}
+
+// special session variables.
+const (
+ SQLModeVar = "sql_mode"
+ MaxAllowedPacket = "max_allowed_packet"
+ TimeZone = "time_zone"
+ MaxExecutionTime = "max_execution_time"
+ CharacterSetResults = "character_set_results"
+)
+
+// GetCharsetInfo gets charset and collation for current context.
+// What character set should the server translate a statement to after receiving it?
+// For this, the server uses the character_set_connection and collation_connection system variables.
+// It converts statements sent by the client from character_set_client to character_set_connection
+// (except for string literals that have an introducer such as _latin1 or _utf8).
+// collation_connection is important for comparisons of literal strings.
+// For comparisons of strings with column values, collation_connection does not matter because columns
+// have their own collation, which has a higher collation precedence.
+// See https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html
+func (s *SessionVars) GetCharsetInfo() (charset, collation string) {
+ charset = s.systems[CharacterSetConnection]
+ collation = s.systems[CollationConnection]
+ return
+}
+
+// BuildParserConfig generate parser.ParserConfig for initial parser
+func (s *SessionVars) BuildParserConfig() parser.ParserConfig {
+ return parser.ParserConfig{
+ EnableWindowFunction: s.EnableWindowFunction,
+ EnableStrictDoubleTypeCheck: s.EnableStrictDoubleTypeCheck,
+ }
+}
+
+func (s *SessionVars) SetSystemVar(name string, val string) error {
+ switch name {
+ case SQLModeVar:
+ val = mysql.FormatSQLModeStr(val)
+ // Modes is a list of different modes separated by commas.
+ sqlMode, err2 := mysql.GetSQLMode(val)
+ if err2 != nil {
+ return errors.Trace(err2)
+ }
+ s.StrictSQLMode = sqlMode.HasStrictMode()
+ s.SQLMode = sqlMode
+ s.SetStatusFlag(mysql.ServerStatusNoBackslashEscaped, sqlMode.HasNoBackslashEscapesMode())
+ case AutoCommit:
+ isAutocommit := DBOptOn(val)
+ s.SetStatusFlag(mysql.ServerStatusAutocommit, isAutocommit)
+ if isAutocommit {
+ s.SetInTxn(false)
+ }
+ case AutoIncrementIncrement:
+ // AutoIncrementIncrement is valid in [1, 65535].
+ s.AutoIncrementIncrement = dbOptPositiveInt32(val, DefAutoIncrementIncrement)
+ case AutoIncrementOffset:
+ // AutoIncrementOffset is valid in [1, 65535].
+ s.AutoIncrementOffset = dbOptPositiveInt32(val, DefAutoIncrementOffset)
+ case CharacterSetConnection, CharacterSetClient, CharacterSetResults,
+ CharacterSetServer, CharsetDatabase, CharacterSetFilesystem:
+ if val == "" {
+ if name == CharacterSetResults {
+ s.systems[CharacterSetResults] = ""
+ return nil
+ }
+ return ErrWrongValueForVar.GenWithStackByArgs(name, "NULL")
+ }
+ cht, coll, err := charset.GetCharsetInfo(val)
+ if err != nil {
+ // logutil.BgLogger().Warn(err.Error())
+ cht, coll = charset.GetDefaultCharsetAndCollate()
+ }
+ switch name {
+ case CharacterSetConnection:
+ s.systems[CollationConnection] = coll
+ s.systems[CharacterSetConnection] = cht
+ case CharsetDatabase:
+ s.systems[CollationDatabase] = coll
+ s.systems[CharsetDatabase] = cht
+ case CharacterSetServer:
+ s.systems[CollationServer] = coll
+ s.systems[CharacterSetServer] = cht
+ }
+ val = cht
+ case SQLSelectLimit:
+ result, err := strconv.ParseUint(val, 10, 64)
+ if err != nil {
+ return errors.Trace(err)
+ }
+ s.SelectLimit = result
+ }
+ s.systems[name] = val
+ return nil
+}
+
+// SetStatusFlag sets the session server status variable.
+// If on is ture sets the flag in session status,
+// otherwise removes the flag.
+func (s *SessionVars) SetStatusFlag(flag uint16, on bool) {
+ if on {
+ s.Status |= flag
+ return
+ }
+ s.Status &= ^flag
+}
+
+// SetInTxn sets whether the session is in transaction.
+// It also updates the IsExplicit flag in TxnCtx if val is true.
+func (s *SessionVars) SetInTxn(val bool) {
+ s.SetStatusFlag(mysql.ServerStatusInTrans, val)
+}
diff --git a/pkg/sessionctx/variable/sysvar.go b/pkg/sessionctx/variable/sysvar.go
new file mode 100644
index 0000000000000000000000000000000000000000..2afb5ce7a314248e8a7ea15ca7109a4c4c14d248
--- /dev/null
+++ b/pkg/sessionctx/variable/sysvar.go
@@ -0,0 +1,415 @@
+package variable
+
+import (
+ "fmt"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+)
+
+// ScopeFlag is for system variable whether can be changed in global/session dynamically or not.
+type ScopeFlag uint8
+
+// TypeFlag is the SysVar type, which doesn't exactly match MySQL types.
+type TypeFlag byte
+
+const (
+ // ScopeNone means the system variable can not be changed dynamically.
+ ScopeNone ScopeFlag = 0
+ // ScopeGlobal means the system variable can be changed globally.
+ ScopeGlobal ScopeFlag = 1 << 0
+ // ScopeSession means the system variable can only be changed in current session.
+ ScopeSession ScopeFlag = 1 << 1
+
+ // TypeStr is the default
+ TypeStr TypeFlag = 0
+ // TypeBool for boolean
+ TypeBool TypeFlag = 1
+ // TypeInt for integer
+ TypeInt TypeFlag = 2
+ // TypeEnum for Enum
+ TypeEnum TypeFlag = 3
+ // TypeFloat for Double
+ TypeFloat TypeFlag = 4
+ // TypeUnsigned for Unsigned integer
+ TypeUnsigned TypeFlag = 5
+ // TypeTime for time of day (a TiDB extension)
+ TypeTime TypeFlag = 6
+ // TypeDuration for a golang duration (a TiDB extension)
+ TypeDuration TypeFlag = 7
+
+ // BoolOff is the canonical string representation of a boolean false.
+ BoolOff = "OFF"
+ // BoolOn is the canonical string representation of a boolean true.
+ BoolOn = "ON"
+ // On is the canonical string for ON
+ On = "ON"
+
+ // Off is the canonical string for OFF
+ Off = "OFF"
+
+ // Warn means return warnings
+ Warn = "WARN"
+)
+
+// SysVar is for system variable.
+type SysVar struct {
+ // Scope is for whether can be changed or not
+ Scope ScopeFlag
+ // Name is the variable name.
+ Name string
+ // Value is the variable value.
+ Value string
+ // Type is the MySQL type (optional)
+ Type TypeFlag
+ // MinValue will automatically be validated when specified (optional)
+ MinValue int64
+ // MaxValue will automatically be validated when specified (optional)
+ MaxValue uint64
+ // AutoConvertNegativeBool applies to boolean types (optional)
+ AutoConvertNegativeBool bool
+ // AutoConvertOutOfRange applies to int and unsigned types.
+ AutoConvertOutOfRange bool
+ // ReadOnly applies to all types
+ ReadOnly bool
+ // PossibleValues applies to ENUM type
+ PossibleValues []string
+ // AllowEmpty is a special TiDB behavior which means "read value from config" (do not use)
+ AllowEmpty bool
+ // AllowEmptyAll is a special behavior that only applies to TiDBCapturePlanBaseline, TiDBTxnMode (do not use)
+ AllowEmptyAll bool
+ // AllowAutoValue means that the special value "-1" is permitted, even when outside of range.
+ AllowAutoValue bool
+ // Validation is a callback after the type validation has been performed
+ Validation func(*SessionVars, string, string, ScopeFlag) (string, error)
+ // IsHintUpdatable indicate whether it's updatable via SET_VAR() hint (optional)
+ IsHintUpdatable bool
+}
+
+// ValidateFromType provides automatic validation based on the SysVar's type
+func (sv *SysVar) ValidateFromType(vars *SessionVars, value string, scope ScopeFlag) (string, error) {
+ // Some sysvars are read-only. Attempting to set should always fail.
+ if sv.ReadOnly || sv.Scope == ScopeNone {
+ return value, ErrIncorrectScope.GenWithStackByArgs(sv.Name, "read only")
+ }
+ // The string "DEFAULT" is a special keyword in MySQL, which restores
+ // the compiled sysvar value. In which case we can skip further validation.
+ if strings.EqualFold(value, "DEFAULT") {
+ return sv.Value, nil
+ }
+ // Some sysvars in TiDB have a special behavior where the empty string means
+ // "use the config file value". This needs to be cleaned up once the behavior
+ // for instance variables is determined.
+ if value == "" && ((sv.AllowEmpty && scope == ScopeSession) || sv.AllowEmptyAll) {
+ return value, nil
+ }
+ // Provide validation using the SysVar struct
+ switch sv.Type {
+ case TypeUnsigned:
+ return sv.checkUInt64SystemVar(value, vars)
+ case TypeInt:
+ return sv.checkInt64SystemVar(value, vars)
+ case TypeBool:
+ return sv.checkBoolSystemVar(value, vars)
+ case TypeFloat:
+ return sv.checkFloatSystemVar(value, vars)
+ case TypeEnum:
+ return sv.checkEnumSystemVar(value, vars)
+ case TypeTime:
+ return sv.checkTimeSystemVar(value, vars)
+ case TypeDuration:
+ return sv.checkDurationSystemVar(value, vars)
+ }
+ return value, nil // typeString
+}
+
+const (
+ localDayTimeFormat = "15:04"
+ // FullDayTimeFormat is the full format of analyze start time and end time.
+ FullDayTimeFormat = "15:04 -0700"
+)
+
+func (sv *SysVar) checkTimeSystemVar(value string, vars *SessionVars) (string, error) {
+ var t time.Time
+ var err error
+ if len(value) <= len(localDayTimeFormat) {
+ t, err = time.ParseInLocation(localDayTimeFormat, value, vars.TimeZone)
+ } else {
+ t, err = time.ParseInLocation(FullDayTimeFormat, value, vars.TimeZone)
+ }
+ if err != nil {
+ return "", err
+ }
+ return t.Format(FullDayTimeFormat), nil
+}
+
+func (sv *SysVar) checkDurationSystemVar(value string, vars *SessionVars) (string, error) {
+ d, err := time.ParseDuration(value)
+ if err != nil {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ // Check for min/max violations
+ if int64(d) < sv.MinValue {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ if uint64(d) > sv.MaxValue {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ // return a string representation of the duration
+ return d.String(), nil
+}
+
+func (sv *SysVar) checkUInt64SystemVar(value string, vars *SessionVars) (string, error) {
+ if sv.AllowAutoValue && value == "-1" {
+ return value, nil
+ }
+ // There are two types of validation behaviors for integer values. The default
+ // is to return an error saying the value is out of range. For MySQL compatibility, some
+ // values prefer convert the value to the min/max and return a warning.
+ if !sv.AutoConvertOutOfRange {
+ return sv.checkUint64SystemVarWithError(value)
+ }
+ if len(value) == 0 {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ if value[0] == '-' {
+ _, err := strconv.ParseInt(value, 10, 64)
+ if err != nil {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
+ return fmt.Sprintf("%d", sv.MinValue), nil
+ }
+ val, err := strconv.ParseUint(value, 10, 64)
+ if err != nil {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ if val < uint64(sv.MinValue) {
+ vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
+ return fmt.Sprintf("%d", sv.MinValue), nil
+ }
+ if val > sv.MaxValue {
+ vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
+ return fmt.Sprintf("%d", sv.MaxValue), nil
+ }
+ return value, nil
+}
+
+func (sv *SysVar) checkInt64SystemVar(value string, vars *SessionVars) (string, error) {
+ if sv.AllowAutoValue && value == "-1" {
+ return value, nil
+ }
+ // There are two types of validation behaviors for integer values. The default
+ // is to return an error saying the value is out of range. For MySQL compatibility, some
+ // values prefer convert the value to the min/max and return a warning.
+ if !sv.AutoConvertOutOfRange {
+ return sv.checkInt64SystemVarWithError(value)
+ }
+ val, err := strconv.ParseInt(value, 10, 64)
+ if err != nil {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ if val < sv.MinValue {
+ vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
+ return fmt.Sprintf("%d", sv.MinValue), nil
+ }
+ if val > int64(sv.MaxValue) {
+ vars.StmtCtx.AppendWarning(ErrTruncatedWrongValue.GenWithStackByArgs(sv.Name, value))
+ return fmt.Sprintf("%d", sv.MaxValue), nil
+ }
+ return value, nil
+}
+
+func (sv *SysVar) checkEnumSystemVar(value string, vars *SessionVars) (string, error) {
+ // The value could be either a string or the ordinal position in the PossibleValues.
+ // This allows for the behavior 0 = OFF, 1 = ON, 2 = DEMAND etc.
+ var iStr string
+ for i, v := range sv.PossibleValues {
+ iStr = fmt.Sprintf("%d", i)
+ if strings.EqualFold(value, v) || strings.EqualFold(value, iStr) {
+ return v, nil
+ }
+ }
+ return value, ErrWrongValueForVar.GenWithStackByArgs(sv.Name, value)
+}
+
+func (sv *SysVar) checkFloatSystemVar(value string, vars *SessionVars) (string, error) {
+ if len(value) == 0 {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ val, err := strconv.ParseFloat(value, 64)
+ if err != nil {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ if val < float64(sv.MinValue) || val > float64(sv.MaxValue) {
+ return value, ErrWrongValueForVar.GenWithStackByArgs(sv.Name, value)
+ }
+ return value, nil
+}
+
+func (sv *SysVar) checkBoolSystemVar(value string, vars *SessionVars) (string, error) {
+ if strings.EqualFold(value, "ON") {
+ return BoolOn, nil
+ } else if strings.EqualFold(value, "OFF") {
+ return BoolOff, nil
+ }
+ val, err := strconv.ParseInt(value, 10, 64)
+ if err == nil {
+ // There are two types of conversion rules for integer values.
+ // The default only allows 0 || 1, but a subset of values convert any
+ // negative integer to 1.
+ if !sv.AutoConvertNegativeBool {
+ if val == 0 {
+ return BoolOff, nil
+ } else if val == 1 {
+ return BoolOn, nil
+ }
+ } else {
+ if val == 1 || val < 0 {
+ return BoolOn, nil
+ } else if val == 0 {
+ return BoolOff, nil
+ }
+ }
+ }
+ return value, ErrWrongValueForVar.GenWithStackByArgs(sv.Name, value)
+}
+
+func (sv *SysVar) checkUint64SystemVarWithError(value string) (string, error) {
+ if len(value) == 0 {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ if value[0] == '-' {
+ // // in strict it expects the error WrongValue, but in non-strict it returns WrongType
+ return value, ErrWrongValueForVar.GenWithStackByArgs(sv.Name, value)
+ }
+ val, err := strconv.ParseUint(value, 10, 64)
+ if err != nil {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ if val < uint64(sv.MinValue) || val > sv.MaxValue {
+ return value, ErrWrongValueForVar.GenWithStackByArgs(sv.Name, value)
+ }
+ return value, nil
+}
+
+func (sv *SysVar) checkInt64SystemVarWithError(value string) (string, error) {
+ if len(value) == 0 {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ val, err := strconv.ParseInt(value, 10, 64)
+ if err != nil {
+ return value, ErrWrongTypeForVar.GenWithStackByArgs(sv.Name)
+ }
+ if val < sv.MinValue || val > int64(sv.MaxValue) {
+ return value, ErrWrongValueForVar.GenWithStackByArgs(sv.Name, value)
+ }
+ return value, nil
+}
+
+var sysVars map[string]*SysVar
+var sysVarsLock sync.RWMutex
+
+// RegisterSysVar adds a sysvar to the SysVars list
+func RegisterSysVar(sv *SysVar) {
+ name := strings.ToLower(sv.Name)
+ sysVarsLock.Lock()
+ sysVars[name] = sv
+ sysVarsLock.Unlock()
+}
+
+// UnregisterSysVar removes a sysvar from the SysVars list
+// currently only used in tests.
+func UnregisterSysVar(name string) {
+ name = strings.ToLower(name)
+ sysVarsLock.Lock()
+ delete(sysVars, name)
+ sysVarsLock.Unlock()
+}
+
+// GetSysVar returns sys var info for name as key.
+func GetSysVar(name string) *SysVar {
+ name = strings.ToLower(name)
+ sysVarsLock.RLock()
+ defer sysVarsLock.RUnlock()
+ return sysVars[name]
+}
+
+// SetSysVar sets a sysvar. This will not propagate to the cluster, so it should only be
+// used for instance scoped AUTO variables such as system_time_zone.
+func SetSysVar(name string, value string) {
+ name = strings.ToLower(name)
+ sysVarsLock.Lock()
+ defer sysVarsLock.Unlock()
+ sysVars[name].Value = value
+}
+
+// GetSysVars returns the sysVars list under a RWLock
+func GetSysVars() map[string]*SysVar {
+ sysVarsLock.RLock()
+ defer sysVarsLock.RUnlock()
+ return sysVars
+}
+
+// ValidateFromHook calls the anonymous function on the sysvar if it exists.
+func (sv *SysVar) ValidateFromHook(vars *SessionVars, normalizedValue string, originalValue string, scope ScopeFlag) (string, error) {
+ if sv.Validation != nil {
+ return sv.Validation(vars, normalizedValue, originalValue, scope)
+ }
+ return normalizedValue, nil
+}
+
+// SetNamesVariables is the system variable names related to set names statements.
+var SetNamesVariables = []string{
+ CharacterSetClient,
+ CharacterSetConnection,
+ CharacterSetResults,
+}
+
+// SetCharsetVariables is the system variable names related to set charset statements.
+var SetCharsetVariables = []string{
+ CharacterSetClient,
+ CharacterSetResults,
+}
+
+const (
+ // CharacterSetConnection is the name for character_set_connection system variable.
+ CharacterSetConnection = "character_set_connection"
+ // CollationConnection is the name for collation_connection system variable.
+ CollationConnection = "collation_connection"
+ // CharsetDatabase is the name for character_set_database system variable.
+ CharsetDatabase = "character_set_database"
+ // CollationDatabase is the name for collation_database system variable.
+ CollationDatabase = "collation_database"
+ // CharacterSetFilesystem is the name for character_set_filesystem system variable.
+ CharacterSetFilesystem = "character_set_filesystem"
+ // CharacterSetClient is the name for character_set_client system variable.
+ CharacterSetClient = "character_set_client"
+ // CharacterSetSystem is the name for character_set_system system variable.
+ CharacterSetSystem = "character_set_system"
+ // CharacterSetServer is the name of 'character_set_server' system variable.
+ CharacterSetServer = "character_set_server"
+ // AutoCommit is the name for 'autocommit' system variable.
+ AutoCommit = "autocommit"
+ // AutoIncrementIncrement is the name of 'auto_increment_increment' system variable.
+ AutoIncrementIncrement = "auto_increment_increment"
+ // AutoIncrementOffset is the name of 'auto_increment_offset' system variable.
+ AutoIncrementOffset = "auto_increment_offset"
+ // CollationServer is the name of 'collation_server' variable.
+ CollationServer = "collation_server"
+ // WarningCount is the name for 'warning_count' system variable.
+ WarningCount = "warning_count"
+ // ErrorCount is the name for 'error_count' system variable.
+ ErrorCount = "error_count"
+ // SQLSelectLimit is the name for 'sql_select_limit' system variable.
+ SQLSelectLimit = "sql_select_limit"
+)
+
+// GlobalVarAccessor is the interface for accessing global scope system and status variables.
+type GlobalVarAccessor interface {
+ // GetGlobalSysVar gets the global system variable value for name.
+ GetGlobalSysVar(name string) (string, error)
+ // SetGlobalSysVar sets the global system variable name to value.
+ SetGlobalSysVar(name string, value string) error
+}
diff --git a/pkg/sessionctx/variable/varsutil.go b/pkg/sessionctx/variable/varsutil.go
new file mode 100644
index 0000000000000000000000000000000000000000..0fc5faba7e52effd5dd86dbce28da6cac9bab598
--- /dev/null
+++ b/pkg/sessionctx/variable/varsutil.go
@@ -0,0 +1,167 @@
+// Copyright 2016 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package variable
+
+import (
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+)
+
+// GetSessionSystemVar gets a system variable.
+// If it is a session only variable, use the default value defined in code.
+// Returns error if there is no such variable.
+func GetSessionSystemVar(s *SessionVars, key string) (string, error) {
+ key = strings.ToLower(key)
+ gVal, ok, err := GetSessionOnlySysVars(s, key)
+ if err != nil || ok {
+ return gVal, err
+ }
+ gVal, err = s.GlobalVarsAccessor.GetGlobalSysVar(key)
+ if err != nil {
+ return "", err
+ }
+ s.systems[key] = gVal
+ return gVal, nil
+}
+
+// GetSessionOnlySysVars get the default value defined in code for session only variable.
+// The return bool value indicates whether it's a session only variable.
+func GetSessionOnlySysVars(s *SessionVars, key string) (string, bool, error) {
+ return "", false, ErrUnknownSystemVar.GenWithStackByArgs(key)
+}
+
+// GetGlobalSystemVar gets a global system variable.
+func GetGlobalSystemVar(s *SessionVars, key string) (string, error) {
+ key = strings.ToLower(key)
+ gVal, ok, err := GetScopeNoneSystemVar(key)
+ if err != nil || ok {
+ return gVal, err
+ }
+ gVal, err = s.GlobalVarsAccessor.GetGlobalSysVar(key)
+ if err != nil {
+ return "", err
+ }
+ return gVal, nil
+}
+
+// GetScopeNoneSystemVar checks the validation of `key`,
+// and return the default value if its scope is `ScopeNone`.
+func GetScopeNoneSystemVar(key string) (string, bool, error) {
+ return "", false, ErrUnknownSystemVar.GenWithStackByArgs(key)
+}
+
+// epochShiftBits is used to reserve logical part of the timestamp.
+const epochShiftBits = 18
+
+// ValidateGetSystemVar checks if system variable exists and validates its scope when get system variable.
+func ValidateGetSystemVar(name string, isGlobal bool) error {
+ return ErrUnknownSystemVar.GenWithStackByArgs(name)
+}
+
+const (
+ // initChunkSizeUpperBound indicates upper bound value of tidb_init_chunk_size.
+ initChunkSizeUpperBound = 32
+ // maxChunkSizeLowerBound indicates lower bound value of tidb_max_chunk_size.
+ maxChunkSizeLowerBound = 32
+)
+
+// ValidateSetSystemVar checks if system variable satisfies specific restriction.
+// func ValidateSetSystemVar(vars *SessionVars, name string, value string, scope ScopeFlag) (string, error) {
+// return value, ErrUnknownSystemVar.GenWithStackByArgs(name)
+// }
+
+// TiDBOptOn could be used for all tidb session variable options, we use "ON"/1 to turn on those options.
+func DBOptOn(opt string) bool {
+ return strings.EqualFold(opt, "ON") || opt == "1"
+}
+
+const (
+ // OffInt is used by TiDBMultiStatementMode
+ OffInt = 0
+ // OnInt is used TiDBMultiStatementMode
+ OnInt = 1
+ // WarnInt is used by TiDBMultiStatementMode
+ WarnInt = 2
+)
+
+// TiDBOptMultiStmt converts multi-stmt options to int.
+func TiDBOptMultiStmt(opt string) int {
+ switch opt {
+ case BoolOff:
+ return OffInt
+ case BoolOn:
+ return OnInt
+ }
+ return WarnInt
+}
+
+func dbOptPositiveInt32(opt string, defaultVal int) int {
+ val, err := strconv.Atoi(opt)
+ if err != nil || val <= 0 {
+ return defaultVal
+ }
+ return val
+}
+
+func tidbOptInt64(opt string, defaultVal int64) int64 {
+ val, err := strconv.ParseInt(opt, 10, 64)
+ if err != nil {
+ return defaultVal
+ }
+ return val
+}
+
+func tidbOptFloat64(opt string, defaultVal float64) float64 {
+ val, err := strconv.ParseFloat(opt, 64)
+ if err != nil {
+ return defaultVal
+ }
+ return val
+}
+
+// GoTimeToTS converts a Go time to uint64 timestamp.
+func GoTimeToTS(t time.Time) uint64 {
+ ts := (t.UnixNano() / int64(time.Millisecond)) << epochShiftBits
+ return uint64(ts)
+}
+
+// serverGlobalVariable is used to handle variables that acts in server and global scope.
+type serverGlobalVariable struct {
+ sync.Mutex
+ serverVal string
+ globalVal string
+}
+
+// Set sets the value according to variable scope.
+func (v *serverGlobalVariable) Set(val string, isServer bool) {
+ v.Lock()
+ if isServer {
+ v.serverVal = val
+ } else {
+ v.globalVal = val
+ }
+ v.Unlock()
+}
+
+// GetVal gets the value.
+func (v *serverGlobalVariable) GetVal() string {
+ v.Lock()
+ defer v.Unlock()
+ if v.serverVal != "" {
+ return v.serverVal
+ }
+ return v.globalVal
+}
diff --git a/pkg/types/binary_literal.go b/pkg/types/binary_literal.go
new file mode 100644
index 0000000000000000000000000000000000000000..2610bfc65286d82453c6d00218c4d25aa4170b38
--- /dev/null
+++ b/pkg/types/binary_literal.go
@@ -0,0 +1,237 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "bytes"
+ "encoding/binary"
+ "encoding/hex"
+ "fmt"
+ "math"
+ "strconv"
+ "strings"
+
+ "github.com/pingcap/errors"
+ "matrixbase/pkg/sessionctx/stmtctx"
+)
+
+// BinaryLiteral is the internal type for storing bit / hex literal type.
+type BinaryLiteral []byte
+
+// BitLiteral is the bit literal type.
+type BitLiteral BinaryLiteral
+
+// HexLiteral is the hex literal type.
+type HexLiteral BinaryLiteral
+
+// ZeroBinaryLiteral is a BinaryLiteral literal with zero value.
+var ZeroBinaryLiteral = BinaryLiteral{}
+
+func trimLeadingZeroBytes(bytes []byte) []byte {
+ if len(bytes) == 0 {
+ return bytes
+ }
+ pos, posMax := 0, len(bytes)-1
+ for ; pos < posMax; pos++ {
+ if bytes[pos] != 0 {
+ break
+ }
+ }
+ return bytes[pos:]
+}
+
+// NewBinaryLiteralFromUint creates a new BinaryLiteral instance by the given uint value in BitEndian.
+// byteSize will be used as the length of the new BinaryLiteral, with leading bytes filled to zero.
+// If byteSize is -1, the leading zeros in new BinaryLiteral will be trimmed.
+func NewBinaryLiteralFromUint(value uint64, byteSize int) BinaryLiteral {
+ if byteSize != -1 && (byteSize < 1 || byteSize > 8) {
+ panic("Invalid byteSize")
+ }
+ buf := make([]byte, 8)
+ binary.BigEndian.PutUint64(buf, value)
+ if byteSize == -1 {
+ buf = trimLeadingZeroBytes(buf)
+ } else {
+ buf = buf[8-byteSize:]
+ }
+ return buf
+}
+
+// String implements fmt.Stringer interface.
+func (b BinaryLiteral) String() string {
+ if len(b) == 0 {
+ return ""
+ }
+ return "0x" + hex.EncodeToString(b)
+}
+
+// ToString returns the string representation for the literal.
+func (b BinaryLiteral) ToString() string {
+ return string(b)
+}
+
+// ToBitLiteralString returns the bit literal representation for the literal.
+func (b BinaryLiteral) ToBitLiteralString(trimLeadingZero bool) string {
+ if len(b) == 0 {
+ return "b''"
+ }
+ var buf bytes.Buffer
+ for _, data := range b {
+ fmt.Fprintf(&buf, "%08b", data)
+ }
+ ret := buf.Bytes()
+ if trimLeadingZero {
+ ret = bytes.TrimLeft(ret, "0")
+ if len(ret) == 0 {
+ ret = []byte{'0'}
+ }
+ }
+ return fmt.Sprintf("b'%s'", string(ret))
+}
+
+// ToInt returns the int value for the literal.
+func (b BinaryLiteral) ToInt(sc *stmtctx.StatementContext) (uint64, error) {
+ buf := trimLeadingZeroBytes(b)
+ length := len(buf)
+ if length == 0 {
+ return 0, nil
+ }
+ if length > 8 {
+ var err = ErrTruncatedWrongVal.GenWithStackByArgs("BINARY", b)
+ if sc != nil {
+ err = sc.HandleTruncate(err)
+ }
+ return math.MaxUint64, err
+ }
+ // Note: the byte-order is BigEndian.
+ val := uint64(buf[0])
+ for i := 1; i < length; i++ {
+ val = (val << 8) | uint64(buf[i])
+ }
+ return val, nil
+}
+
+// Compare compares BinaryLiteral to another one
+func (b BinaryLiteral) Compare(b2 BinaryLiteral) int {
+ bufB := trimLeadingZeroBytes(b)
+ bufB2 := trimLeadingZeroBytes(b2)
+ if len(bufB) > len(bufB2) {
+ return 1
+ }
+ if len(bufB) < len(bufB2) {
+ return -1
+ }
+ return bytes.Compare(bufB, bufB2)
+}
+
+// ParseBitStr parses bit string.
+// The string format can be b'val', B'val' or 0bval, val must be 0 or 1.
+// See https://dev.mysql.com/doc/refman/5.7/en/bit-value-literals.html
+func ParseBitStr(s string) (BinaryLiteral, error) {
+ if len(s) == 0 {
+ return nil, errors.Errorf("invalid empty string for parsing bit type")
+ }
+
+ if s[0] == 'b' || s[0] == 'B' {
+ // format is b'val' or B'val'
+ s = strings.Trim(s[1:], "'")
+ } else if strings.HasPrefix(s, "0b") {
+ s = s[2:]
+ } else {
+ // here means format is not b'val', B'val' or 0bval.
+ return nil, errors.Errorf("invalid bit type format %s", s)
+ }
+
+ if len(s) == 0 {
+ return ZeroBinaryLiteral, nil
+ }
+
+ alignedLength := (len(s) + 7) &^ 7
+ s = ("00000000" + s)[len(s)+8-alignedLength:] // Pad with zero (slice from `-alignedLength`)
+ byteLength := len(s) >> 3
+ buf := make([]byte, byteLength)
+
+ for i := 0; i < byteLength; i++ {
+ strPosition := i << 3
+ val, err := strconv.ParseUint(s[strPosition:strPosition+8], 2, 8)
+ if err != nil {
+ return nil, errors.Trace(err)
+ }
+ buf[i] = byte(val)
+ }
+
+ return buf, nil
+}
+
+// NewBitLiteral parses bit string as BitLiteral type.
+func NewBitLiteral(s string) (BitLiteral, error) {
+ b, err := ParseBitStr(s)
+ if err != nil {
+ return BitLiteral{}, err
+ }
+ return BitLiteral(b), nil
+}
+
+// ToString implement ast.BinaryLiteral interface
+func (b BitLiteral) ToString() string {
+ return BinaryLiteral(b).ToString()
+}
+
+// ParseHexStr parses hexadecimal string literal.
+// See https://dev.mysql.com/doc/refman/5.7/en/hexadecimal-literals.html
+func ParseHexStr(s string) (BinaryLiteral, error) {
+ if len(s) == 0 {
+ return nil, errors.Errorf("invalid empty string for parsing hexadecimal literal")
+ }
+
+ if s[0] == 'x' || s[0] == 'X' {
+ // format is x'val' or X'val'
+ s = strings.Trim(s[1:], "'")
+ if len(s)%2 != 0 {
+ return nil, errors.Errorf("invalid hexadecimal format, must even numbers, but %d", len(s))
+ }
+ } else if strings.HasPrefix(s, "0x") {
+ s = s[2:]
+ } else {
+ // here means format is not x'val', X'val' or 0xval.
+ return nil, errors.Errorf("invalid hexadecimal format %s", s)
+ }
+
+ if len(s) == 0 {
+ return ZeroBinaryLiteral, nil
+ }
+
+ if len(s)%2 != 0 {
+ s = "0" + s
+ }
+ buf, err := hex.DecodeString(s)
+ if err != nil {
+ return nil, errors.Trace(err)
+ }
+ return buf, nil
+}
+
+// NewHexLiteral parses hexadecimal string as HexLiteral type.
+func NewHexLiteral(s string) (HexLiteral, error) {
+ h, err := ParseHexStr(s)
+ if err != nil {
+ return HexLiteral{}, err
+ }
+ return HexLiteral(h), nil
+}
+
+// ToString implement ast.BinaryLiteral interface
+func (b HexLiteral) ToString() string {
+ return BinaryLiteral(b).ToString()
+}
diff --git a/pkg/types/compare.go b/pkg/types/compare.go
new file mode 100644
index 0000000000000000000000000000000000000000..0facc47957927ba1cf609bc628c15bb591a88a8e
--- /dev/null
+++ b/pkg/types/compare.go
@@ -0,0 +1,130 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "math"
+ "time"
+
+ "matrixbase/pkg/util/collate"
+)
+
+// CompareInt64 returns an integer comparing the int64 x to y.
+func CompareInt64(x, y int64) int {
+ if x < y {
+ return -1
+ } else if x == y {
+ return 0
+ }
+
+ return 1
+}
+
+// CompareUint64 returns an integer comparing the uint64 x to y.
+func CompareUint64(x, y uint64) int {
+ if x < y {
+ return -1
+ } else if x == y {
+ return 0
+ }
+
+ return 1
+}
+
+// VecCompareUU returns []int64 comparing the []uint64 x to []uint64 y
+func VecCompareUU(x, y []uint64, res []int64) {
+ n := len(x)
+ for i := 0; i < n; i++ {
+ if x[i] < y[i] {
+ res[i] = -1
+ } else if x[i] == y[i] {
+ res[i] = 0
+ } else {
+ res[i] = 1
+ }
+ }
+}
+
+// VecCompareII returns []int64 comparing the []int64 x to []int64 y
+func VecCompareII(x, y, res []int64) {
+ n := len(x)
+ for i := 0; i < n; i++ {
+ if x[i] < y[i] {
+ res[i] = -1
+ } else if x[i] == y[i] {
+ res[i] = 0
+ } else {
+ res[i] = 1
+ }
+ }
+}
+
+// VecCompareUI returns []int64 comparing the []uint64 x to []int64y
+func VecCompareUI(x []uint64, y, res []int64) {
+ n := len(x)
+ for i := 0; i < n; i++ {
+ if y[i] < 0 || x[i] > math.MaxInt64 {
+ res[i] = 1
+ } else if int64(x[i]) < y[i] {
+ res[i] = -1
+ } else if int64(x[i]) == y[i] {
+ res[i] = 0
+ } else {
+ res[i] = 1
+ }
+ }
+}
+
+// VecCompareIU returns []int64 comparing the []int64 x to []uint64y
+func VecCompareIU(x []int64, y []uint64, res []int64) {
+ n := len(x)
+ for i := 0; i < n; i++ {
+ if x[i] < 0 || y[i] > math.MaxInt64 {
+ res[i] = -1
+ } else if x[i] < int64(y[i]) {
+ res[i] = -1
+ } else if x[i] == int64(y[i]) {
+ res[i] = 0
+ } else {
+ res[i] = 1
+ }
+ }
+}
+
+// CompareFloat64 returns an integer comparing the float64 x to y.
+func CompareFloat64(x, y float64) int {
+ if x < y {
+ return -1
+ } else if x == y {
+ return 0
+ }
+
+ return 1
+}
+
+// CompareString returns an integer comparing the string x to y with the specified collation and length.
+func CompareString(x, y, collation string) int {
+ return collate.GetCollator(collation).Compare(x, y)
+}
+
+// CompareDuration returns an integer comparing the duration x to y.
+func CompareDuration(x, y time.Duration) int {
+ if x < y {
+ return -1
+ } else if x == y {
+ return 0
+ }
+
+ return 1
+}
diff --git a/pkg/types/convert.go b/pkg/types/convert.go
new file mode 100644
index 0000000000000000000000000000000000000000..c65c852e07459c9e119e5c64ef4e43f90c9872c3
--- /dev/null
+++ b/pkg/types/convert.go
@@ -0,0 +1,755 @@
+// Copyright 2014 The ql Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSES/QL-LICENSE file.
+
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "math"
+ "strconv"
+ "strings"
+
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser/mysql"
+ "matrixbase/pkg/sessionctx/stmtctx"
+ "matrixbase/pkg/types/json"
+ "matrixbase/pkg/util/hack"
+)
+
+func truncateStr(str string, flen int) string {
+ if flen != UnspecifiedLength && len(str) > flen {
+ str = str[:flen]
+ }
+ return str
+}
+
+// IntergerUnsignedUpperBound indicates the max uint64 values of different mysql types.
+func IntergerUnsignedUpperBound(intType byte) uint64 {
+ switch intType {
+ case mysql.TypeTiny:
+ return math.MaxUint8
+ case mysql.TypeShort:
+ return math.MaxUint16
+ case mysql.TypeInt24:
+ return mysql.MaxUint24
+ case mysql.TypeLong:
+ return math.MaxUint32
+ case mysql.TypeLonglong:
+ return math.MaxUint64
+ case mysql.TypeBit:
+ return math.MaxUint64
+ case mysql.TypeEnum:
+ return math.MaxUint64
+ case mysql.TypeSet:
+ return math.MaxUint64
+ default:
+ panic("Input byte is not a mysql type")
+ }
+}
+
+// IntergerSignedUpperBound indicates the max int64 values of different mysql types.
+func IntergerSignedUpperBound(intType byte) int64 {
+ switch intType {
+ case mysql.TypeTiny:
+ return math.MaxInt8
+ case mysql.TypeShort:
+ return math.MaxInt16
+ case mysql.TypeInt24:
+ return mysql.MaxInt24
+ case mysql.TypeLong:
+ return math.MaxInt32
+ case mysql.TypeLonglong:
+ return math.MaxInt64
+ default:
+ panic("Input byte is not a mysql type")
+ }
+}
+
+// IntergerSignedLowerBound indicates the min int64 values of different mysql types.
+func IntergerSignedLowerBound(intType byte) int64 {
+ switch intType {
+ case mysql.TypeTiny:
+ return math.MinInt8
+ case mysql.TypeShort:
+ return math.MinInt16
+ case mysql.TypeInt24:
+ return mysql.MinInt24
+ case mysql.TypeLong:
+ return math.MinInt32
+ case mysql.TypeLonglong:
+ return math.MinInt64
+ default:
+ panic("Input byte is not a mysql type")
+ }
+}
+
+// ConvertFloatToInt converts a float64 value to a int value.
+// `tp` is used in err msg, if there is overflow, this func will report err according to `tp`
+func ConvertFloatToInt(fval float64, lowerBound, upperBound int64, tp byte) (int64, error) {
+ val := RoundFloat(fval)
+ if val < float64(lowerBound) {
+ return lowerBound, overflow(val, tp)
+ }
+
+ if val >= float64(upperBound) {
+ if val == float64(upperBound) {
+ return upperBound, nil
+ }
+ return upperBound, overflow(val, tp)
+ }
+ return int64(val), nil
+}
+
+// ConvertIntToInt converts an int value to another int value of different precision.
+func ConvertIntToInt(val int64, lowerBound int64, upperBound int64, tp byte) (int64, error) {
+ if val < lowerBound {
+ return lowerBound, overflow(val, tp)
+ }
+
+ if val > upperBound {
+ return upperBound, overflow(val, tp)
+ }
+
+ return val, nil
+}
+
+// ConvertUintToInt converts an uint value to an int value.
+func ConvertUintToInt(val uint64, upperBound int64, tp byte) (int64, error) {
+ if val > uint64(upperBound) {
+ return upperBound, overflow(val, tp)
+ }
+
+ return int64(val), nil
+}
+
+// ConvertIntToUint converts an int value to an uint value.
+func ConvertIntToUint(sc *stmtctx.StatementContext, val int64, upperBound uint64, tp byte) (uint64, error) {
+ if sc.ShouldClipToZero() && val < 0 {
+ return 0, overflow(val, tp)
+ }
+
+ if uint64(val) > upperBound {
+ return upperBound, overflow(val, tp)
+ }
+
+ return uint64(val), nil
+}
+
+// ConvertUintToUint converts an uint value to another uint value of different precision.
+func ConvertUintToUint(val uint64, upperBound uint64, tp byte) (uint64, error) {
+ if val > upperBound {
+ return upperBound, overflow(val, tp)
+ }
+
+ return val, nil
+}
+
+// ConvertFloatToUint converts a float value to an uint value.
+func ConvertFloatToUint(sc *stmtctx.StatementContext, fval float64, upperBound uint64, tp byte) (uint64, error) {
+ val := RoundFloat(fval)
+ if val < 0 {
+ if sc.ShouldClipToZero() {
+ return 0, overflow(val, tp)
+ }
+ return uint64(int64(val)), overflow(val, tp)
+ }
+
+ ubf := float64(upperBound)
+ // Because math.MaxUint64 can not be represented precisely in iee754(64bit),
+ // so `float64(math.MaxUint64)` will make a num bigger than math.MaxUint64,
+ // which can not be represented by 64bit integer.
+ // So `uint64(float64(math.MaxUint64))` is undefined behavior.
+ if val == ubf {
+ return math.MaxUint64, nil
+ }
+ if val > ubf {
+ return math.MaxUint64, overflow(val, tp)
+ }
+ return uint64(val), nil
+}
+
+// convertScientificNotation converts a decimal string with scientific notation to a normal decimal string.
+// 1E6 => 1000000, .12345E+5 => 12345
+func convertScientificNotation(str string) (string, error) {
+ // https://golang.org/ref/spec#Floating-point_literals
+ eIdx := -1
+ point := -1
+ for i := 0; i < len(str); i++ {
+ if str[i] == '.' {
+ point = i
+ }
+ if str[i] == 'e' || str[i] == 'E' {
+ eIdx = i
+ if point == -1 {
+ point = i
+ }
+ break
+ }
+ }
+ if eIdx == -1 {
+ return str, nil
+ }
+ exp, err := strconv.ParseInt(str[eIdx+1:], 10, 64)
+ if err != nil {
+ return "", errors.WithStack(err)
+ }
+
+ f := str[:eIdx]
+ if exp == 0 {
+ return f, nil
+ } else if exp > 0 { // move point right
+ if point+int(exp) == len(f)-1 { // 123.456 >> 3 = 123456. = 123456
+ return f[:point] + f[point+1:], nil
+ } else if point+int(exp) < len(f)-1 { // 123.456 >> 2 = 12345.6
+ return f[:point] + f[point+1:point+1+int(exp)] + "." + f[point+1+int(exp):], nil
+ }
+ // 123.456 >> 5 = 12345600
+ return f[:point] + f[point+1:] + strings.Repeat("0", point+int(exp)-len(f)+1), nil
+ } else { // move point left
+ exp = -exp
+ if int(exp) < point { // 123.456 << 2 = 1.23456
+ return f[:point-int(exp)] + "." + f[point-int(exp):point] + f[point+1:], nil
+ }
+ // 123.456 << 5 = 0.00123456
+ return "0." + strings.Repeat("0", int(exp)-point) + f[:point] + f[point+1:], nil
+ }
+}
+
+func convertDecimalStrToUint(sc *stmtctx.StatementContext, str string, upperBound uint64, tp byte) (uint64, error) {
+ str, err := convertScientificNotation(str)
+ if err != nil {
+ return 0, err
+ }
+
+ var intStr, fracStr string
+ p := strings.Index(str, ".")
+ if p == -1 {
+ intStr = str
+ } else {
+ intStr = str[:p]
+ fracStr = str[p+1:]
+ }
+ intStr = strings.TrimLeft(intStr, "0")
+ if intStr == "" {
+ intStr = "0"
+ }
+ if sc.ShouldClipToZero() && intStr[0] == '-' {
+ return 0, overflow(str, tp)
+ }
+
+ var round uint64
+ if fracStr != "" && fracStr[0] >= '5' {
+ round++
+ }
+
+ upperBound -= round
+ upperStr := strconv.FormatUint(upperBound, 10)
+ if len(intStr) > len(upperStr) ||
+ (len(intStr) == len(upperStr) && intStr > upperStr) {
+ return upperBound, overflow(str, tp)
+ }
+
+ val, err := strconv.ParseUint(intStr, 10, 64)
+ if err != nil {
+ return val, overflow(str, tp)
+ }
+ return val + round, nil
+}
+
+// ConvertDecimalToUint converts a decimal to a uint by converting it to a string first to avoid float overflow (#10181).
+func ConvertDecimalToUint(sc *stmtctx.StatementContext, d *MyDecimal, upperBound uint64, tp byte) (uint64, error) {
+ return convertDecimalStrToUint(sc, string(d.ToString()), upperBound, tp)
+}
+
+// StrToInt converts a string to an integer at the best-effort.
+func StrToInt(sc *stmtctx.StatementContext, str string, isFuncCast bool) (int64, error) {
+ str = strings.TrimSpace(str)
+ validPrefix, err := getValidIntPrefix(sc, str, isFuncCast)
+ iVal, err1 := strconv.ParseInt(validPrefix, 10, 64)
+ if err1 != nil {
+ return iVal, ErrOverflow.GenWithStackByArgs("BIGINT", validPrefix)
+ }
+ return iVal, errors.Trace(err)
+}
+
+// StrToUint converts a string to an unsigned integer at the best-effortt.
+func StrToUint(sc *stmtctx.StatementContext, str string, isFuncCast bool) (uint64, error) {
+ str = strings.TrimSpace(str)
+ validPrefix, err := getValidIntPrefix(sc, str, isFuncCast)
+ if validPrefix[0] == '+' {
+ validPrefix = validPrefix[1:]
+ }
+ uVal, err1 := strconv.ParseUint(validPrefix, 10, 64)
+ if err1 != nil {
+ return uVal, ErrOverflow.GenWithStackByArgs("BIGINT UNSIGNED", validPrefix)
+ }
+ return uVal, errors.Trace(err)
+}
+
+// StrToDateTime converts str to MySQL DateTime.
+func StrToDateTime(sc *stmtctx.StatementContext, str string, fsp int8) (Time, error) {
+ return ParseTime(sc, str, mysql.TypeDatetime, fsp)
+}
+
+// StrToDuration converts str to Duration. It returns Duration in normal case,
+// and returns Time when str is in datetime format.
+// when isDuration is true, the d is returned, when it is false, the t is returned.
+// See https://dev.mysql.com/doc/refman/5.5/en/date-and-time-literals.html.
+func StrToDuration(sc *stmtctx.StatementContext, str string, fsp int8) (d Duration, t Time, isDuration bool, err error) {
+ str = strings.TrimSpace(str)
+ length := len(str)
+ if length > 0 && str[0] == '-' {
+ length--
+ }
+ // Timestamp format is 'YYYYMMDDHHMMSS' or 'YYMMDDHHMMSS', which length is 12.
+ // See #3923, it explains what we do here.
+ if length >= 12 {
+ t, err = StrToDateTime(sc, str, fsp)
+ if err == nil {
+ return d, t, false, nil
+ }
+ }
+
+ d, err = ParseDuration(sc, str, fsp)
+ if ErrTruncatedWrongVal.Equal(err) {
+ err = sc.HandleTruncate(err)
+ }
+ return d, t, true, errors.Trace(err)
+}
+
+// NumberToDuration converts number to Duration.
+func NumberToDuration(number int64, fsp int8) (Duration, error) {
+ if number > TimeMaxValue {
+ // Try to parse DATETIME.
+ if number >= 10000000000 { // '2001-00-00 00-00-00'
+ if t, err := ParseDatetimeFromNum(nil, number); err == nil {
+ dur, err1 := t.ConvertToDuration()
+ return dur, errors.Trace(err1)
+ }
+ }
+ dur := MaxMySQLDuration(fsp)
+ return dur, ErrOverflow.GenWithStackByArgs("Duration", strconv.Itoa(int(number)))
+ } else if number < -TimeMaxValue {
+ dur := MaxMySQLDuration(fsp)
+ dur.Duration = -dur.Duration
+ return dur, ErrOverflow.GenWithStackByArgs("Duration", strconv.Itoa(int(number)))
+ }
+ var neg bool
+ if neg = number < 0; neg {
+ number = -number
+ }
+
+ if number/10000 > TimeMaxHour || number%100 >= 60 || (number/100)%100 >= 60 {
+ return ZeroDuration, errors.Trace(ErrTruncatedWrongVal.GenWithStackByArgs(TimeStr, strconv.FormatInt(number, 10)))
+ }
+ dur := NewDuration(int(number/10000), int((number/100)%100), int(number%100), 0, fsp)
+ if neg {
+ dur.Duration = -dur.Duration
+ }
+ return dur, nil
+}
+
+// getValidIntPrefix gets prefix of the string which can be successfully parsed as int.
+func getValidIntPrefix(sc *stmtctx.StatementContext, str string, isFuncCast bool) (string, error) {
+ if !isFuncCast {
+ floatPrefix, err := getValidFloatPrefix(sc, str, isFuncCast)
+ if err != nil {
+ return floatPrefix, errors.Trace(err)
+ }
+ return floatStrToIntStr(sc, floatPrefix, str)
+ }
+
+ validLen := 0
+
+ for i := 0; i < len(str); i++ {
+ c := str[i]
+ if (c == '+' || c == '-') && i == 0 {
+ continue
+ }
+
+ if c >= '0' && c <= '9' {
+ validLen = i + 1
+ continue
+ }
+
+ break
+ }
+ valid := str[:validLen]
+ if valid == "" {
+ valid = "0"
+ }
+ if validLen == 0 || validLen != len(str) {
+ return valid, errors.Trace(sc.HandleTruncate(ErrTruncatedWrongVal.GenWithStackByArgs("INTEGER", str)))
+ }
+ return valid, nil
+}
+
+// roundIntStr is to round a **valid int string** base on the number following dot.
+func roundIntStr(numNextDot byte, intStr string) string {
+ if numNextDot < '5' {
+ return intStr
+ }
+ retStr := []byte(intStr)
+ idx := len(intStr) - 1
+ for ; idx >= 1; idx-- {
+ if retStr[idx] != '9' {
+ retStr[idx]++
+ break
+ }
+ retStr[idx] = '0'
+ }
+ if idx == 0 {
+ if intStr[0] == '9' {
+ retStr[0] = '1'
+ retStr = append(retStr, '0')
+ } else if isDigit(intStr[0]) {
+ retStr[0]++
+ } else {
+ retStr[1] = '1'
+ retStr = append(retStr, '0')
+ }
+ }
+ return string(retStr)
+}
+
+// floatStrToIntStr converts a valid float string into valid integer string which can be parsed by
+// strconv.ParseInt, we can't parse float first then convert it to string because precision will
+// be lost. For example, the string value "18446744073709551615" which is the max number of unsigned
+// int will cause some precision to lose. intStr[0] may be a positive and negative sign like '+' or '-'.
+//
+// This func will find serious overflow such as the len of intStr > 20 (without prefix `+/-`)
+// however, it will not check whether the intStr overflow BIGINT.
+func floatStrToIntStr(sc *stmtctx.StatementContext, validFloat string, oriStr string) (intStr string, _ error) {
+ var dotIdx = -1
+ var eIdx = -1
+ for i := 0; i < len(validFloat); i++ {
+ switch validFloat[i] {
+ case '.':
+ dotIdx = i
+ case 'e', 'E':
+ eIdx = i
+ }
+ }
+ if eIdx == -1 {
+ if dotIdx == -1 {
+ return validFloat, nil
+ }
+ var digits []byte
+ if validFloat[0] == '-' || validFloat[0] == '+' {
+ dotIdx--
+ digits = []byte(validFloat[1:])
+ } else {
+ digits = []byte(validFloat)
+ }
+ if dotIdx == 0 {
+ intStr = "0"
+ } else {
+ intStr = string(digits)[:dotIdx]
+ }
+ if len(digits) > dotIdx+1 {
+ intStr = roundIntStr(digits[dotIdx+1], intStr)
+ }
+ if (len(intStr) > 1 || intStr[0] != '0') && validFloat[0] == '-' {
+ intStr = "-" + intStr
+ }
+ return intStr, nil
+ }
+ // intCnt and digits contain the prefix `+/-` if validFloat[0] is `+/-`
+ var intCnt int
+ digits := make([]byte, 0, len(validFloat))
+ if dotIdx == -1 {
+ digits = append(digits, validFloat[:eIdx]...)
+ intCnt = len(digits)
+ } else {
+ digits = append(digits, validFloat[:dotIdx]...)
+ intCnt = len(digits)
+ digits = append(digits, validFloat[dotIdx+1:eIdx]...)
+ }
+ exp, err := strconv.Atoi(validFloat[eIdx+1:])
+ if err != nil {
+ return validFloat, errors.Trace(err)
+ }
+ intCnt += exp
+ if exp >= 0 && (intCnt > 21 || intCnt < 0) {
+ // MaxInt64 has 19 decimal digits.
+ // MaxUint64 has 20 decimal digits.
+ // And the intCnt may contain the len of `+/-`,
+ // so I use 21 here as the early detection.
+ sc.AppendWarning(ErrOverflow.GenWithStackByArgs("BIGINT", oriStr))
+ return validFloat[:eIdx], nil
+ }
+ if intCnt <= 0 {
+ intStr = "0"
+ if intCnt == 0 && len(digits) > 0 && isDigit(digits[0]) {
+ intStr = roundIntStr(digits[0], intStr)
+ }
+ return intStr, nil
+ }
+ if intCnt == 1 && (digits[0] == '-' || digits[0] == '+') {
+ intStr = "0"
+ if len(digits) > 1 {
+ intStr = roundIntStr(digits[1], intStr)
+ }
+ if intStr[0] == '1' {
+ intStr = string(digits[:1]) + intStr
+ }
+ return intStr, nil
+ }
+ if intCnt <= len(digits) {
+ intStr = string(digits[:intCnt])
+ if intCnt < len(digits) {
+ intStr = roundIntStr(digits[intCnt], intStr)
+ }
+ } else {
+ // convert scientific notation decimal number
+ extraZeroCount := intCnt - len(digits)
+ intStr = string(digits) + strings.Repeat("0", extraZeroCount)
+ }
+ return intStr, nil
+}
+
+// StrToFloat converts a string to a float64 at the best-effort.
+func StrToFloat(sc *stmtctx.StatementContext, str string, isFuncCast bool) (float64, error) {
+ str = strings.TrimSpace(str)
+ validStr, err := getValidFloatPrefix(sc, str, isFuncCast)
+ f, err1 := strconv.ParseFloat(validStr, 64)
+ if err1 != nil {
+ if err2, ok := err1.(*strconv.NumError); ok {
+ // value will truncate to MAX/MIN if out of range.
+ if err2.Err == strconv.ErrRange {
+ err1 = sc.HandleTruncate(ErrTruncatedWrongVal.GenWithStackByArgs("DOUBLE", str))
+ if math.IsInf(f, 1) {
+ f = math.MaxFloat64
+ } else if math.IsInf(f, -1) {
+ f = -math.MaxFloat64
+ }
+ }
+ }
+ return f, errors.Trace(err1)
+ }
+ return f, errors.Trace(err)
+}
+
+// ConvertJSONToInt64 casts JSON into int64.
+func ConvertJSONToInt64(sc *stmtctx.StatementContext, j json.BinaryJSON, unsigned bool) (int64, error) {
+ return ConvertJSONToInt(sc, j, unsigned, mysql.TypeLonglong)
+}
+
+// ConvertJSONToInt casts JSON into int by type.
+func ConvertJSONToInt(sc *stmtctx.StatementContext, j json.BinaryJSON, unsigned bool, tp byte) (int64, error) {
+ switch j.TypeCode {
+ case json.TypeCodeObject, json.TypeCodeArray:
+ return 0, sc.HandleTruncate(ErrTruncatedWrongVal.GenWithStackByArgs("INTEGER", j.String()))
+ case json.TypeCodeLiteral:
+ switch j.Value[0] {
+ case json.LiteralNil, json.LiteralFalse:
+ return 0, nil
+ default:
+ return 1, nil
+ }
+ case json.TypeCodeInt64:
+ i := j.GetInt64()
+ if unsigned {
+ uBound := IntergerUnsignedUpperBound(tp)
+ u, err := ConvertIntToUint(sc, i, uBound, tp)
+ return int64(u), sc.HandleOverflow(err, err)
+ }
+
+ lBound := IntergerSignedLowerBound(tp)
+ uBound := IntergerSignedUpperBound(tp)
+ i, err := ConvertIntToInt(i, lBound, uBound, tp)
+ return i, sc.HandleOverflow(err, err)
+ case json.TypeCodeUint64:
+ u := j.GetUint64()
+ if unsigned {
+ uBound := IntergerUnsignedUpperBound(tp)
+ u, err := ConvertUintToUint(u, uBound, tp)
+ return int64(u), sc.HandleOverflow(err, err)
+ }
+
+ uBound := IntergerSignedUpperBound(tp)
+ i, err := ConvertUintToInt(u, uBound, tp)
+ return i, sc.HandleOverflow(err, err)
+ case json.TypeCodeFloat64:
+ f := j.GetFloat64()
+ if !unsigned {
+ lBound := IntergerSignedLowerBound(tp)
+ uBound := IntergerSignedUpperBound(tp)
+ u, e := ConvertFloatToInt(f, lBound, uBound, tp)
+ return u, sc.HandleOverflow(e, e)
+ }
+ bound := IntergerUnsignedUpperBound(tp)
+ u, err := ConvertFloatToUint(sc, f, bound, tp)
+ return int64(u), sc.HandleOverflow(err, err)
+ case json.TypeCodeString:
+ str := string(hack.String(j.GetString()))
+ if !unsigned {
+ r, e := StrToInt(sc, str, false)
+ return r, sc.HandleOverflow(e, e)
+ }
+ u, err := StrToUint(sc, str, false)
+ return int64(u), sc.HandleOverflow(err, err)
+ }
+ return 0, errors.New("Unknown type code in JSON")
+}
+
+// ConvertJSONToFloat casts JSON into float64.
+func ConvertJSONToFloat(sc *stmtctx.StatementContext, j json.BinaryJSON) (float64, error) {
+ switch j.TypeCode {
+ case json.TypeCodeObject, json.TypeCodeArray:
+ return 0, sc.HandleTruncate(ErrTruncatedWrongVal.GenWithStackByArgs("FLOAT", j.String()))
+ case json.TypeCodeLiteral:
+ switch j.Value[0] {
+ case json.LiteralNil, json.LiteralFalse:
+ return 0, nil
+ default:
+ return 1, nil
+ }
+ case json.TypeCodeInt64:
+ return float64(j.GetInt64()), nil
+ case json.TypeCodeUint64:
+ return float64(j.GetUint64()), nil
+ case json.TypeCodeFloat64:
+ return j.GetFloat64(), nil
+ case json.TypeCodeString:
+ str := string(hack.String(j.GetString()))
+ return StrToFloat(sc, str, false)
+ }
+ return 0, errors.New("Unknown type code in JSON")
+}
+
+// ConvertJSONToDecimal casts JSON into decimal.
+func ConvertJSONToDecimal(sc *stmtctx.StatementContext, j json.BinaryJSON) (*MyDecimal, error) {
+ var err error = nil
+ res := new(MyDecimal)
+ switch j.TypeCode {
+ case json.TypeCodeObject, json.TypeCodeArray:
+ err = ErrTruncatedWrongVal.GenWithStackByArgs("DECIMAL", j.String())
+ case json.TypeCodeLiteral:
+ switch j.Value[0] {
+ case json.LiteralNil, json.LiteralFalse:
+ res = res.FromInt(0)
+ default:
+ res = res.FromInt(1)
+ }
+ case json.TypeCodeInt64:
+ res = res.FromInt(j.GetInt64())
+ case json.TypeCodeUint64:
+ res = res.FromUint(j.GetUint64())
+ case json.TypeCodeFloat64:
+ err = res.FromFloat64(j.GetFloat64())
+ case json.TypeCodeString:
+ err = res.FromString(j.GetString())
+ }
+ err = sc.HandleTruncate(err)
+ if err != nil {
+ return res, errors.Trace(err)
+ }
+ return res, errors.Trace(err)
+}
+
+// getValidFloatPrefix gets prefix of string which can be successfully parsed as float.
+func getValidFloatPrefix(sc *stmtctx.StatementContext, s string, isFuncCast bool) (valid string, err error) {
+ if isFuncCast && s == "" {
+ return "0", nil
+ }
+
+ var (
+ sawDot bool
+ sawDigit bool
+ validLen int
+ eIdx = -1
+ )
+ for i := 0; i < len(s); i++ {
+ c := s[i]
+ if c == '+' || c == '-' {
+ if i != 0 && i != eIdx+1 { // "1e+1" is valid.
+ break
+ }
+ } else if c == '.' {
+ if sawDot || eIdx > 0 { // "1.1." or "1e1.1"
+ break
+ }
+ sawDot = true
+ if sawDigit { // "123." is valid.
+ validLen = i + 1
+ }
+ } else if c == 'e' || c == 'E' {
+ if !sawDigit { // "+.e"
+ break
+ }
+ if eIdx != -1 { // "1e5e"
+ break
+ }
+ eIdx = i
+ } else if c == '\u0000' {
+ s = s[:validLen]
+ break
+ } else if c < '0' || c > '9' {
+ break
+ } else {
+ sawDigit = true
+ validLen = i + 1
+ }
+ }
+ valid = s[:validLen]
+ if valid == "" {
+ valid = "0"
+ }
+ if validLen == 0 || validLen != len(s) {
+ err = errors.Trace(sc.HandleTruncate(ErrTruncatedWrongVal.GenWithStackByArgs("FLOAT", s)))
+ }
+ return valid, err
+}
+
+// ToString converts an interface to a string.
+func ToString(value interface{}) (string, error) {
+ switch v := value.(type) {
+ case bool:
+ if v {
+ return "1", nil
+ }
+ return "0", nil
+ case int:
+ return strconv.FormatInt(int64(v), 10), nil
+ case int64:
+ return strconv.FormatInt(v, 10), nil
+ case uint64:
+ return strconv.FormatUint(v, 10), nil
+ case float32:
+ return strconv.FormatFloat(float64(v), 'f', -1, 32), nil
+ case float64:
+ return strconv.FormatFloat(v, 'f', -1, 64), nil
+ case string:
+ return v, nil
+ case []byte:
+ return string(v), nil
+ case Time:
+ return v.String(), nil
+ case Duration:
+ return v.String(), nil
+ case *MyDecimal:
+ return v.String(), nil
+ case BinaryLiteral:
+ return v.ToString(), nil
+ case Enum:
+ return v.String(), nil
+ case Set:
+ return v.String(), nil
+ default:
+ return "", errors.Errorf("cannot convert %v(type %T) to string", value, value)
+ }
+}
diff --git a/pkg/types/core_time.go b/pkg/types/core_time.go
new file mode 100644
index 0000000000000000000000000000000000000000..f8cf9a0b0db9db97dae051e9c1f7744366fdcd36
--- /dev/null
+++ b/pkg/types/core_time.go
@@ -0,0 +1,598 @@
+// Copyright 2016 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "fmt"
+ gotime "time"
+
+ "github.com/pingcap/errors"
+)
+
+// CoreTime is the internal struct type for Time.
+type CoreTime uint64
+
+// ZeroCoreTime is the zero value for TimeInternal type.
+var ZeroCoreTime = CoreTime(0)
+
+// String implements fmt.Stringer.
+func (t CoreTime) String() string {
+ return fmt.Sprintf("{%d %d %d %d %d %d %d}", t.getYear(), t.getMonth(), t.getDay(), t.getHour(), t.getMinute(), t.getSecond(), t.getMicrosecond())
+}
+
+func (t CoreTime) getYear() uint16 {
+ return uint16((uint64(t) & yearBitFieldMask) >> yearBitFieldOffset)
+}
+
+func (t *CoreTime) setYear(year uint16) {
+ *(*uint64)(t) &= ^yearBitFieldMask
+ *(*uint64)(t) |= (uint64(year) << yearBitFieldOffset) & yearBitFieldMask
+}
+
+// Year returns the year value.
+func (t CoreTime) Year() int {
+ return int(t.getYear())
+}
+
+func (t CoreTime) getMonth() uint8 {
+ return uint8((uint64(t) & monthBitFieldMask) >> monthBitFieldOffset)
+}
+
+func (t *CoreTime) setMonth(month uint8) {
+ *(*uint64)(t) &= ^monthBitFieldMask
+ *(*uint64)(t) |= (uint64(month) << monthBitFieldOffset) & monthBitFieldMask
+}
+
+// Month returns the month value.
+func (t CoreTime) Month() int {
+ return int(t.getMonth())
+}
+
+func (t CoreTime) getDay() uint8 {
+ return uint8((uint64(t) & dayBitFieldMask) >> dayBitFieldOffset)
+}
+
+func (t *CoreTime) setDay(day uint8) {
+ *(*uint64)(t) &= ^dayBitFieldMask
+ *(*uint64)(t) |= (uint64(day) << dayBitFieldOffset) & dayBitFieldMask
+}
+
+// Day returns the day value.
+func (t CoreTime) Day() int {
+ return int(t.getDay())
+}
+
+func (t CoreTime) getHour() uint8 {
+ return uint8((uint64(t) & hourBitFieldMask) >> hourBitFieldOffset)
+}
+
+func (t *CoreTime) setHour(hour uint8) {
+ *(*uint64)(t) &= ^hourBitFieldMask
+ *(*uint64)(t) |= (uint64(hour) << hourBitFieldOffset) & hourBitFieldMask
+}
+
+// Hour returns the hour value.
+func (t CoreTime) Hour() int {
+ return int(t.getHour())
+}
+
+func (t CoreTime) getMinute() uint8 {
+ return uint8((uint64(t) & minuteBitFieldMask) >> minuteBitFieldOffset)
+}
+
+func (t *CoreTime) setMinute(minute uint8) {
+ *(*uint64)(t) &= ^minuteBitFieldMask
+ *(*uint64)(t) |= (uint64(minute) << minuteBitFieldOffset) & minuteBitFieldMask
+}
+
+// Minute returns the minute value.
+func (t CoreTime) Minute() int {
+ return int(t.getMinute())
+}
+
+func (t CoreTime) getSecond() uint8 {
+ return uint8((uint64(t) & secondBitFieldMask) >> secondBitFieldOffset)
+}
+
+func (t *CoreTime) setSecond(second uint8) {
+ *(*uint64)(t) &= ^secondBitFieldMask
+ *(*uint64)(t) |= (uint64(second) << secondBitFieldOffset) & secondBitFieldMask
+}
+
+// Second returns the second value.
+func (t CoreTime) Second() int {
+ return int(t.getSecond())
+}
+
+func (t CoreTime) getMicrosecond() uint32 {
+ return uint32((uint64(t) & microsecondBitFieldMask) >> microsecondBitFieldOffset)
+}
+
+func (t *CoreTime) setMicrosecond(microsecond uint32) {
+ *(*uint64)(t) &= ^microsecondBitFieldMask
+ *(*uint64)(t) |= (uint64(microsecond) << microsecondBitFieldOffset) & microsecondBitFieldMask
+}
+
+// Microsecond returns the microsecond value.
+func (t CoreTime) Microsecond() int {
+ return int(t.getMicrosecond())
+}
+
+// Weekday returns weekday value.
+func (t CoreTime) Weekday() gotime.Weekday {
+ // TODO: Consider time_zone variable.
+ t1, err := t.GoTime(gotime.Local)
+ // allow invalid dates
+ if err != nil {
+ return t1.Weekday()
+ }
+ return t1.Weekday()
+}
+
+// YearWeek returns year and week.
+func (t CoreTime) YearWeek(mode int) (int, int) {
+ behavior := weekMode(mode) | weekBehaviourYear
+ return calcWeek(t, behavior)
+}
+
+// Week returns week value.
+func (t CoreTime) Week(mode int) int {
+ if t.getMonth() == 0 || t.getDay() == 0 {
+ return 0
+ }
+ _, week := calcWeek(t, weekMode(mode))
+ return week
+}
+
+// YearDay returns year and day.
+func (t CoreTime) YearDay() int {
+ if t.getMonth() == 0 || t.getDay() == 0 {
+ return 0
+ }
+ year, month, day := t.Year(), t.Month(), t.Day()
+ return calcDaynr(year, month, day) -
+ calcDaynr(year, 1, 1) + 1
+}
+
+// GoTime converts Time to GoTime.
+func (t CoreTime) GoTime(loc *gotime.Location) (gotime.Time, error) {
+ // gotime.Time can't represent month 0 or day 0, date contains 0 would be converted to a nearest date,
+ // For example, 2006-12-00 00:00:00 would become 2015-11-30 23:59:59.
+ year, month, day, hour, minute, second, microsecond := t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Microsecond()
+ tm := gotime.Date(year, gotime.Month(month), day, hour, minute, second, microsecond*1000, loc)
+ year2, month2, day2 := tm.Date()
+ hour2, minute2, second2 := tm.Clock()
+ microsec2 := tm.Nanosecond() / 1000
+ // This function will check the result, and return an error if it's not the same with the origin input .
+ if year2 != year || int(month2) != month || day2 != day ||
+ hour2 != hour || minute2 != minute || second2 != second ||
+ microsec2 != microsecond {
+ return tm, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, t))
+ }
+ return tm, nil
+}
+
+// IsLeapYear returns if it's leap year.
+func (t CoreTime) IsLeapYear() bool {
+ return isLeapYear(t.getYear())
+}
+
+func isLeapYear(year uint16) bool {
+ return (year%4 == 0 && year%100 != 0) || year%400 == 0
+}
+
+var daysByMonth = [12]int{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
+
+// GetLastDay returns the last day of the month
+func GetLastDay(year, month int) int {
+ var day = 0
+ if month > 0 && month <= 12 {
+ day = daysByMonth[month-1]
+ }
+ if month == 2 && isLeapYear(uint16(year)) {
+ day = 29
+ }
+ return day
+}
+
+func getFixDays(year, month, day int, ot gotime.Time) int {
+ if (year != 0 || month != 0) && day == 0 {
+ od := ot.Day()
+ t := ot.AddDate(year, month, day)
+ td := t.Day()
+ if od != td {
+ tm := int(t.Month()) - 1
+ tMax := GetLastDay(t.Year(), tm)
+ dd := tMax - od
+ return dd
+ }
+ }
+ return 0
+}
+
+// compareTime compare two Time.
+// return:
+// 0: if a == b
+// 1: if a > b
+// -1: if a < b
+func compareTime(a, b CoreTime) int {
+ ta := datetimeToUint64(a)
+ tb := datetimeToUint64(b)
+
+ switch {
+ case ta < tb:
+ return -1
+ case ta > tb:
+ return 1
+ }
+
+ switch {
+ case a.Microsecond() < b.Microsecond():
+ return -1
+ case a.Microsecond() > b.Microsecond():
+ return 1
+ }
+
+ return 0
+}
+
+// AddDate fix gap between mysql and golang api
+// When we execute select date_add('2018-01-31',interval 1 month) in mysql we got 2018-02-28
+// but in tidb we got 2018-03-03.
+// Dig it and we found it's caused by golang api time.Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time ,
+// it says October 32 converts to November 1 ,it conflicts with mysql.
+// See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_date-add
+func AddDate(year, month, day int64, ot gotime.Time) (nt gotime.Time) {
+ df := getFixDays(int(year), int(month), int(day), ot)
+ if df != 0 {
+ nt = ot.AddDate(int(year), int(month), df)
+ } else {
+ nt = ot.AddDate(int(year), int(month), int(day))
+ }
+ return nt
+}
+
+func calcTimeFromSec(to *CoreTime, seconds, microseconds int) {
+ to.setHour(uint8(seconds / 3600))
+ seconds = seconds % 3600
+ to.setMinute(uint8(seconds / 60))
+ to.setSecond(uint8(seconds % 60))
+ to.setMicrosecond(uint32(microseconds))
+}
+
+const secondsIn24Hour = 86400
+
+func calcTimeDiffInternal(t1 CoreTime, year, month, day, hour, minute, second, microsecond, sign int) (seconds, microseconds int, neg bool) {
+ days := calcDaynr(t1.Year(), t1.Month(), t1.Day())
+ days2 := calcDaynr(year, month, day)
+ days -= sign * days2
+
+ tmp := (int64(days)*secondsIn24Hour+
+ int64(t1.Hour())*3600+int64(t1.Minute())*60+
+ int64(t1.Second())-
+ int64(sign)*(int64(hour)*3600+int64(minute)*60+
+ int64(second)))*
+ 1e6 +
+ int64(t1.Microsecond()) - int64(sign)*int64(microsecond)
+
+ if tmp < 0 {
+ tmp = -tmp
+ neg = true
+ }
+ seconds = int(tmp / 1e6)
+ microseconds = int(tmp % 1e6)
+ return
+}
+
+// calcTimeDiff calculates difference between two datetime values as seconds + microseconds.
+// sign can be +1 or -1, and t2 is preprocessed with sign first.
+func calcTimeTimeDiff(t1, t2 CoreTime, sign int) (seconds, microseconds int, neg bool) {
+ return calcTimeDiffInternal(t1, t2.Year(), t2.Month(), t2.Day(), t2.Hour(), t2.Minute(), t2.Second(), t2.Microsecond(), sign)
+}
+
+// calcTimeDiff calculates difference between a datetime value and a duration as seconds + microseconds.
+func calcTimeDurationDiff(t CoreTime, d Duration) (seconds, microseconds int, neg bool) {
+ sign, hh, mm, ss, micro := splitDuration(d.Duration)
+ return calcTimeDiffInternal(t, 0, 0, 0, hh, mm, ss, micro, -sign)
+}
+
+// datetimeToUint64 converts time value to integer in YYYYMMDDHHMMSS format.
+func datetimeToUint64(t CoreTime) uint64 {
+ return uint64(t.Year())*1e10 +
+ uint64(t.Month())*1e8 +
+ uint64(t.Day())*1e6 +
+ uint64(t.Hour())*1e4 +
+ uint64(t.Minute())*1e2 +
+ uint64(t.Second())
+}
+
+// calcDaynr calculates days since 0000-00-00.
+func calcDaynr(year, month, day int) int {
+ if year == 0 && month == 0 {
+ return 0
+ }
+
+ delsum := 365*year + 31*(month-1) + day
+ if month <= 2 {
+ year--
+ } else {
+ delsum -= (month*4 + 23) / 10
+ }
+ temp := ((year/100 + 1) * 3) / 4
+ return delsum + year/4 - temp
+}
+
+// DateDiff calculates number of days between two days.
+func DateDiff(startTime, endTime CoreTime) int {
+ return calcDaynr(startTime.Year(), startTime.Month(), startTime.Day()) - calcDaynr(endTime.Year(), endTime.Month(), endTime.Day())
+}
+
+// calcDaysInYear calculates days in one year, it works with 0 <= year <= 99.
+func calcDaysInYear(year int) int {
+ if (year&3) == 0 && (year%100 != 0 || (year%400 == 0 && (year != 0))) {
+ return 366
+ }
+ return 365
+}
+
+// calcWeekday calculates weekday from daynr, returns 0 for Monday, 1 for Tuesday ...
+func calcWeekday(daynr int, sundayFirstDayOfWeek bool) int {
+ daynr += 5
+ if sundayFirstDayOfWeek {
+ daynr++
+ }
+ return daynr % 7
+}
+
+type weekBehaviour uint
+
+const (
+ // weekBehaviourMondayFirst set Monday as first day of week; otherwise Sunday is first day of week
+ weekBehaviourMondayFirst weekBehaviour = 1 << iota
+ // If set, Week is in range 1-53, otherwise Week is in range 0-53.
+ // Note that this flag is only relevant if WEEK_JANUARY is not set.
+ weekBehaviourYear
+ // If not set, Weeks are numbered according to ISO 8601:1988.
+ // If set, the week that contains the first 'first-day-of-week' is week 1.
+ weekBehaviourFirstWeekday
+)
+
+func (v weekBehaviour) test(flag weekBehaviour) bool {
+ return (v & flag) != 0
+}
+
+func weekMode(mode int) weekBehaviour {
+ weekFormat := weekBehaviour(mode & 7)
+ if (weekFormat & weekBehaviourMondayFirst) == 0 {
+ weekFormat ^= weekBehaviourFirstWeekday
+ }
+ return weekFormat
+}
+
+// calcWeek calculates week and year for the time.
+func calcWeek(t CoreTime, wb weekBehaviour) (year int, week int) {
+ var days int
+ ty, tm, td := int(t.getYear()), int(t.getMonth()), int(t.getDay())
+ daynr := calcDaynr(ty, tm, td)
+ firstDaynr := calcDaynr(ty, 1, 1)
+ mondayFirst := wb.test(weekBehaviourMondayFirst)
+ weekYear := wb.test(weekBehaviourYear)
+ firstWeekday := wb.test(weekBehaviourFirstWeekday)
+
+ weekday := calcWeekday(firstDaynr, !mondayFirst)
+
+ year = ty
+
+ if tm == 1 && td <= 7-weekday {
+ if !weekYear &&
+ ((firstWeekday && weekday != 0) || (!firstWeekday && weekday >= 4)) {
+ week = 0
+ return
+ }
+ weekYear = true
+ year--
+ days = calcDaysInYear(year)
+ firstDaynr -= days
+ weekday = (weekday + 53*7 - days) % 7
+ }
+
+ if (firstWeekday && weekday != 0) ||
+ (!firstWeekday && weekday >= 4) {
+ days = daynr - (firstDaynr + 7 - weekday)
+ } else {
+ days = daynr - (firstDaynr - weekday)
+ }
+
+ if weekYear && days >= 52*7 {
+ weekday = (weekday + calcDaysInYear(year)) % 7
+ if (!firstWeekday && weekday < 4) ||
+ (firstWeekday && weekday == 0) {
+ year++
+ week = 1
+ return
+ }
+ }
+ week = days/7 + 1
+ return
+}
+
+// mixDateAndDuration mixes a date value and a duration value.
+func mixDateAndDuration(date *CoreTime, dur Duration) {
+ if dur.Duration >= 0 && dur.Hour() < 24 {
+ _, hh, mm, ss, frac := splitDuration(dur.Duration)
+ date.setHour(uint8(hh))
+ date.setMinute(uint8(mm))
+ date.setSecond(uint8(ss))
+ date.setMicrosecond(uint32(frac))
+ return
+ }
+
+ // Time is negative or outside of 24 hours internal.
+ seconds, microseconds, _ := calcTimeDurationDiff(*date, dur)
+
+ // If we want to use this function with arbitrary dates, this code will need
+ // to cover cases when time is negative and "date < -time".
+
+ days := seconds / secondsIn24Hour
+ calcTimeFromSec(date, seconds%secondsIn24Hour, microseconds)
+ year, month, day := getDateFromDaynr(uint(days))
+ date.setYear(uint16(year))
+ date.setMonth(uint8(month))
+ date.setDay(uint8(day))
+}
+
+var daysInMonth = []int{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
+
+// getDateFromDaynr changes a daynr to year, month and day,
+// daynr 0 is returned as date 00.00.00
+func getDateFromDaynr(daynr uint) (year uint, month uint, day uint) {
+ if daynr <= 365 || daynr >= 3652500 {
+ return
+ }
+
+ year = daynr * 100 / 36525
+ temp := (((year-1)/100 + 1) * 3) / 4
+ dayOfYear := daynr - year*365 - (year-1)/4 + temp
+
+ daysInYear := calcDaysInYear(int(year))
+ for dayOfYear > uint(daysInYear) {
+ dayOfYear -= uint(daysInYear)
+ year++
+ daysInYear = calcDaysInYear(int(year))
+ }
+
+ leapDay := uint(0)
+ if daysInYear == 366 {
+ if dayOfYear > 31+28 {
+ dayOfYear--
+ if dayOfYear == 31+28 {
+ // Handle leapyears leapday.
+ leapDay = 1
+ }
+ }
+ }
+
+ month = 1
+ for _, days := range daysInMonth {
+ if dayOfYear <= uint(days) {
+ break
+ }
+ dayOfYear -= uint(days)
+ month++
+ }
+
+ day = dayOfYear + leapDay
+ return
+}
+
+const (
+ intervalYEAR = "YEAR"
+ intervalQUARTER = "QUARTER"
+ intervalMONTH = "MONTH"
+ intervalWEEK = "WEEK"
+ intervalDAY = "DAY"
+ intervalHOUR = "HOUR"
+ intervalMINUTE = "MINUTE"
+ intervalSECOND = "SECOND"
+ intervalMICROSECOND = "MICROSECOND"
+)
+
+func timestampDiff(intervalType string, t1, t2 CoreTime) int64 {
+ seconds, microseconds, neg := calcTimeTimeDiff(t2, t1, 1)
+ months := uint(0)
+ if intervalType == intervalYEAR || intervalType == intervalQUARTER ||
+ intervalType == intervalMONTH {
+ var (
+ yearBeg, yearEnd, monthBeg, monthEnd, dayBeg, dayEnd uint
+ secondBeg, secondEnd, microsecondBeg, microsecondEnd uint
+ )
+
+ if neg {
+ yearBeg = uint(t2.Year())
+ yearEnd = uint(t1.Year())
+ monthBeg = uint(t2.Month())
+ monthEnd = uint(t1.Month())
+ dayBeg = uint(t2.Day())
+ dayEnd = uint(t1.Day())
+ secondBeg = uint(t2.Hour()*3600 + t2.Minute()*60 + t2.Second())
+ secondEnd = uint(t1.Hour()*3600 + t1.Minute()*60 + t1.Second())
+ microsecondBeg = uint(t2.Microsecond())
+ microsecondEnd = uint(t1.Microsecond())
+ } else {
+ yearBeg = uint(t1.Year())
+ yearEnd = uint(t2.Year())
+ monthBeg = uint(t1.Month())
+ monthEnd = uint(t2.Month())
+ dayBeg = uint(t1.Day())
+ dayEnd = uint(t2.Day())
+ secondBeg = uint(t1.Hour()*3600 + t1.Minute()*60 + t1.Second())
+ secondEnd = uint(t2.Hour()*3600 + t2.Minute()*60 + t2.Second())
+ microsecondBeg = uint(t1.Microsecond())
+ microsecondEnd = uint(t2.Microsecond())
+ }
+
+ // calc years
+ years := yearEnd - yearBeg
+ if monthEnd < monthBeg ||
+ (monthEnd == monthBeg && dayEnd < dayBeg) {
+ years--
+ }
+
+ // calc months
+ months = 12 * years
+ if monthEnd < monthBeg ||
+ (monthEnd == monthBeg && dayEnd < dayBeg) {
+ months += 12 - (monthBeg - monthEnd)
+ } else {
+ months += monthEnd - monthBeg
+ }
+
+ if dayEnd < dayBeg {
+ months--
+ } else if (dayEnd == dayBeg) &&
+ ((secondEnd < secondBeg) ||
+ (secondEnd == secondBeg && microsecondEnd < microsecondBeg)) {
+ months--
+ }
+ }
+
+ negV := int64(1)
+ if neg {
+ negV = -1
+ }
+ switch intervalType {
+ case intervalYEAR:
+ return int64(months) / 12 * negV
+ case intervalQUARTER:
+ return int64(months) / 3 * negV
+ case intervalMONTH:
+ return int64(months) * negV
+ case intervalWEEK:
+ return int64(seconds) / secondsIn24Hour / 7 * negV
+ case intervalDAY:
+ return int64(seconds) / secondsIn24Hour * negV
+ case intervalHOUR:
+ return int64(seconds) / 3600 * negV
+ case intervalMINUTE:
+ return int64(seconds) / 60 * negV
+ case intervalSECOND:
+ return int64(seconds) * negV
+ case intervalMICROSECOND:
+ // In MySQL difference between any two valid datetime values
+ // in microseconds fits into longlong.
+ return int64(seconds*1000000+microseconds) * negV
+ }
+
+ return 0
+}
diff --git a/pkg/types/datum.go b/pkg/types/datum.go
new file mode 100644
index 0000000000000000000000000000000000000000..97c79aebd4d9f76ef0d2ed80245240e7049141c9
--- /dev/null
+++ b/pkg/types/datum.go
@@ -0,0 +1,2306 @@
+// Copyright 2016 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "fmt"
+ "math"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+ "unicode/utf8"
+ "unsafe"
+
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser/charset"
+ "github.com/pingcap/parser/mysql"
+ "github.com/pingcap/parser/terror"
+ "github.com/pingcap/parser/types"
+ "matrixbase/pkg/sessionctx/stmtctx"
+ "matrixbase/pkg/types/json"
+ "matrixbase/pkg/util/hack"
+)
+
+// Kind constants.
+const (
+ KindNull byte = 0
+ KindInt64 byte = 1
+ KindUint64 byte = 2
+ KindFloat32 byte = 3
+ KindFloat64 byte = 4
+ KindString byte = 5
+ KindBytes byte = 6
+ KindBinaryLiteral byte = 7 // Used for BIT / HEX literals.
+ KindMysqlDecimal byte = 8
+ KindMysqlDuration byte = 9
+ KindMysqlEnum byte = 10
+ KindMysqlBit byte = 11 // Used for BIT table column values.
+ KindMysqlSet byte = 12
+ KindMysqlTime byte = 13
+ KindInterface byte = 14
+ KindMinNotNull byte = 15
+ KindMaxValue byte = 16
+ KindRaw byte = 17
+ KindMysqlJSON byte = 18
+)
+
+// Datum is a data box holds different kind of data.
+// It has better performance and is easier to use than `interface{}`.
+type Datum struct {
+ k byte // datum kind.
+ decimal uint16 // decimal can hold uint16 values.
+ length uint32 // length can hold uint32 values.
+ i int64 // i can hold int64 uint64 float64 values.
+ collation string // collation hold the collation information for string value.
+ b []byte // b can hold string or []byte values.
+ x interface{} // x hold all other types.
+}
+
+// Clone create a deep copy of the Datum.
+func (d *Datum) Clone() *Datum {
+ ret := new(Datum)
+ d.Copy(ret)
+ return ret
+}
+
+// Copy deep copies a Datum into destination.
+func (d *Datum) Copy(dst *Datum) {
+ *dst = *d
+ if d.b != nil {
+ dst.b = make([]byte, len(d.b))
+ copy(dst.b, d.b)
+ }
+ switch dst.Kind() {
+ case KindMysqlDecimal:
+ d := *d.GetMysqlDecimal()
+ dst.SetMysqlDecimal(&d)
+ case KindMysqlTime:
+ dst.SetMysqlTime(d.GetMysqlTime())
+ }
+}
+
+// Kind gets the kind of the datum.
+func (d *Datum) Kind() byte {
+ return d.k
+}
+
+// Collation gets the collation of the datum.
+func (d *Datum) Collation() string {
+ return d.collation
+}
+
+// SetCollation sets the collation of the datum.
+func (d *Datum) SetCollation(collation string) {
+ d.collation = collation
+}
+
+// Frac gets the frac of the datum.
+func (d *Datum) Frac() int {
+ return int(d.decimal)
+}
+
+// SetFrac sets the frac of the datum.
+func (d *Datum) SetFrac(frac int) {
+ d.decimal = uint16(frac)
+}
+
+// Length gets the length of the datum.
+func (d *Datum) Length() int {
+ return int(d.length)
+}
+
+// SetLength sets the length of the datum.
+func (d *Datum) SetLength(l int) {
+ d.length = uint32(l)
+}
+
+// IsNull checks if datum is null.
+func (d *Datum) IsNull() bool {
+ return d.k == KindNull
+}
+
+// GetInt64 gets int64 value.
+func (d *Datum) GetInt64() int64 {
+ return d.i
+}
+
+// SetInt64 sets int64 value.
+func (d *Datum) SetInt64(i int64) {
+ d.k = KindInt64
+ d.i = i
+}
+
+// GetUint64 gets uint64 value.
+func (d *Datum) GetUint64() uint64 {
+ return uint64(d.i)
+}
+
+// SetUint64 sets uint64 value.
+func (d *Datum) SetUint64(i uint64) {
+ d.k = KindUint64
+ d.i = int64(i)
+}
+
+// GetFloat64 gets float64 value.
+func (d *Datum) GetFloat64() float64 {
+ return math.Float64frombits(uint64(d.i))
+}
+
+// SetFloat64 sets float64 value.
+func (d *Datum) SetFloat64(f float64) {
+ d.k = KindFloat64
+ d.i = int64(math.Float64bits(f))
+}
+
+// GetFloat32 gets float32 value.
+func (d *Datum) GetFloat32() float32 {
+ return float32(math.Float64frombits(uint64(d.i)))
+}
+
+// SetFloat32 sets float32 value.
+func (d *Datum) SetFloat32(f float32) {
+ d.k = KindFloat32
+ d.i = int64(math.Float64bits(float64(f)))
+}
+
+// GetString gets string value.
+func (d *Datum) GetString() string {
+ return string(hack.String(d.b))
+}
+
+// SetString sets string value.
+func (d *Datum) SetString(s string, collation string) {
+ d.k = KindString
+ sink(s)
+ d.b = hack.Slice(s)
+ d.collation = collation
+}
+
+// sink prevents s from being allocated on the stack.
+var sink = func(s string) {
+}
+
+// GetBytes gets bytes value.
+func (d *Datum) GetBytes() []byte {
+ if d.b != nil {
+ return d.b
+ }
+ return []byte{}
+}
+
+// SetBytes sets bytes value to datum.
+func (d *Datum) SetBytes(b []byte) {
+ d.k = KindBytes
+ d.b = b
+ d.collation = charset.CollationBin
+}
+
+// SetBytesAsString sets bytes value to datum as string type.
+func (d *Datum) SetBytesAsString(b []byte, collation string, length uint32) {
+ d.k = KindString
+ d.b = b
+ d.length = length
+ d.collation = collation
+}
+
+// GetInterface gets interface value.
+func (d *Datum) GetInterface() interface{} {
+ return d.x
+}
+
+// SetInterface sets interface to datum.
+func (d *Datum) SetInterface(x interface{}) {
+ d.k = KindInterface
+ d.x = x
+}
+
+// SetNull sets datum to nil.
+func (d *Datum) SetNull() {
+ d.k = KindNull
+ d.x = nil
+}
+
+// SetMinNotNull sets datum to minNotNull value.
+func (d *Datum) SetMinNotNull() {
+ d.k = KindMinNotNull
+ d.x = nil
+}
+
+// GetBinaryLiteral gets Bit value
+func (d *Datum) GetBinaryLiteral() BinaryLiteral {
+ return d.b
+}
+
+// GetMysqlBit gets MysqlBit value
+func (d *Datum) GetMysqlBit() BinaryLiteral {
+ return d.GetBinaryLiteral()
+}
+
+// SetBinaryLiteral sets Bit value
+func (d *Datum) SetBinaryLiteral(b BinaryLiteral) {
+ d.k = KindBinaryLiteral
+ d.b = b
+}
+
+// SetMysqlBit sets MysqlBit value
+func (d *Datum) SetMysqlBit(b BinaryLiteral) {
+ d.k = KindMysqlBit
+ d.b = b
+}
+
+// GetMysqlDecimal gets Decimal value
+func (d *Datum) GetMysqlDecimal() *MyDecimal {
+ return d.x.(*MyDecimal)
+}
+
+// SetMysqlDecimal sets Decimal value
+func (d *Datum) SetMysqlDecimal(b *MyDecimal) {
+ d.k = KindMysqlDecimal
+ d.x = b
+}
+
+// GetMysqlDuration gets Duration value
+func (d *Datum) GetMysqlDuration() Duration {
+ return Duration{Duration: time.Duration(d.i), Fsp: int8(d.decimal)}
+}
+
+// SetMysqlDuration sets Duration value
+func (d *Datum) SetMysqlDuration(b Duration) {
+ d.k = KindMysqlDuration
+ d.i = int64(b.Duration)
+ d.decimal = uint16(b.Fsp)
+}
+
+// GetMysqlEnum gets Enum value
+func (d *Datum) GetMysqlEnum() Enum {
+ str := string(hack.String(d.b))
+ return Enum{Value: uint64(d.i), Name: str}
+}
+
+// SetMysqlEnum sets Enum value
+func (d *Datum) SetMysqlEnum(b Enum, collation string) {
+ d.k = KindMysqlEnum
+ d.i = int64(b.Value)
+ sink(b.Name)
+ d.collation = collation
+ d.b = hack.Slice(b.Name)
+}
+
+// GetMysqlSet gets Set value
+func (d *Datum) GetMysqlSet() Set {
+ str := string(hack.String(d.b))
+ return Set{Value: uint64(d.i), Name: str}
+}
+
+// SetMysqlSet sets Set value
+func (d *Datum) SetMysqlSet(b Set, collation string) {
+ d.k = KindMysqlSet
+ d.i = int64(b.Value)
+ sink(b.Name)
+ d.collation = collation
+ d.b = hack.Slice(b.Name)
+}
+
+// GetMysqlJSON gets json.BinaryJSON value
+func (d *Datum) GetMysqlJSON() json.BinaryJSON {
+ return json.BinaryJSON{TypeCode: byte(d.i), Value: d.b}
+}
+
+// SetMysqlJSON sets json.BinaryJSON value
+func (d *Datum) SetMysqlJSON(b json.BinaryJSON) {
+ d.k = KindMysqlJSON
+ d.i = int64(b.TypeCode)
+ d.b = b.Value
+}
+
+// GetMysqlTime gets types.Time value
+func (d *Datum) GetMysqlTime() Time {
+ return d.x.(Time)
+}
+
+// SetMysqlTime sets types.Time value
+func (d *Datum) SetMysqlTime(b Time) {
+ d.k = KindMysqlTime
+ d.x = b
+}
+
+// SetRaw sets raw value.
+func (d *Datum) SetRaw(b []byte) {
+ d.k = KindRaw
+ d.b = b
+}
+
+// GetRaw gets raw value.
+func (d *Datum) GetRaw() []byte {
+ return d.b
+}
+
+// SetAutoID set the auto increment ID according to its int flag.
+func (d *Datum) SetAutoID(id int64, flag uint) {
+ if mysql.HasUnsignedFlag(flag) {
+ d.SetUint64(uint64(id))
+ } else {
+ d.SetInt64(id)
+ }
+}
+
+// String returns a human-readable description of Datum. It is intended only for debugging.
+func (d Datum) String() string {
+ var t string
+ switch d.k {
+ case KindNull:
+ t = "KindNull"
+ case KindInt64:
+ t = "KindInt64"
+ case KindUint64:
+ t = "KindUint64"
+ case KindFloat32:
+ t = "KindFloat32"
+ case KindFloat64:
+ t = "KindFloat64"
+ case KindString:
+ t = "KindString"
+ case KindBytes:
+ t = "KindBytes"
+ case KindMysqlDecimal:
+ t = "KindMysqlDecimal"
+ case KindMysqlDuration:
+ t = "KindMysqlDuration"
+ case KindMysqlEnum:
+ t = "KindMysqlEnum"
+ case KindBinaryLiteral:
+ t = "KindBinaryLiteral"
+ case KindMysqlBit:
+ t = "KindMysqlBit"
+ case KindMysqlSet:
+ t = "KindMysqlSet"
+ case KindMysqlJSON:
+ t = "KindMysqlJSON"
+ case KindMysqlTime:
+ t = "KindMysqlTime"
+ default:
+ t = "Unknown"
+ }
+ v := d.GetValue()
+ if b, ok := v.([]byte); ok && d.k == KindBytes {
+ v = string(b)
+ }
+ return fmt.Sprintf("%v %v", t, v)
+}
+
+// GetValue gets the value of the datum of any kind.
+func (d *Datum) GetValue() interface{} {
+ switch d.k {
+ case KindInt64:
+ return d.GetInt64()
+ case KindUint64:
+ return d.GetUint64()
+ case KindFloat32:
+ return d.GetFloat32()
+ case KindFloat64:
+ return d.GetFloat64()
+ case KindString:
+ return d.GetString()
+ case KindBytes:
+ return d.GetBytes()
+ case KindMysqlDecimal:
+ return d.GetMysqlDecimal()
+ case KindMysqlDuration:
+ return d.GetMysqlDuration()
+ case KindMysqlEnum:
+ return d.GetMysqlEnum()
+ case KindBinaryLiteral, KindMysqlBit:
+ return d.GetBinaryLiteral()
+ case KindMysqlSet:
+ return d.GetMysqlSet()
+ case KindMysqlJSON:
+ return d.GetMysqlJSON()
+ case KindMysqlTime:
+ return d.GetMysqlTime()
+ default:
+ return d.GetInterface()
+ }
+}
+
+// SetValueWithDefaultCollation sets any kind of value.
+func (d *Datum) SetValueWithDefaultCollation(val interface{}) {
+ switch x := val.(type) {
+ case nil:
+ d.SetNull()
+ case bool:
+ if x {
+ d.SetInt64(1)
+ } else {
+ d.SetInt64(0)
+ }
+ case int:
+ d.SetInt64(int64(x))
+ case int64:
+ d.SetInt64(x)
+ case uint64:
+ d.SetUint64(x)
+ case float32:
+ d.SetFloat32(x)
+ case float64:
+ d.SetFloat64(x)
+ case string:
+ d.SetString(x, mysql.DefaultCollationName)
+ case []byte:
+ d.SetBytes(x)
+ case *MyDecimal:
+ d.SetMysqlDecimal(x)
+ case Duration:
+ d.SetMysqlDuration(x)
+ case Enum:
+ d.SetMysqlEnum(x, mysql.DefaultCollationName)
+ case BinaryLiteral:
+ d.SetBinaryLiteral(x)
+ case BitLiteral: // Store as BinaryLiteral for Bit and Hex literals
+ d.SetBinaryLiteral(BinaryLiteral(x))
+ case HexLiteral:
+ d.SetBinaryLiteral(BinaryLiteral(x))
+ case Set:
+ d.SetMysqlSet(x, mysql.DefaultCollationName)
+ case json.BinaryJSON:
+ d.SetMysqlJSON(x)
+ case Time:
+ d.SetMysqlTime(x)
+ default:
+ d.SetInterface(x)
+ }
+}
+
+// SetValue sets any kind of value.
+func (d *Datum) SetValue(val interface{}, tp *types.FieldType) {
+ switch x := val.(type) {
+ case nil:
+ d.SetNull()
+ case bool:
+ if x {
+ d.SetInt64(1)
+ } else {
+ d.SetInt64(0)
+ }
+ case int:
+ d.SetInt64(int64(x))
+ case int64:
+ d.SetInt64(x)
+ case uint64:
+ d.SetUint64(x)
+ case float32:
+ d.SetFloat32(x)
+ case float64:
+ d.SetFloat64(x)
+ case string:
+ d.SetString(x, tp.Collate)
+ case []byte:
+ d.SetBytes(x)
+ case *MyDecimal:
+ d.SetMysqlDecimal(x)
+ case Duration:
+ d.SetMysqlDuration(x)
+ case Enum:
+ d.SetMysqlEnum(x, tp.Collate)
+ case BinaryLiteral:
+ d.SetBinaryLiteral(x)
+ case BitLiteral: // Store as BinaryLiteral for Bit and Hex literals
+ d.SetBinaryLiteral(BinaryLiteral(x))
+ case HexLiteral:
+ d.SetBinaryLiteral(BinaryLiteral(x))
+ case Set:
+ d.SetMysqlSet(x, tp.Collate)
+ case json.BinaryJSON:
+ d.SetMysqlJSON(x)
+ case Time:
+ d.SetMysqlTime(x)
+ default:
+ d.SetInterface(x)
+ }
+}
+
+// CompareDatum compares datum to another datum.
+// TODO: return error properly.
+func (d *Datum) CompareDatum(sc *stmtctx.StatementContext, ad *Datum) (int, error) {
+ if d.k == KindMysqlJSON && ad.k != KindMysqlJSON {
+ cmp, err := ad.CompareDatum(sc, d)
+ return cmp * -1, errors.Trace(err)
+ }
+ switch ad.k {
+ case KindNull:
+ if d.k == KindNull {
+ return 0, nil
+ }
+ return 1, nil
+ case KindMinNotNull:
+ if d.k == KindNull {
+ return -1, nil
+ } else if d.k == KindMinNotNull {
+ return 0, nil
+ }
+ return 1, nil
+ case KindMaxValue:
+ if d.k == KindMaxValue {
+ return 0, nil
+ }
+ return -1, nil
+ case KindInt64:
+ return d.compareInt64(sc, ad.GetInt64())
+ case KindUint64:
+ return d.compareUint64(sc, ad.GetUint64())
+ case KindFloat32, KindFloat64:
+ return d.compareFloat64(sc, ad.GetFloat64())
+ case KindString:
+ return d.compareString(sc, ad.GetString(), d.collation)
+ case KindBytes:
+ return d.compareBytes(sc, ad.GetBytes())
+ case KindMysqlDecimal:
+ return d.compareMysqlDecimal(sc, ad.GetMysqlDecimal())
+ case KindMysqlDuration:
+ return d.compareMysqlDuration(sc, ad.GetMysqlDuration())
+ case KindMysqlEnum:
+ return d.compareMysqlEnum(sc, ad.GetMysqlEnum())
+ case KindBinaryLiteral, KindMysqlBit:
+ return d.compareBinaryLiteral(sc, ad.GetBinaryLiteral())
+ case KindMysqlSet:
+ return d.compareMysqlSet(sc, ad.GetMysqlSet())
+ case KindMysqlJSON:
+ return d.compareMysqlJSON(sc, ad.GetMysqlJSON())
+ case KindMysqlTime:
+ return d.compareMysqlTime(sc, ad.GetMysqlTime())
+ default:
+ return 0, nil
+ }
+}
+
+func (d *Datum) compareInt64(sc *stmtctx.StatementContext, i int64) (int, error) {
+ switch d.k {
+ case KindMaxValue:
+ return 1, nil
+ case KindInt64:
+ return CompareInt64(d.i, i), nil
+ case KindUint64:
+ if i < 0 || d.GetUint64() > math.MaxInt64 {
+ return 1, nil
+ }
+ return CompareInt64(d.i, i), nil
+ default:
+ return d.compareFloat64(sc, float64(i))
+ }
+}
+
+func (d *Datum) compareUint64(sc *stmtctx.StatementContext, u uint64) (int, error) {
+ switch d.k {
+ case KindMaxValue:
+ return 1, nil
+ case KindInt64:
+ if d.i < 0 || u > math.MaxInt64 {
+ return -1, nil
+ }
+ return CompareInt64(d.i, int64(u)), nil
+ case KindUint64:
+ return CompareUint64(d.GetUint64(), u), nil
+ default:
+ return d.compareFloat64(sc, float64(u))
+ }
+}
+
+func (d *Datum) compareFloat64(sc *stmtctx.StatementContext, f float64) (int, error) {
+ switch d.k {
+ case KindNull, KindMinNotNull:
+ return -1, nil
+ case KindMaxValue:
+ return 1, nil
+ case KindInt64:
+ return CompareFloat64(float64(d.i), f), nil
+ case KindUint64:
+ return CompareFloat64(float64(d.GetUint64()), f), nil
+ case KindFloat32, KindFloat64:
+ return CompareFloat64(d.GetFloat64(), f), nil
+ case KindString, KindBytes:
+ fVal, err := StrToFloat(sc, d.GetString(), false)
+ return CompareFloat64(fVal, f), errors.Trace(err)
+ case KindMysqlDecimal:
+ fVal, err := d.GetMysqlDecimal().ToFloat64()
+ return CompareFloat64(fVal, f), errors.Trace(err)
+ case KindMysqlDuration:
+ fVal := d.GetMysqlDuration().Seconds()
+ return CompareFloat64(fVal, f), nil
+ case KindMysqlEnum:
+ fVal := d.GetMysqlEnum().ToNumber()
+ return CompareFloat64(fVal, f), nil
+ case KindBinaryLiteral, KindMysqlBit:
+ val, err := d.GetBinaryLiteral().ToInt(sc)
+ fVal := float64(val)
+ return CompareFloat64(fVal, f), errors.Trace(err)
+ case KindMysqlSet:
+ fVal := d.GetMysqlSet().ToNumber()
+ return CompareFloat64(fVal, f), nil
+ case KindMysqlTime:
+ fVal, err := d.GetMysqlTime().ToNumber().ToFloat64()
+ return CompareFloat64(fVal, f), errors.Trace(err)
+ default:
+ return -1, nil
+ }
+}
+
+func (d *Datum) compareString(sc *stmtctx.StatementContext, s string, retCollation string) (int, error) {
+ switch d.k {
+ case KindNull, KindMinNotNull:
+ return -1, nil
+ case KindMaxValue:
+ return 1, nil
+ case KindString, KindBytes:
+ return CompareString(d.GetString(), s, d.collation), nil
+ case KindMysqlDecimal:
+ dec := new(MyDecimal)
+ err := sc.HandleTruncate(dec.FromString(hack.Slice(s)))
+ return d.GetMysqlDecimal().Compare(dec), errors.Trace(err)
+ case KindMysqlTime:
+ dt, err := ParseDatetime(sc, s)
+ return d.GetMysqlTime().Compare(dt), errors.Trace(err)
+ case KindMysqlDuration:
+ dur, err := ParseDuration(sc, s, MaxFsp)
+ return d.GetMysqlDuration().Compare(dur), errors.Trace(err)
+ case KindMysqlSet:
+ return CompareString(d.GetMysqlSet().String(), s, d.collation), nil
+ case KindMysqlEnum:
+ return CompareString(d.GetMysqlEnum().String(), s, d.collation), nil
+ case KindBinaryLiteral, KindMysqlBit:
+ return CompareString(d.GetBinaryLiteral().ToString(), s, d.collation), nil
+ default:
+ fVal, err := StrToFloat(sc, s, false)
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+ return d.compareFloat64(sc, fVal)
+ }
+}
+
+func (d *Datum) compareBytes(sc *stmtctx.StatementContext, b []byte) (int, error) {
+ str := string(hack.String(b))
+ return d.compareString(sc, str, d.collation)
+}
+
+func (d *Datum) compareMysqlDecimal(sc *stmtctx.StatementContext, dec *MyDecimal) (int, error) {
+ switch d.k {
+ case KindNull, KindMinNotNull:
+ return -1, nil
+ case KindMaxValue:
+ return 1, nil
+ case KindMysqlDecimal:
+ return d.GetMysqlDecimal().Compare(dec), nil
+ case KindString, KindBytes:
+ dDec := new(MyDecimal)
+ err := sc.HandleTruncate(dDec.FromString(d.GetBytes()))
+ return dDec.Compare(dec), errors.Trace(err)
+ default:
+ dVal, err := d.ConvertTo(sc, NewFieldType(mysql.TypeNewDecimal))
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+ return dVal.GetMysqlDecimal().Compare(dec), nil
+ }
+}
+
+func (d *Datum) compareMysqlDuration(sc *stmtctx.StatementContext, dur Duration) (int, error) {
+ switch d.k {
+ case KindNull, KindMinNotNull:
+ return -1, nil
+ case KindMaxValue:
+ return 1, nil
+ case KindMysqlDuration:
+ return d.GetMysqlDuration().Compare(dur), nil
+ case KindString, KindBytes:
+ dDur, err := ParseDuration(sc, d.GetString(), MaxFsp)
+ return dDur.Compare(dur), errors.Trace(err)
+ default:
+ return d.compareFloat64(sc, dur.Seconds())
+ }
+}
+
+func (d *Datum) compareMysqlEnum(sc *stmtctx.StatementContext, enum Enum) (int, error) {
+ switch d.k {
+ case KindNull, KindMinNotNull:
+ return -1, nil
+ case KindMaxValue:
+ return 1, nil
+ case KindString, KindBytes, KindMysqlEnum, KindMysqlSet:
+ return CompareString(d.GetString(), enum.String(), d.collation), nil
+ default:
+ return d.compareFloat64(sc, enum.ToNumber())
+ }
+}
+
+func (d *Datum) compareBinaryLiteral(sc *stmtctx.StatementContext, b BinaryLiteral) (int, error) {
+ switch d.k {
+ case KindNull, KindMinNotNull:
+ return -1, nil
+ case KindMaxValue:
+ return 1, nil
+ case KindString, KindBytes:
+ return CompareString(d.GetString(), b.ToString(), d.collation), nil
+ case KindBinaryLiteral, KindMysqlBit:
+ return CompareString(d.GetBinaryLiteral().ToString(), b.ToString(), d.collation), nil
+ default:
+ val, err := b.ToInt(sc)
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+ result, err := d.compareFloat64(sc, float64(val))
+ return result, errors.Trace(err)
+ }
+}
+
+func (d *Datum) compareMysqlSet(sc *stmtctx.StatementContext, set Set) (int, error) {
+ switch d.k {
+ case KindNull, KindMinNotNull:
+ return -1, nil
+ case KindMaxValue:
+ return 1, nil
+ case KindString, KindBytes, KindMysqlEnum, KindMysqlSet:
+ return CompareString(d.GetString(), set.String(), d.collation), nil
+ default:
+ return d.compareFloat64(sc, set.ToNumber())
+ }
+}
+
+func (d *Datum) compareMysqlJSON(sc *stmtctx.StatementContext, target json.BinaryJSON) (int, error) {
+ origin, err := d.ToMysqlJSON()
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+ return json.CompareBinary(origin, target), nil
+}
+
+func (d *Datum) compareMysqlTime(sc *stmtctx.StatementContext, time Time) (int, error) {
+ switch d.k {
+ case KindNull, KindMinNotNull:
+ return -1, nil
+ case KindMaxValue:
+ return 1, nil
+ case KindString, KindBytes:
+ dt, err := ParseDatetime(sc, d.GetString())
+ return dt.Compare(time), errors.Trace(err)
+ case KindMysqlTime:
+ return d.GetMysqlTime().Compare(time), nil
+ default:
+ fVal, err := time.ToNumber().ToFloat64()
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+ return d.compareFloat64(sc, fVal)
+ }
+}
+
+// ConvertTo converts a datum to the target field type.
+// change this method need sync modification to type2Kind in rowcodec/types.go
+func (d *Datum) ConvertTo(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ if d.k == KindNull {
+ return Datum{}, nil
+ }
+ switch target.Tp { // TODO: implement mysql types convert when "CAST() AS" syntax are supported.
+ case mysql.TypeTiny, mysql.TypeShort, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong:
+ unsigned := mysql.HasUnsignedFlag(target.Flag)
+ if unsigned {
+ return d.convertToUint(sc, target)
+ }
+ return d.convertToInt(sc, target)
+ case mysql.TypeFloat, mysql.TypeDouble:
+ return d.convertToFloat(sc, target)
+ case mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ mysql.TypeString, mysql.TypeVarchar, mysql.TypeVarString:
+ return d.convertToString(sc, target)
+ case mysql.TypeTimestamp:
+ return d.convertToMysqlTimestamp(sc, target)
+ case mysql.TypeDatetime, mysql.TypeDate:
+ return d.convertToMysqlTime(sc, target)
+ case mysql.TypeDuration:
+ return d.convertToMysqlDuration(sc, target)
+ case mysql.TypeNewDecimal:
+ return d.convertToMysqlDecimal(sc, target)
+ case mysql.TypeYear:
+ return d.convertToMysqlYear(sc, target)
+ case mysql.TypeEnum:
+ return d.convertToMysqlEnum(sc, target)
+ case mysql.TypeBit:
+ return d.convertToMysqlBit(sc, target)
+ case mysql.TypeSet:
+ return d.convertToMysqlSet(sc, target)
+ case mysql.TypeJSON:
+ return d.convertToMysqlJSON(sc, target)
+ case mysql.TypeNull:
+ return Datum{}, nil
+ default:
+ panic("should never happen")
+ }
+}
+
+func (d *Datum) convertToFloat(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ var (
+ f float64
+ ret Datum
+ err error
+ )
+ switch d.k {
+ case KindNull:
+ return ret, nil
+ case KindInt64:
+ f = float64(d.GetInt64())
+ case KindUint64:
+ f = float64(d.GetUint64())
+ case KindFloat32, KindFloat64:
+ f = d.GetFloat64()
+ case KindString, KindBytes:
+ f, err = StrToFloat(sc, d.GetString(), false)
+ case KindMysqlTime:
+ f, err = d.GetMysqlTime().ToNumber().ToFloat64()
+ case KindMysqlDuration:
+ f, err = d.GetMysqlDuration().ToNumber().ToFloat64()
+ case KindMysqlDecimal:
+ f, err = d.GetMysqlDecimal().ToFloat64()
+ case KindMysqlSet:
+ f = d.GetMysqlSet().ToNumber()
+ case KindMysqlEnum:
+ f = d.GetMysqlEnum().ToNumber()
+ case KindBinaryLiteral, KindMysqlBit:
+ val, err1 := d.GetBinaryLiteral().ToInt(sc)
+ f, err = float64(val), err1
+ case KindMysqlJSON:
+ f, err = ConvertJSONToFloat(sc, d.GetMysqlJSON())
+ default:
+ return invalidConv(d, target.Tp)
+ }
+ var err1 error
+ f, err1 = ProduceFloatWithSpecifiedTp(f, target, sc)
+ if err == nil && err1 != nil {
+ err = err1
+ }
+ if target.Tp == mysql.TypeFloat {
+ ret.SetFloat32(float32(f))
+ } else {
+ ret.SetFloat64(f)
+ }
+ return ret, errors.Trace(err)
+}
+
+// ProduceFloatWithSpecifiedTp produces a new float64 according to `flen` and `decimal`.
+func ProduceFloatWithSpecifiedTp(f float64, target *FieldType, sc *stmtctx.StatementContext) (_ float64, err error) {
+ // For float and following double type, we will only truncate it for float(M, D) format.
+ // If no D is set, we will handle it like origin float whether M is set or not.
+ if target.Flen != UnspecifiedLength && target.Decimal != UnspecifiedLength {
+ f, err = TruncateFloat(f, target.Flen, target.Decimal)
+ if err = sc.HandleOverflow(err, err); err != nil {
+ return f, errors.Trace(err)
+ }
+ }
+ if mysql.HasUnsignedFlag(target.Flag) && f < 0 {
+ return 0, overflow(f, target.Tp)
+ }
+ if target.Tp == mysql.TypeFloat && (f > math.MaxFloat32 || f < -math.MaxFloat32) {
+ if f > 0 {
+ return math.MaxFloat32, overflow(f, target.Tp)
+ }
+ return -math.MaxFloat32, overflow(f, target.Tp)
+ }
+ return f, nil
+}
+
+func (d *Datum) convertToString(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ var ret Datum
+ var s string
+ switch d.k {
+ case KindInt64:
+ s = strconv.FormatInt(d.GetInt64(), 10)
+ case KindUint64:
+ s = strconv.FormatUint(d.GetUint64(), 10)
+ case KindFloat32:
+ s = strconv.FormatFloat(d.GetFloat64(), 'f', -1, 32)
+ case KindFloat64:
+ s = strconv.FormatFloat(d.GetFloat64(), 'f', -1, 64)
+ case KindString, KindBytes:
+ s = d.GetString()
+ case KindMysqlTime:
+ s = d.GetMysqlTime().String()
+ case KindMysqlDuration:
+ s = d.GetMysqlDuration().String()
+ case KindMysqlDecimal:
+ s = d.GetMysqlDecimal().String()
+ case KindMysqlEnum:
+ s = d.GetMysqlEnum().String()
+ case KindMysqlSet:
+ s = d.GetMysqlSet().String()
+ case KindBinaryLiteral, KindMysqlBit:
+ s = d.GetBinaryLiteral().ToString()
+ case KindMysqlJSON:
+ s = d.GetMysqlJSON().String()
+ default:
+ return invalidConv(d, target.Tp)
+ }
+ s, err := ProduceStrWithSpecifiedTp(s, target, sc, true)
+ ret.SetString(s, target.Collate)
+ if target.Charset == charset.CharsetBin {
+ ret.k = KindBytes
+ }
+ return ret, errors.Trace(err)
+}
+
+// ProduceStrWithSpecifiedTp produces a new string according to `flen` and `chs`. Param `padZero` indicates
+// whether we should pad `\0` for `binary(flen)` type.
+func ProduceStrWithSpecifiedTp(s string, tp *FieldType, sc *stmtctx.StatementContext, padZero bool) (_ string, err error) {
+ flen, chs := tp.Flen, tp.Charset
+ if flen >= 0 {
+ // overflowed stores the part of the string that is out of the length contraint, it is later checked to see if the
+ // overflowed part is all whitespaces
+ var overflowed string
+ var characterLen int
+ // Flen is the rune length, not binary length, for UTF8 charset, we need to calculate the
+ // rune count and truncate to Flen runes if it is too long.
+ if chs == charset.CharsetUTF8 || chs == charset.CharsetUTF8MB4 {
+ characterLen = utf8.RuneCountInString(s)
+ if characterLen > flen {
+ // 1. If len(s) is 0 and flen is 0, truncateLen will be 0, don't truncate s.
+ // CREATE TABLE t (a char(0));
+ // INSERT INTO t VALUES (``);
+ // 2. If len(s) is 10 and flen is 0, truncateLen will be 0 too, but we still need to truncate s.
+ // SELECT 1, CAST(1234 AS CHAR(0));
+ // So truncateLen is not a suitable variable to determine to do truncate or not.
+ var runeCount int
+ var truncateLen int
+ for i := range s {
+ if runeCount == flen {
+ truncateLen = i
+ break
+ }
+ runeCount++
+ }
+ overflowed = s[truncateLen:]
+ s = truncateStr(s, truncateLen)
+ }
+ } else if len(s) > flen {
+ characterLen = len(s)
+ overflowed = s[flen:]
+ s = truncateStr(s, flen)
+ }
+
+ if len(overflowed) != 0 {
+ trimed := strings.TrimRight(overflowed, " \t\n\r")
+ if len(trimed) == 0 && !IsBinaryStr(tp) && IsTypeChar(tp.Tp) {
+ if tp.Tp == mysql.TypeVarchar {
+ sc.AppendWarning(ErrTruncated.GenWithStack("Data truncated, field len %d, data len %d", flen, characterLen))
+ }
+ } else {
+ err = ErrDataTooLong.GenWithStack("Data Too Long, field len %d, data len %d", flen, characterLen)
+ }
+ }
+
+ if tp.Tp == mysql.TypeString && IsBinaryStr(tp) && len(s) < flen && padZero {
+ padding := make([]byte, flen-len(s))
+ s = string(append([]byte(s), padding...))
+ }
+ }
+ return s, errors.Trace(sc.HandleTruncate(err))
+}
+
+func (d *Datum) convertToInt(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ i64, err := d.toSignedInteger(sc, target.Tp)
+ return NewIntDatum(i64), errors.Trace(err)
+}
+
+func (d *Datum) convertToUint(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ tp := target.Tp
+ upperBound := IntergerUnsignedUpperBound(tp)
+ var (
+ val uint64
+ err error
+ ret Datum
+ )
+ switch d.k {
+ case KindInt64:
+ val, err = ConvertIntToUint(sc, d.GetInt64(), upperBound, tp)
+ case KindUint64:
+ val, err = ConvertUintToUint(d.GetUint64(), upperBound, tp)
+ case KindFloat32, KindFloat64:
+ val, err = ConvertFloatToUint(sc, d.GetFloat64(), upperBound, tp)
+ case KindString, KindBytes:
+ uval, err1 := StrToUint(sc, d.GetString(), false)
+ if err1 != nil && ErrOverflow.Equal(err1) && !sc.ShouldIgnoreOverflowError() {
+ return ret, errors.Trace(err1)
+ }
+ val, err = ConvertUintToUint(uval, upperBound, tp)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ err = err1
+ case KindMysqlTime:
+ dec := d.GetMysqlTime().ToNumber()
+ err = dec.Round(dec, 0, ModeHalfEven)
+ ival, err1 := dec.ToInt()
+ if err == nil {
+ err = err1
+ }
+ val, err1 = ConvertIntToUint(sc, ival, upperBound, tp)
+ if err == nil {
+ err = err1
+ }
+ case KindMysqlDuration:
+ dec := d.GetMysqlDuration().ToNumber()
+ err = dec.Round(dec, 0, ModeHalfEven)
+ ival, err1 := dec.ToInt()
+ if err1 == nil {
+ val, err = ConvertIntToUint(sc, ival, upperBound, tp)
+ }
+ case KindMysqlDecimal:
+ val, err = ConvertDecimalToUint(sc, d.GetMysqlDecimal(), upperBound, tp)
+ case KindMysqlEnum:
+ val, err = ConvertFloatToUint(sc, d.GetMysqlEnum().ToNumber(), upperBound, tp)
+ case KindMysqlSet:
+ val, err = ConvertFloatToUint(sc, d.GetMysqlSet().ToNumber(), upperBound, tp)
+ case KindBinaryLiteral, KindMysqlBit:
+ val, err = d.GetBinaryLiteral().ToInt(sc)
+ if err == nil {
+ val, err = ConvertUintToUint(val, upperBound, tp)
+ }
+ case KindMysqlJSON:
+ var i64 int64
+ i64, err = ConvertJSONToInt(sc, d.GetMysqlJSON(), true, tp)
+ val = uint64(i64)
+ default:
+ return invalidConv(d, target.Tp)
+ }
+ ret.SetUint64(val)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ return ret, nil
+}
+
+func (d *Datum) convertToMysqlTimestamp(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ var (
+ ret Datum
+ t Time
+ err error
+ )
+ fsp := DefaultFsp
+ if target.Decimal != UnspecifiedLength {
+ fsp = int8(target.Decimal)
+ }
+ switch d.k {
+ case KindMysqlTime:
+ t = d.GetMysqlTime()
+ t, err = t.RoundFrac(sc, fsp)
+ case KindMysqlDuration:
+ t, err = d.GetMysqlDuration().ConvertToTime(sc, mysql.TypeTimestamp)
+ if err != nil {
+ ret.SetMysqlTime(t)
+ return ret, errors.Trace(err)
+ }
+ t, err = t.RoundFrac(sc, fsp)
+ case KindString, KindBytes:
+ t, err = ParseTime(sc, d.GetString(), mysql.TypeTimestamp, fsp)
+ case KindInt64:
+ t, err = ParseTimeFromNum(sc, d.GetInt64(), mysql.TypeTimestamp, fsp)
+ case KindMysqlDecimal:
+ t, err = ParseTimeFromFloatString(sc, d.GetMysqlDecimal().String(), mysql.TypeTimestamp, fsp)
+ case KindMysqlJSON:
+ j := d.GetMysqlJSON()
+ var s string
+ s, err = j.Unquote()
+ if err != nil {
+ ret.SetMysqlTime(t)
+ return ret, err
+ }
+ t, err = ParseTime(sc, s, mysql.TypeTimestamp, fsp)
+ default:
+ return invalidConv(d, mysql.TypeTimestamp)
+ }
+ t.SetType(mysql.TypeTimestamp)
+ ret.SetMysqlTime(t)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ return ret, nil
+}
+
+func (d *Datum) convertToMysqlTime(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ tp := target.Tp
+ fsp := DefaultFsp
+ if target.Decimal != UnspecifiedLength {
+ fsp = int8(target.Decimal)
+ }
+ var (
+ ret Datum
+ t Time
+ err error
+ )
+ switch d.k {
+ case KindMysqlTime:
+ t, err = d.GetMysqlTime().Convert(sc, tp)
+ if err != nil {
+ ret.SetMysqlTime(t)
+ return ret, errors.Trace(err)
+ }
+ t, err = t.RoundFrac(sc, fsp)
+ case KindMysqlDuration:
+ t, err = d.GetMysqlDuration().ConvertToTime(sc, tp)
+ if err != nil {
+ ret.SetMysqlTime(t)
+ return ret, errors.Trace(err)
+ }
+ t, err = t.RoundFrac(sc, fsp)
+ case KindMysqlDecimal:
+ t, err = ParseTimeFromFloatString(sc, d.GetMysqlDecimal().String(), tp, fsp)
+ case KindString, KindBytes:
+ t, err = ParseTime(sc, d.GetString(), tp, fsp)
+ case KindInt64:
+ t, err = ParseTimeFromNum(sc, d.GetInt64(), tp, fsp)
+ case KindMysqlJSON:
+ j := d.GetMysqlJSON()
+ var s string
+ s, err = j.Unquote()
+ if err != nil {
+ ret.SetMysqlTime(t)
+ return ret, err
+ }
+ t, err = ParseTime(sc, s, tp, fsp)
+ default:
+ return invalidConv(d, tp)
+ }
+ if tp == mysql.TypeDate {
+ // Truncate hh:mm:ss part if the type is Date.
+ t.SetCoreTime(FromDate(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0))
+ }
+ ret.SetMysqlTime(t)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ return ret, nil
+}
+
+func (d *Datum) convertToMysqlDuration(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ tp := target.Tp
+ fsp := DefaultFsp
+ if target.Decimal != UnspecifiedLength {
+ fsp = int8(target.Decimal)
+ }
+ var ret Datum
+ switch d.k {
+ case KindMysqlTime:
+ dur, err := d.GetMysqlTime().ConvertToDuration()
+ if err != nil {
+ ret.SetMysqlDuration(dur)
+ return ret, errors.Trace(err)
+ }
+ dur, err = dur.RoundFrac(fsp)
+ ret.SetMysqlDuration(dur)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ case KindMysqlDuration:
+ dur, err := d.GetMysqlDuration().RoundFrac(fsp)
+ ret.SetMysqlDuration(dur)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ case KindInt64, KindFloat32, KindFloat64, KindMysqlDecimal:
+ // TODO: We need a ParseDurationFromNum to avoid the cost of converting a num to string.
+ timeStr, err := d.ToString()
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ timeNum, err := d.ToInt64(sc)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ // For huge numbers(>'0001-00-00 00-00-00') try full DATETIME in ParseDuration.
+ if timeNum > MaxDuration && timeNum < 10000000000 {
+ // mysql return max in no strict sql mode.
+ ret.SetMysqlDuration(Duration{Duration: MaxTime, Fsp: 0})
+ return ret, ErrWrongValue.GenWithStackByArgs(TimeStr, timeStr)
+ }
+ if timeNum < -MaxDuration {
+ return ret, ErrWrongValue.GenWithStackByArgs(TimeStr, timeStr)
+ }
+ t, err := ParseDuration(sc, timeStr, fsp)
+ ret.SetMysqlDuration(t)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ case KindString, KindBytes:
+ t, err := ParseDuration(sc, d.GetString(), fsp)
+ ret.SetMysqlDuration(t)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ case KindMysqlJSON:
+ j := d.GetMysqlJSON()
+ s, err := j.Unquote()
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ t, err := ParseDuration(sc, s, fsp)
+ ret.SetMysqlDuration(t)
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ default:
+ return invalidConv(d, tp)
+ }
+ return ret, nil
+}
+
+func (d *Datum) convertToMysqlDecimal(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ var ret Datum
+ ret.SetLength(target.Flen)
+ ret.SetFrac(target.Decimal)
+ var dec = &MyDecimal{}
+ var err error
+ switch d.k {
+ case KindInt64:
+ dec.FromInt(d.GetInt64())
+ case KindUint64:
+ dec.FromUint(d.GetUint64())
+ case KindFloat32, KindFloat64:
+ err = dec.FromFloat64(d.GetFloat64())
+ case KindString, KindBytes:
+ err = dec.FromString(d.GetBytes())
+ case KindMysqlDecimal:
+ *dec = *d.GetMysqlDecimal()
+ case KindMysqlTime:
+ dec = d.GetMysqlTime().ToNumber()
+ case KindMysqlDuration:
+ dec = d.GetMysqlDuration().ToNumber()
+ case KindMysqlEnum:
+ err = dec.FromFloat64(d.GetMysqlEnum().ToNumber())
+ case KindMysqlSet:
+ err = dec.FromFloat64(d.GetMysqlSet().ToNumber())
+ case KindBinaryLiteral, KindMysqlBit:
+ val, err1 := d.GetBinaryLiteral().ToInt(sc)
+ err = err1
+ dec.FromUint(val)
+ case KindMysqlJSON:
+ f, err1 := ConvertJSONToDecimal(sc, d.GetMysqlJSON())
+ if err1 != nil {
+ return ret, errors.Trace(err1)
+ }
+ dec = f
+ default:
+ return invalidConv(d, target.Tp)
+ }
+ var err1 error
+ dec, err1 = ProduceDecWithSpecifiedTp(dec, target, sc)
+ if err == nil && err1 != nil {
+ err = err1
+ }
+ if dec.negative && mysql.HasUnsignedFlag(target.Flag) {
+ *dec = zeroMyDecimal
+ if err == nil {
+ err = ErrOverflow.GenWithStackByArgs("DECIMAL", fmt.Sprintf("(%d, %d)", target.Flen, target.Decimal))
+ }
+ }
+ ret.SetMysqlDecimal(dec)
+ return ret, err
+}
+
+// ProduceDecWithSpecifiedTp produces a new decimal according to `flen` and `decimal`.
+func ProduceDecWithSpecifiedTp(dec *MyDecimal, tp *FieldType, sc *stmtctx.StatementContext) (_ *MyDecimal, err error) {
+ flen, decimal := tp.Flen, tp.Decimal
+ if flen != UnspecifiedLength && decimal != UnspecifiedLength {
+ if flen < decimal {
+ return nil, ErrMBiggerThanD.GenWithStackByArgs("")
+ }
+ prec, frac := dec.PrecisionAndFrac()
+ if !dec.IsZero() && prec-frac > flen-decimal {
+ dec = NewMaxOrMinDec(dec.IsNegative(), flen, decimal)
+ // select (cast 111 as decimal(1)) causes a warning in MySQL.
+ err = ErrOverflow.GenWithStackByArgs("DECIMAL", fmt.Sprintf("(%d, %d)", flen, decimal))
+ } else if frac != decimal {
+ old := *dec
+ err = dec.Round(dec, decimal, ModeHalfEven)
+ if err != nil {
+ return nil, err
+ }
+ if !dec.IsZero() && frac > decimal && dec.Compare(&old) != 0 {
+ sc.AppendWarning(ErrTruncatedWrongVal.GenWithStackByArgs("DECIMAL", &old))
+ err = nil
+ }
+ }
+ }
+
+ if ErrOverflow.Equal(err) {
+ // TODO: warnErr need to be ErrWarnDataOutOfRange
+ err = sc.HandleOverflow(err, err)
+ }
+ unsigned := mysql.HasUnsignedFlag(tp.Flag)
+ if unsigned && dec.IsNegative() {
+ dec = dec.FromUint(0)
+ }
+ return dec, err
+}
+
+func (d *Datum) convertToMysqlYear(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ var (
+ ret Datum
+ y int64
+ err error
+ adjust bool
+ )
+ switch d.k {
+ case KindString, KindBytes:
+ s := d.GetString()
+ trimS := strings.TrimSpace(s)
+ y, err = StrToInt(sc, trimS, false)
+ if err != nil {
+ ret.SetInt64(0)
+ return ret, errors.Trace(err)
+ }
+ // condition:
+ // parsed to 0, not a string of length 4, the first valid char is a 0 digit
+ if len(s) != 4 && y == 0 && strings.HasPrefix(trimS, "0") {
+ adjust = true
+ }
+ case KindMysqlTime:
+ y = int64(d.GetMysqlTime().Year())
+ case KindMysqlDuration:
+ y = int64(time.Now().Year())
+ case KindMysqlJSON:
+ y, err = ConvertJSONToInt64(sc, d.GetMysqlJSON(), false)
+ if err != nil {
+ ret.SetInt64(0)
+ return ret, errors.Trace(err)
+ }
+ default:
+ ret, err = d.convertToInt(sc, NewFieldType(mysql.TypeLonglong))
+ if err != nil {
+ _, err = invalidConv(d, target.Tp)
+ ret.SetInt64(0)
+ return ret, err
+ }
+ y = ret.GetInt64()
+ }
+ y, err = AdjustYear(y, adjust)
+ ret.SetInt64(y)
+ return ret, errors.Trace(err)
+}
+
+// ConvertDatumToFloatYear converts datum into MySQL year with float type
+func ConvertDatumToFloatYear(sc *stmtctx.StatementContext, d Datum) (Datum, error) {
+ return d.convertToMysqlFloatYear(sc, types.NewFieldType(mysql.TypeYear))
+}
+
+func (d *Datum) convertToMysqlFloatYear(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ var (
+ ret Datum
+ y float64
+ err error
+ adjust bool
+ )
+ switch d.k {
+ case KindString, KindBytes:
+ s := d.GetString()
+ trimS := strings.TrimSpace(s)
+ y, err = StrToFloat(sc, trimS, false)
+ if err != nil {
+ ret.SetFloat64(0)
+ return ret, errors.Trace(err)
+ }
+ // condition:
+ // parsed to 0, not a string of length 4, the first valid char is a 0 digit
+ if len(s) != 4 && y == 0 && strings.HasPrefix(trimS, "0") {
+ adjust = true
+ }
+ case KindMysqlTime:
+ y = float64(d.GetMysqlTime().Year())
+ case KindMysqlDuration:
+ y = float64(time.Now().Year())
+ case KindNull:
+ // if datum is NULL, we should keep it as it is, instead of setting it to zero or any other value.
+ ret = *d
+ return ret, nil
+ default:
+ ret, err = d.convertToFloat(sc, NewFieldType(mysql.TypeDouble))
+ if err != nil {
+ _, err = invalidConv(d, target.Tp)
+ ret.SetFloat64(0)
+ return ret, err
+ }
+ y = ret.GetFloat64()
+ }
+ y = adjustYearForFloat(y, adjust)
+ ret.SetFloat64(y)
+ return ret, err
+}
+
+func (d *Datum) convertStringToMysqlBit(sc *stmtctx.StatementContext) (uint64, error) {
+ bitStr, err := ParseBitStr(BinaryLiteral(d.b).ToString())
+ if err != nil {
+ // It cannot be converted to bit type, so we need to convert it to int type.
+ return BinaryLiteral(d.b).ToInt(sc)
+ }
+ return bitStr.ToInt(sc)
+}
+
+func (d *Datum) convertToMysqlBit(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ var ret Datum
+ var uintValue uint64
+ var err error
+ switch d.k {
+ case KindBytes:
+ uintValue, err = BinaryLiteral(d.b).ToInt(sc)
+ case KindString:
+ // For single bit value, we take string like "true", "1" as 1, and "false", "0" as 0,
+ // this behavior is not documented in MySQL, but it behaves so, for more information, see issue #18681
+ s := BinaryLiteral(d.b).ToString()
+ if target.Flen == 1 {
+ switch strings.ToLower(s) {
+ case "true", "1":
+ uintValue = 1
+ case "false", "0":
+ uintValue = 0
+ default:
+ uintValue, err = d.convertStringToMysqlBit(sc)
+ }
+ } else {
+ uintValue, err = d.convertStringToMysqlBit(sc)
+ }
+ case KindInt64:
+ // if input kind is int64 (signed), when trans to bit, we need to treat it as unsigned
+ d.k = KindUint64
+ fallthrough
+ default:
+ uintDatum, err1 := d.convertToUint(sc, target)
+ uintValue, err = uintDatum.GetUint64(), err1
+ }
+ // Avoid byte size panic, never goto this branch.
+ if target.Flen <= 0 || target.Flen >= 128 {
+ return Datum{}, errors.Trace(ErrDataTooLong.GenWithStack("Data Too Long, field len %d", target.Flen))
+ }
+ if target.Flen < 64 && uintValue >= 1<<(uint64(target.Flen)) {
+ uintValue &= (1 << (uint64(target.Flen))) - 1
+ err = ErrDataTooLong.GenWithStack("Data Too Long, field len %d", target.Flen)
+ }
+ byteSize := (target.Flen + 7) >> 3
+ ret.SetMysqlBit(NewBinaryLiteralFromUint(uintValue, byteSize))
+ return ret, errors.Trace(err)
+}
+
+func (d *Datum) convertToMysqlEnum(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ var (
+ ret Datum
+ e Enum
+ err error
+ )
+ switch d.k {
+ case KindString, KindBytes, KindBinaryLiteral:
+ e, err = ParseEnum(target.Elems, d.GetString(), target.Collate)
+ case KindMysqlEnum:
+ e, err = ParseEnum(target.Elems, d.GetMysqlEnum().Name, target.Collate)
+ case KindMysqlSet:
+ e, err = ParseEnum(target.Elems, d.GetMysqlSet().Name, target.Collate)
+ default:
+ var uintDatum Datum
+ uintDatum, err = d.convertToUint(sc, target)
+ if err == nil {
+ e, err = ParseEnumValue(target.Elems, uintDatum.GetUint64())
+ }
+ }
+ if err != nil {
+ err = errors.Wrap(ErrTruncated, "convert to MySQL enum failed: "+err.Error())
+ }
+ ret.SetMysqlEnum(e, target.Collate)
+ return ret, err
+}
+
+func (d *Datum) convertToMysqlSet(sc *stmtctx.StatementContext, target *FieldType) (Datum, error) {
+ var (
+ ret Datum
+ s Set
+ err error
+ )
+ switch d.k {
+ case KindString, KindBytes, KindBinaryLiteral:
+ s, err = ParseSet(target.Elems, d.GetString(), target.Collate)
+ case KindMysqlEnum:
+ s, err = ParseSet(target.Elems, d.GetMysqlEnum().Name, target.Collate)
+ case KindMysqlSet:
+ s, err = ParseSet(target.Elems, d.GetMysqlSet().Name, target.Collate)
+ default:
+ var uintDatum Datum
+ uintDatum, err = d.convertToUint(sc, target)
+ if err == nil {
+ s, err = ParseSetValue(target.Elems, uintDatum.GetUint64())
+ }
+ }
+ if err != nil {
+ err = errors.Wrap(ErrTruncated, "convert to MySQL set failed: "+err.Error())
+ }
+ ret.SetMysqlSet(s, target.Collate)
+ return ret, err
+}
+
+func (d *Datum) convertToMysqlJSON(sc *stmtctx.StatementContext, target *FieldType) (ret Datum, err error) {
+ switch d.k {
+ case KindString, KindBytes:
+ var j json.BinaryJSON
+ if j, err = json.ParseBinaryFromString(d.GetString()); err == nil {
+ ret.SetMysqlJSON(j)
+ }
+ case KindInt64:
+ i64 := d.GetInt64()
+ ret.SetMysqlJSON(json.CreateBinary(i64))
+ case KindUint64:
+ u64 := d.GetUint64()
+ ret.SetMysqlJSON(json.CreateBinary(u64))
+ case KindFloat32, KindFloat64:
+ f64 := d.GetFloat64()
+ ret.SetMysqlJSON(json.CreateBinary(f64))
+ case KindMysqlDecimal:
+ var f64 float64
+ if f64, err = d.GetMysqlDecimal().ToFloat64(); err == nil {
+ ret.SetMysqlJSON(json.CreateBinary(f64))
+ }
+ case KindMysqlJSON:
+ ret = *d
+ default:
+ var s string
+ if s, err = d.ToString(); err == nil {
+ // TODO: fix precision of MysqlTime. For example,
+ // On MySQL 5.7 CAST(NOW() AS JSON) -> "2011-11-11 11:11:11.111111",
+ // But now we can only return "2011-11-11 11:11:11".
+ ret.SetMysqlJSON(json.CreateBinary(s))
+ }
+ }
+ return ret, errors.Trace(err)
+}
+
+// ToBool converts to a bool.
+// We will use 1 for true, and 0 for false.
+func (d *Datum) ToBool(sc *stmtctx.StatementContext) (int64, error) {
+ var err error
+ isZero := false
+ switch d.Kind() {
+ case KindInt64:
+ isZero = d.GetInt64() == 0
+ case KindUint64:
+ isZero = d.GetUint64() == 0
+ case KindFloat32:
+ isZero = d.GetFloat64() == 0
+ case KindFloat64:
+ isZero = d.GetFloat64() == 0
+ case KindString, KindBytes:
+ iVal, err1 := StrToFloat(sc, d.GetString(), false)
+ isZero, err = iVal == 0, err1
+
+ case KindMysqlTime:
+ isZero = d.GetMysqlTime().IsZero()
+ case KindMysqlDuration:
+ isZero = d.GetMysqlDuration().Duration == 0
+ case KindMysqlDecimal:
+ isZero = d.GetMysqlDecimal().IsZero()
+ case KindMysqlEnum:
+ isZero = d.GetMysqlEnum().ToNumber() == 0
+ case KindMysqlSet:
+ isZero = d.GetMysqlSet().ToNumber() == 0
+ case KindBinaryLiteral, KindMysqlBit:
+ val, err1 := d.GetBinaryLiteral().ToInt(sc)
+ isZero, err = val == 0, err1
+ case KindMysqlJSON:
+ val := d.GetMysqlJSON()
+ isZero = val.IsZero()
+ default:
+ return 0, errors.Errorf("cannot convert %v(type %T) to bool", d.GetValue(), d.GetValue())
+ }
+ var ret int64
+ if isZero {
+ ret = 0
+ } else {
+ ret = 1
+ }
+ if err != nil {
+ return ret, errors.Trace(err)
+ }
+ return ret, nil
+}
+
+// ConvertDatumToDecimal converts datum to decimal.
+func ConvertDatumToDecimal(sc *stmtctx.StatementContext, d Datum) (*MyDecimal, error) {
+ dec := new(MyDecimal)
+ var err error
+ switch d.Kind() {
+ case KindInt64:
+ dec.FromInt(d.GetInt64())
+ case KindUint64:
+ dec.FromUint(d.GetUint64())
+ case KindFloat32:
+ err = dec.FromFloat64(float64(d.GetFloat32()))
+ case KindFloat64:
+ err = dec.FromFloat64(d.GetFloat64())
+ case KindString:
+ err = sc.HandleTruncate(dec.FromString(d.GetBytes()))
+ case KindMysqlDecimal:
+ *dec = *d.GetMysqlDecimal()
+ case KindMysqlEnum:
+ dec.FromUint(d.GetMysqlEnum().Value)
+ case KindMysqlSet:
+ dec.FromUint(d.GetMysqlSet().Value)
+ case KindBinaryLiteral, KindMysqlBit:
+ val, err1 := d.GetBinaryLiteral().ToInt(sc)
+ dec.FromUint(val)
+ err = err1
+ case KindMysqlJSON:
+ f, err1 := ConvertJSONToDecimal(sc, d.GetMysqlJSON())
+ if err1 != nil {
+ return nil, errors.Trace(err1)
+ }
+ dec = f
+ default:
+ err = fmt.Errorf("can't convert %v to decimal", d.GetValue())
+ }
+ return dec, errors.Trace(err)
+}
+
+// ToDecimal converts to a decimal.
+func (d *Datum) ToDecimal(sc *stmtctx.StatementContext) (*MyDecimal, error) {
+ switch d.Kind() {
+ case KindMysqlTime:
+ return d.GetMysqlTime().ToNumber(), nil
+ case KindMysqlDuration:
+ return d.GetMysqlDuration().ToNumber(), nil
+ default:
+ return ConvertDatumToDecimal(sc, *d)
+ }
+}
+
+// ToInt64 converts to a int64.
+func (d *Datum) ToInt64(sc *stmtctx.StatementContext) (int64, error) {
+ switch d.Kind() {
+ case KindMysqlBit:
+ uintVal, err := d.GetBinaryLiteral().ToInt(sc)
+ return int64(uintVal), err
+ }
+ return d.toSignedInteger(sc, mysql.TypeLonglong)
+}
+
+func (d *Datum) toSignedInteger(sc *stmtctx.StatementContext, tp byte) (int64, error) {
+ lowerBound := IntergerSignedLowerBound(tp)
+ upperBound := IntergerSignedUpperBound(tp)
+ switch d.Kind() {
+ case KindInt64:
+ return ConvertIntToInt(d.GetInt64(), lowerBound, upperBound, tp)
+ case KindUint64:
+ return ConvertUintToInt(d.GetUint64(), upperBound, tp)
+ case KindFloat32:
+ return ConvertFloatToInt(float64(d.GetFloat32()), lowerBound, upperBound, tp)
+ case KindFloat64:
+ return ConvertFloatToInt(d.GetFloat64(), lowerBound, upperBound, tp)
+ case KindString, KindBytes:
+ iVal, err := StrToInt(sc, d.GetString(), false)
+ iVal, err2 := ConvertIntToInt(iVal, lowerBound, upperBound, tp)
+ if err == nil {
+ err = err2
+ }
+ return iVal, errors.Trace(err)
+ case KindMysqlTime:
+ // 2011-11-10 11:11:11.999999 -> 20111110111112
+ // 2011-11-10 11:59:59.999999 -> 20111110120000
+ t, err := d.GetMysqlTime().RoundFrac(sc, DefaultFsp)
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+ ival, err := t.ToNumber().ToInt()
+ ival, err2 := ConvertIntToInt(ival, lowerBound, upperBound, tp)
+ if err == nil {
+ err = err2
+ }
+ return ival, errors.Trace(err)
+ case KindMysqlDuration:
+ // 11:11:11.999999 -> 111112
+ // 11:59:59.999999 -> 120000
+ dur, err := d.GetMysqlDuration().RoundFrac(DefaultFsp)
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+ ival, err := dur.ToNumber().ToInt()
+ ival, err2 := ConvertIntToInt(ival, lowerBound, upperBound, tp)
+ if err == nil {
+ err = err2
+ }
+ return ival, errors.Trace(err)
+ case KindMysqlDecimal:
+ var to MyDecimal
+ err := d.GetMysqlDecimal().Round(&to, 0, ModeHalfEven)
+ ival, err1 := to.ToInt()
+ if err == nil {
+ err = err1
+ }
+ ival, err2 := ConvertIntToInt(ival, lowerBound, upperBound, tp)
+ if err == nil {
+ err = err2
+ }
+ return ival, errors.Trace(err)
+ case KindMysqlEnum:
+ fval := d.GetMysqlEnum().ToNumber()
+ return ConvertFloatToInt(fval, lowerBound, upperBound, tp)
+ case KindMysqlSet:
+ fval := d.GetMysqlSet().ToNumber()
+ return ConvertFloatToInt(fval, lowerBound, upperBound, tp)
+ case KindMysqlJSON:
+ return ConvertJSONToInt(sc, d.GetMysqlJSON(), false, tp)
+ case KindBinaryLiteral, KindMysqlBit:
+ val, err := d.GetBinaryLiteral().ToInt(sc)
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+ ival, err := ConvertUintToInt(val, upperBound, tp)
+ return ival, errors.Trace(err)
+ default:
+ return 0, errors.Errorf("cannot convert %v(type %T) to int64", d.GetValue(), d.GetValue())
+ }
+}
+
+// ToFloat64 converts to a float64
+func (d *Datum) ToFloat64(sc *stmtctx.StatementContext) (float64, error) {
+ switch d.Kind() {
+ case KindInt64:
+ return float64(d.GetInt64()), nil
+ case KindUint64:
+ return float64(d.GetUint64()), nil
+ case KindFloat32:
+ return float64(d.GetFloat32()), nil
+ case KindFloat64:
+ return d.GetFloat64(), nil
+ case KindString:
+ return StrToFloat(sc, d.GetString(), false)
+ case KindBytes:
+ return StrToFloat(sc, string(d.GetBytes()), false)
+ case KindMysqlTime:
+ f, err := d.GetMysqlTime().ToNumber().ToFloat64()
+ return f, errors.Trace(err)
+ case KindMysqlDuration:
+ f, err := d.GetMysqlDuration().ToNumber().ToFloat64()
+ return f, errors.Trace(err)
+ case KindMysqlDecimal:
+ f, err := d.GetMysqlDecimal().ToFloat64()
+ return f, errors.Trace(err)
+ case KindMysqlEnum:
+ return d.GetMysqlEnum().ToNumber(), nil
+ case KindMysqlSet:
+ return d.GetMysqlSet().ToNumber(), nil
+ case KindBinaryLiteral, KindMysqlBit:
+ val, err := d.GetBinaryLiteral().ToInt(sc)
+ return float64(val), errors.Trace(err)
+ case KindMysqlJSON:
+ f, err := ConvertJSONToFloat(sc, d.GetMysqlJSON())
+ return f, errors.Trace(err)
+ default:
+ return 0, errors.Errorf("cannot convert %v(type %T) to float64", d.GetValue(), d.GetValue())
+ }
+}
+
+// ToString gets the string representation of the datum.
+func (d *Datum) ToString() (string, error) {
+ switch d.Kind() {
+ case KindInt64:
+ return strconv.FormatInt(d.GetInt64(), 10), nil
+ case KindUint64:
+ return strconv.FormatUint(d.GetUint64(), 10), nil
+ case KindFloat32:
+ return strconv.FormatFloat(float64(d.GetFloat32()), 'f', -1, 32), nil
+ case KindFloat64:
+ return strconv.FormatFloat(d.GetFloat64(), 'f', -1, 64), nil
+ case KindString:
+ return d.GetString(), nil
+ case KindBytes:
+ return d.GetString(), nil
+ case KindMysqlTime:
+ return d.GetMysqlTime().String(), nil
+ case KindMysqlDuration:
+ return d.GetMysqlDuration().String(), nil
+ case KindMysqlDecimal:
+ return d.GetMysqlDecimal().String(), nil
+ case KindMysqlEnum:
+ return d.GetMysqlEnum().String(), nil
+ case KindMysqlSet:
+ return d.GetMysqlSet().String(), nil
+ case KindMysqlJSON:
+ return d.GetMysqlJSON().String(), nil
+ case KindBinaryLiteral, KindMysqlBit:
+ return d.GetBinaryLiteral().ToString(), nil
+ case KindNull:
+ return "", nil
+ default:
+ return "", errors.Errorf("cannot convert %v(type %T) to string", d.GetValue(), d.GetValue())
+ }
+}
+
+// ToBytes gets the bytes representation of the datum.
+func (d *Datum) ToBytes() ([]byte, error) {
+ switch d.k {
+ case KindString, KindBytes:
+ return d.GetBytes(), nil
+ default:
+ str, err := d.ToString()
+ if err != nil {
+ return nil, errors.Trace(err)
+ }
+ return []byte(str), nil
+ }
+}
+
+// ToMysqlJSON is similar to convertToMysqlJSON, except the
+// latter parses from string, but the former uses it as primitive.
+func (d *Datum) ToMysqlJSON() (j json.BinaryJSON, err error) {
+ var in interface{}
+ switch d.Kind() {
+ case KindMysqlJSON:
+ j = d.GetMysqlJSON()
+ return
+ case KindInt64:
+ in = d.GetInt64()
+ case KindUint64:
+ in = d.GetUint64()
+ case KindFloat32, KindFloat64:
+ in = d.GetFloat64()
+ case KindMysqlDecimal:
+ in, err = d.GetMysqlDecimal().ToFloat64()
+ case KindString, KindBytes:
+ in = d.GetString()
+ case KindBinaryLiteral, KindMysqlBit:
+ in = d.GetBinaryLiteral().ToString()
+ case KindNull:
+ in = nil
+ default:
+ in, err = d.ToString()
+ }
+ if err != nil {
+ err = errors.Trace(err)
+ return
+ }
+ j = json.CreateBinary(in)
+ return
+}
+
+func invalidConv(d *Datum, tp byte) (Datum, error) {
+ return Datum{}, errors.Errorf("cannot convert datum from %s to type %s.", KindStr(d.Kind()), TypeStr(tp))
+}
+
+// NewDatum creates a new Datum from an interface{}.
+func NewDatum(in interface{}) (d Datum) {
+ switch x := in.(type) {
+ case []interface{}:
+ d.SetValueWithDefaultCollation(MakeDatums(x...))
+ default:
+ d.SetValueWithDefaultCollation(in)
+ }
+ return d
+}
+
+// NewIntDatum creates a new Datum from an int64 value.
+func NewIntDatum(i int64) (d Datum) {
+ d.SetInt64(i)
+ return d
+}
+
+// NewUintDatum creates a new Datum from an uint64 value.
+func NewUintDatum(i uint64) (d Datum) {
+ d.SetUint64(i)
+ return d
+}
+
+// NewBytesDatum creates a new Datum from a byte slice.
+func NewBytesDatum(b []byte) (d Datum) {
+ d.SetBytes(b)
+ return d
+}
+
+// NewStringDatum creates a new Datum from a string.
+func NewStringDatum(s string) (d Datum) {
+ d.SetString(s, mysql.DefaultCollationName)
+ return d
+}
+
+// NewCollationStringDatum creates a new Datum from a string with collation and length info.
+func NewCollationStringDatum(s string, collation string, length int) (d Datum) {
+ d.SetString(s, collation)
+ return d
+}
+
+// NewFloat64Datum creates a new Datum from a float64 value.
+func NewFloat64Datum(f float64) (d Datum) {
+ d.SetFloat64(f)
+ return d
+}
+
+// NewFloat32Datum creates a new Datum from a float32 value.
+func NewFloat32Datum(f float32) (d Datum) {
+ d.SetFloat32(f)
+ return d
+}
+
+// NewDurationDatum creates a new Datum from a Duration value.
+func NewDurationDatum(dur Duration) (d Datum) {
+ d.SetMysqlDuration(dur)
+ return d
+}
+
+// NewTimeDatum creates a new Time from a Time value.
+func NewTimeDatum(t Time) (d Datum) {
+ d.SetMysqlTime(t)
+ return d
+}
+
+// NewDecimalDatum creates a new Datum from a MyDecimal value.
+func NewDecimalDatum(dec *MyDecimal) (d Datum) {
+ d.SetMysqlDecimal(dec)
+ return d
+}
+
+// NewJSONDatum creates a new Datum from a BinaryJSON value
+func NewJSONDatum(j json.BinaryJSON) (d Datum) {
+ d.SetMysqlJSON(j)
+ return d
+}
+
+// NewBinaryLiteralDatum creates a new BinaryLiteral Datum for a BinaryLiteral value.
+func NewBinaryLiteralDatum(b BinaryLiteral) (d Datum) {
+ d.SetBinaryLiteral(b)
+ return d
+}
+
+// NewMysqlBitDatum creates a new MysqlBit Datum for a BinaryLiteral value.
+func NewMysqlBitDatum(b BinaryLiteral) (d Datum) {
+ d.SetMysqlBit(b)
+ return d
+}
+
+// NewMysqlEnumDatum creates a new MysqlEnum Datum for a Enum value.
+func NewMysqlEnumDatum(e Enum) (d Datum) {
+ d.SetMysqlEnum(e, mysql.DefaultCollationName)
+ return d
+}
+
+// NewCollateMysqlEnumDatum create a new MysqlEnum Datum for a Enum value with collation information.
+func NewCollateMysqlEnumDatum(e Enum, collation string) (d Datum) {
+ d.SetMysqlEnum(e, collation)
+ return d
+}
+
+// NewMysqlSetDatum creates a new MysqlSet Datum for a Enum value.
+func NewMysqlSetDatum(e Set, collation string) (d Datum) {
+ d.SetMysqlSet(e, collation)
+ return d
+}
+
+// MakeDatums creates datum slice from interfaces.
+func MakeDatums(args ...interface{}) []Datum {
+ datums := make([]Datum, len(args))
+ for i, v := range args {
+ datums[i] = NewDatum(v)
+ }
+ return datums
+}
+
+// MinNotNullDatum returns a datum represents minimum not null value.
+func MinNotNullDatum() Datum {
+ return Datum{k: KindMinNotNull}
+}
+
+// MaxValueDatum returns a datum represents max value.
+func MaxValueDatum() Datum {
+ return Datum{k: KindMaxValue}
+}
+
+// SortDatums sorts a slice of datum.
+func SortDatums(sc *stmtctx.StatementContext, datums []Datum) error {
+ sorter := datumsSorter{datums: datums, sc: sc}
+ sort.Sort(&sorter)
+ return sorter.err
+}
+
+type datumsSorter struct {
+ datums []Datum
+ sc *stmtctx.StatementContext
+ err error
+}
+
+func (ds *datumsSorter) Len() int {
+ return len(ds.datums)
+}
+
+func (ds *datumsSorter) Less(i, j int) bool {
+ cmp, err := ds.datums[i].CompareDatum(ds.sc, &ds.datums[j])
+ if err != nil {
+ ds.err = errors.Trace(err)
+ return true
+ }
+ return cmp < 0
+}
+
+func (ds *datumsSorter) Swap(i, j int) {
+ ds.datums[i], ds.datums[j] = ds.datums[j], ds.datums[i]
+}
+
+// DatumsToString converts several datums to formatted string.
+func DatumsToString(datums []Datum, handleSpecialValue bool) (string, error) {
+ strs := make([]string, 0, len(datums))
+ for _, datum := range datums {
+ if handleSpecialValue {
+ switch datum.Kind() {
+ case KindNull:
+ strs = append(strs, "NULL")
+ continue
+ case KindMinNotNull:
+ strs = append(strs, "-inf")
+ continue
+ case KindMaxValue:
+ strs = append(strs, "+inf")
+ continue
+ }
+ }
+ str, err := datum.ToString()
+ if err != nil {
+ return "", errors.Trace(err)
+ }
+ strs = append(strs, str)
+ }
+ size := len(datums)
+ if size > 1 {
+ strs[0] = "(" + strs[0]
+ strs[size-1] = strs[size-1] + ")"
+ }
+ return strings.Join(strs, ", "), nil
+}
+
+// DatumsToStrNoErr converts some datums to a formatted string.
+// If an error occurs, it will print a log instead of returning an error.
+func DatumsToStrNoErr(datums []Datum) string {
+ str, err := DatumsToString(datums, true)
+ terror.Log(errors.Trace(err))
+ return str
+}
+
+// CloneRow deep copies a Datum slice.
+func CloneRow(dr []Datum) []Datum {
+ c := make([]Datum, len(dr))
+ for i, d := range dr {
+ d.Copy(&c[i])
+ }
+ return c
+}
+
+// GetMaxValue returns the max value datum for each type.
+func GetMaxValue(ft *FieldType) (max Datum) {
+ switch ft.Tp {
+ case mysql.TypeTiny, mysql.TypeShort, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong:
+ if mysql.HasUnsignedFlag(ft.Flag) {
+ max.SetUint64(IntergerUnsignedUpperBound(ft.Tp))
+ } else {
+ max.SetInt64(IntergerSignedUpperBound(ft.Tp))
+ }
+ case mysql.TypeFloat:
+ max.SetFloat32(float32(GetMaxFloat(ft.Flen, ft.Decimal)))
+ case mysql.TypeDouble:
+ max.SetFloat64(GetMaxFloat(ft.Flen, ft.Decimal))
+ case mysql.TypeString, mysql.TypeVarString, mysql.TypeVarchar, mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob:
+ // codec.Encode KindMaxValue, to avoid import circle
+ bytes := []byte{250}
+ max.SetString(string(bytes), ft.Collate)
+ case mysql.TypeNewDecimal:
+ max.SetMysqlDecimal(NewMaxOrMinDec(false, ft.Flen, ft.Decimal))
+ case mysql.TypeDuration:
+ max.SetMysqlDuration(Duration{Duration: MaxTime})
+ case mysql.TypeDate, mysql.TypeDatetime, mysql.TypeTimestamp:
+ if ft.Tp == mysql.TypeDate || ft.Tp == mysql.TypeDatetime {
+ max.SetMysqlTime(NewTime(MaxDatetime, ft.Tp, 0))
+ } else {
+ max.SetMysqlTime(MaxTimestamp)
+ }
+ }
+ return
+}
+
+// GetMinValue returns the min value datum for each type.
+func GetMinValue(ft *FieldType) (min Datum) {
+ switch ft.Tp {
+ case mysql.TypeTiny, mysql.TypeShort, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong:
+ if mysql.HasUnsignedFlag(ft.Flag) {
+ min.SetUint64(0)
+ } else {
+ min.SetInt64(IntergerSignedLowerBound(ft.Tp))
+ }
+ case mysql.TypeFloat:
+ min.SetFloat32(float32(-GetMaxFloat(ft.Flen, ft.Decimal)))
+ case mysql.TypeDouble:
+ min.SetFloat64(-GetMaxFloat(ft.Flen, ft.Decimal))
+ case mysql.TypeString, mysql.TypeVarString, mysql.TypeVarchar, mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob:
+ // codec.Encode KindMinNotNull, to avoid import circle
+ bytes := []byte{1}
+ min.SetString(string(bytes), ft.Collate)
+ case mysql.TypeNewDecimal:
+ min.SetMysqlDecimal(NewMaxOrMinDec(true, ft.Flen, ft.Decimal))
+ case mysql.TypeDuration:
+ min.SetMysqlDuration(Duration{Duration: MinTime})
+ case mysql.TypeDate, mysql.TypeDatetime, mysql.TypeTimestamp:
+ if ft.Tp == mysql.TypeDate || ft.Tp == mysql.TypeDatetime {
+ min.SetMysqlTime(NewTime(MinDatetime, ft.Tp, 0))
+ } else {
+ min.SetMysqlTime(MinTimestamp)
+ }
+ }
+ return
+}
+
+// RoundingType is used to indicate the rounding type for reversing evaluation.
+type RoundingType uint8
+
+const (
+ // Ceiling means rounding up.
+ Ceiling RoundingType = iota
+ // Floor means rounding down.
+ Floor
+)
+
+func getDatumBound(retType *FieldType, rType RoundingType) Datum {
+ if rType == Ceiling {
+ return GetMaxValue(retType)
+ }
+ return GetMinValue(retType)
+}
+
+// ChangeReverseResultByUpperLowerBound is for expression's reverse evaluation.
+// Here is an example for what's effort for the function: CastRealAsInt(t.a),
+// if the type of column `t.a` is mysql.TypeDouble, and there is a row that t.a == MaxFloat64
+// then the cast function will arrive a result MaxInt64. But when we do the reverse evaluation,
+// if the result is MaxInt64, and the rounding type is ceiling. Then we should get the MaxFloat64
+// instead of float64(MaxInt64).
+// Another example: cast(1.1 as signed) = 1,
+// when we get the answer 1, we can only reversely evaluate 1.0 as the column value. So in this
+// case, we should judge whether the rounding type are ceiling. If it is, then we should plus one for
+// 1.0 and get the reverse result 2.0.
+func ChangeReverseResultByUpperLowerBound(
+ sc *stmtctx.StatementContext,
+ retType *FieldType,
+ res Datum,
+ rType RoundingType) (Datum, error) {
+ d, err := res.ConvertTo(sc, retType)
+ if terror.ErrorEqual(err, ErrOverflow) {
+ return d, nil
+ }
+ if err != nil {
+ return d, err
+ }
+ resRetType := FieldType{}
+ switch res.Kind() {
+ case KindInt64:
+ resRetType.Tp = mysql.TypeLonglong
+ case KindUint64:
+ resRetType.Tp = mysql.TypeLonglong
+ resRetType.Flag |= mysql.UnsignedFlag
+ case KindFloat32:
+ resRetType.Tp = mysql.TypeFloat
+ case KindFloat64:
+ resRetType.Tp = mysql.TypeDouble
+ case KindMysqlDecimal:
+ resRetType.Tp = mysql.TypeNewDecimal
+ resRetType.Flen = int(res.GetMysqlDecimal().GetDigitsFrac() + res.GetMysqlDecimal().GetDigitsInt())
+ resRetType.Decimal = int(res.GetMysqlDecimal().GetDigitsInt())
+ }
+ bound := getDatumBound(&resRetType, rType)
+ cmp, err := d.CompareDatum(sc, &bound)
+ if err != nil {
+ return d, err
+ }
+ if cmp == 0 {
+ d = getDatumBound(retType, rType)
+ } else if rType == Ceiling {
+ switch retType.Tp {
+ case mysql.TypeShort:
+ if mysql.HasUnsignedFlag(retType.Flag) {
+ if d.GetUint64() != math.MaxUint16 {
+ d.SetUint64(d.GetUint64() + 1)
+ }
+ } else {
+ if d.GetInt64() != math.MaxInt16 {
+ d.SetInt64(d.GetInt64() + 1)
+ }
+ }
+ case mysql.TypeLong:
+ if mysql.HasUnsignedFlag(retType.Flag) {
+ if d.GetUint64() != math.MaxUint32 {
+ d.SetUint64(d.GetUint64() + 1)
+ }
+ } else {
+ if d.GetInt64() != math.MaxInt32 {
+ d.SetInt64(d.GetInt64() + 1)
+ }
+ }
+ case mysql.TypeLonglong:
+ if mysql.HasUnsignedFlag(retType.Flag) {
+ if d.GetUint64() != math.MaxUint64 {
+ d.SetUint64(d.GetUint64() + 1)
+ }
+ } else {
+ if d.GetInt64() != math.MaxInt64 {
+ d.SetInt64(d.GetInt64() + 1)
+ }
+ }
+ case mysql.TypeFloat:
+ if d.GetFloat32() != math.MaxFloat32 {
+ d.SetFloat32(d.GetFloat32() + 1.0)
+ }
+ case mysql.TypeDouble:
+ if d.GetFloat64() != math.MaxFloat64 {
+ d.SetFloat64(d.GetFloat64() + 1.0)
+ }
+ case mysql.TypeNewDecimal:
+ if d.GetMysqlDecimal().Compare(NewMaxOrMinDec(false, retType.Flen, retType.Decimal)) != 0 {
+ var decimalOne, newD MyDecimal
+ one := decimalOne.FromInt(1)
+ err = DecimalAdd(d.GetMysqlDecimal(), one, &newD)
+ if err != nil {
+ return d, err
+ }
+ d = NewDecimalDatum(&newD)
+ }
+ }
+ }
+ return d, nil
+}
+
+const (
+ sizeOfEmptyDatum = int(unsafe.Sizeof(Datum{}))
+ sizeOfMysqlTime = int(unsafe.Sizeof(ZeroTime))
+ sizeOfMyDecimal = MyDecimalStructSize
+)
+
+// EstimatedMemUsage returns the estimated bytes consumed of a one-dimensional
+// or two-dimensional datum array.
+func EstimatedMemUsage(array []Datum, numOfRows int) int64 {
+ if numOfRows == 0 {
+ return 0
+ }
+ var bytesConsumed int
+ for _, d := range array {
+ switch d.Kind() {
+ case KindMysqlDecimal:
+ bytesConsumed += sizeOfMyDecimal
+ case KindMysqlTime:
+ bytesConsumed += sizeOfMysqlTime
+ default:
+ bytesConsumed += len(d.b)
+ }
+ }
+ bytesConsumed += len(array) * sizeOfEmptyDatum
+ return int64(bytesConsumed * numOfRows)
+}
diff --git a/pkg/types/enum.go b/pkg/types/enum.go
new file mode 100644
index 0000000000000000000000000000000000000000..53b756fcbc6e072ab015ea36ae4c521864e19e80
--- /dev/null
+++ b/pkg/types/enum.go
@@ -0,0 +1,80 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "strconv"
+
+ "github.com/pingcap/errors"
+ "matrixbase/pkg/util/collate"
+ "matrixbase/pkg/util/stringutil"
+)
+
+// Enum is for MySQL enum type.
+type Enum struct {
+ Name string
+ Value uint64
+}
+
+// Copy deep copy an Enum.
+func (e Enum) Copy() Enum {
+ return Enum{
+ Name: stringutil.Copy(e.Name),
+ Value: e.Value,
+ }
+}
+
+// String implements fmt.Stringer interface.
+func (e Enum) String() string {
+ return e.Name
+}
+
+// ToNumber changes enum index to float64 for numeric operation.
+func (e Enum) ToNumber() float64 {
+ return float64(e.Value)
+}
+
+// ParseEnum creates a Enum with item name or value.
+func ParseEnum(elems []string, name string, collation string) (Enum, error) {
+ if enumName, err := ParseEnumName(elems, name, collation); err == nil {
+ return enumName, nil
+ }
+ // name doesn't exist, maybe an integer?
+ if num, err := strconv.ParseUint(name, 0, 64); err == nil {
+ return ParseEnumValue(elems, num)
+ }
+
+ return Enum{}, errors.Errorf("item %s is not in enum %v", name, elems)
+}
+
+// ParseEnumName creates a Enum with item name.
+func ParseEnumName(elems []string, name string, collation string) (Enum, error) {
+ ctor := collate.GetCollator(collation)
+ for i, n := range elems {
+ if ctor.Compare(n, name) == 0 {
+ return Enum{Name: n, Value: uint64(i) + 1}, nil
+ }
+ }
+
+ return Enum{}, errors.Errorf("item %s is not in enum %v", name, elems)
+}
+
+// ParseEnumValue creates a Enum with special number.
+func ParseEnumValue(elems []string, number uint64) (Enum, error) {
+ if number == 0 || number > uint64(len(elems)) {
+ return Enum{}, errors.Errorf("number %d overflow enum boundary [1, %d]", number, len(elems))
+ }
+
+ return Enum{Name: elems[number-1], Value: number}, nil
+}
diff --git a/pkg/types/errors.go b/pkg/types/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..ac767fe56077014d8548cfa440ea3902d84a150c
--- /dev/null
+++ b/pkg/types/errors.go
@@ -0,0 +1,89 @@
+// Copyright 2016 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ parser_types "github.com/pingcap/parser/types"
+ mysql "matrixbase/pkg/errno"
+ "matrixbase/pkg/util/dbterror"
+)
+
+// const strings for ErrWrongValue
+const (
+ DateTimeStr = "datetime"
+ DateStr = "date"
+ TimeStr = "time"
+ TimestampStr = "timestamp"
+)
+
+var (
+ // ErrInvalidDefault is returned when meet a invalid default value.
+ ErrInvalidDefault = parser_types.ErrInvalidDefault
+ // ErrDataTooLong is returned when converts a string value that is longer than field type length.
+ ErrDataTooLong = dbterror.ClassTypes.NewStd(mysql.ErrDataTooLong)
+ // ErrIllegalValueForType is returned when value of type is illegal.
+ ErrIllegalValueForType = dbterror.ClassTypes.NewStd(mysql.ErrIllegalValueForType)
+ // ErrTruncated is returned when data has been truncated during conversion.
+ ErrTruncated = dbterror.ClassTypes.NewStd(mysql.WarnDataTruncated)
+ // ErrOverflow is returned when data is out of range for a field type.
+ ErrOverflow = dbterror.ClassTypes.NewStd(mysql.ErrDataOutOfRange)
+ // ErrDivByZero is return when do division by 0.
+ ErrDivByZero = dbterror.ClassTypes.NewStd(mysql.ErrDivisionByZero)
+ // ErrTooBigDisplayWidth is return when display width out of range for column.
+ ErrTooBigDisplayWidth = dbterror.ClassTypes.NewStd(mysql.ErrTooBigDisplaywidth)
+ // ErrTooBigFieldLength is return when column length too big for column.
+ ErrTooBigFieldLength = dbterror.ClassTypes.NewStd(mysql.ErrTooBigFieldlength)
+ // ErrTooBigSet is returned when too many strings for column.
+ ErrTooBigSet = dbterror.ClassTypes.NewStd(mysql.ErrTooBigSet)
+ // ErrTooBigScale is returned when type DECIMAL/NUMERIC scale is bigger than mysql.MaxDecimalScale.
+ ErrTooBigScale = dbterror.ClassTypes.NewStd(mysql.ErrTooBigScale)
+ // ErrTooBigPrecision is returned when type DECIMAL/NUMERIC precision is bigger than mysql.MaxDecimalWidth
+ ErrTooBigPrecision = dbterror.ClassTypes.NewStd(mysql.ErrTooBigPrecision)
+ // ErrBadNumber is return when parsing an invalid binary decimal number.
+ ErrBadNumber = dbterror.ClassTypes.NewStd(mysql.ErrBadNumber)
+ // ErrInvalidFieldSize is returned when the precision of a column is out of range.
+ ErrInvalidFieldSize = dbterror.ClassTypes.NewStd(mysql.ErrInvalidFieldSize)
+ // ErrMBiggerThanD is returned when precision less than the scale.
+ ErrMBiggerThanD = dbterror.ClassTypes.NewStd(mysql.ErrMBiggerThanD)
+ // ErrWarnDataOutOfRange is returned when the value in a numeric column that is outside the permissible range of the column data type.
+ // See https://dev.mysql.com/doc/refman/5.5/en/out-of-range-and-overflow.html for details
+ ErrWarnDataOutOfRange = dbterror.ClassTypes.NewStd(mysql.ErrWarnDataOutOfRange)
+ // ErrDuplicatedValueInType is returned when enum column has duplicated value.
+ ErrDuplicatedValueInType = dbterror.ClassTypes.NewStd(mysql.ErrDuplicatedValueInType)
+ // ErrDatetimeFunctionOverflow is returned when the calculation in datetime function cause overflow.
+ ErrDatetimeFunctionOverflow = dbterror.ClassTypes.NewStd(mysql.ErrDatetimeFunctionOverflow)
+ // ErrCastAsSignedOverflow is returned when positive out-of-range integer, and convert to it's negative complement.
+ ErrCastAsSignedOverflow = dbterror.ClassTypes.NewStd(mysql.ErrCastAsSignedOverflow)
+ // ErrCastNegIntAsUnsigned is returned when a negative integer be casted to an unsigned int.
+ ErrCastNegIntAsUnsigned = dbterror.ClassTypes.NewStd(mysql.ErrCastNegIntAsUnsigned)
+ // ErrInvalidYearFormat is returned when the input is not a valid year format.
+ ErrInvalidYearFormat = dbterror.ClassTypes.NewStd(mysql.ErrInvalidYearFormat)
+ // ErrInvalidYear is returned when the input value is not a valid year.
+ ErrInvalidYear = dbterror.ClassTypes.NewStd(mysql.ErrInvalidYear)
+ // ErrTruncatedWrongVal is returned when data has been truncated during conversion.
+ ErrTruncatedWrongVal = dbterror.ClassTypes.NewStd(mysql.ErrTruncatedWrongValue)
+ // ErrInvalidWeekModeFormat is returned when the week mode is wrong.
+ ErrInvalidWeekModeFormat = dbterror.ClassTypes.NewStd(mysql.ErrInvalidWeekModeFormat)
+ // ErrWrongFieldSpec is returned when the column specifier incorrect.
+ ErrWrongFieldSpec = dbterror.ClassTypes.NewStd(mysql.ErrWrongFieldSpec)
+ // ErrSyntax is returned when the syntax is not allowed.
+ ErrSyntax = dbterror.ClassTypes.NewStdErr(mysql.ErrParse, mysql.MySQLErrName[mysql.ErrSyntax])
+ // ErrWrongValue is returned when the input value is in wrong format.
+ ErrWrongValue = dbterror.ClassTypes.NewStdErr(mysql.ErrTruncatedWrongValue, mysql.MySQLErrName[mysql.ErrWrongValue])
+ // ErrWrongValueForType is returned when the input value is in wrong format for function.
+ ErrWrongValueForType = dbterror.ClassTypes.NewStdErr(mysql.ErrWrongValueForType, mysql.MySQLErrName[mysql.ErrWrongValueForType])
+ // ErrPartitionStatsMissing is returned when the partition-level stats is missing and the build global-level stats fails.
+ // Put this error here is to prevent `import cycle not allowed`.
+ ErrPartitionStatsMissing = dbterror.ClassTypes.NewStd(mysql.ErrPartitionStatsMissing)
+)
diff --git a/pkg/types/etc.go b/pkg/types/etc.go
new file mode 100644
index 0000000000000000000000000000000000000000..d2d428e291bd167f65499be6f7441659875369d0
--- /dev/null
+++ b/pkg/types/etc.go
@@ -0,0 +1,188 @@
+// Copyright 2014 The ql Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSES/QL-LICENSE file.
+
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "io"
+
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser/charset"
+ "github.com/pingcap/parser/mysql"
+ "github.com/pingcap/parser/opcode"
+ "github.com/pingcap/parser/terror"
+ ast "github.com/pingcap/parser/types"
+ "matrixbase/pkg/util/collate"
+)
+
+// IsTypeBlob returns a boolean indicating whether the tp is a blob type.
+var IsTypeBlob = ast.IsTypeBlob
+
+// IsTypeChar returns a boolean indicating
+// whether the tp is the char type like a string type or a varchar type.
+var IsTypeChar = ast.IsTypeChar
+
+// IsTypeVarchar returns a boolean indicating
+// whether the tp is the varchar type like a varstring type or a varchar type.
+func IsTypeVarchar(tp byte) bool {
+ return tp == mysql.TypeVarString || tp == mysql.TypeVarchar
+}
+
+// IsTypeUnspecified returns a boolean indicating whether the tp is the Unspecified type.
+func IsTypeUnspecified(tp byte) bool {
+ return tp == mysql.TypeUnspecified
+}
+
+// IsTypePrefixable returns a boolean indicating
+// whether an index on a column with the tp can be defined with a prefix.
+func IsTypePrefixable(tp byte) bool {
+ return IsTypeBlob(tp) || IsTypeChar(tp)
+}
+
+// IsTypeFractionable returns a boolean indicating
+// whether the tp can has time fraction.
+func IsTypeFractionable(tp byte) bool {
+ return tp == mysql.TypeDatetime || tp == mysql.TypeDuration || tp == mysql.TypeTimestamp
+}
+
+// IsTypeTime returns a boolean indicating
+// whether the tp is time type like datetime, date or timestamp.
+func IsTypeTime(tp byte) bool {
+ return tp == mysql.TypeDatetime || tp == mysql.TypeDate || tp == mysql.TypeTimestamp
+}
+
+// IsTypeInteger returns a boolean indicating whether the tp is integer type.
+func IsTypeInteger(tp byte) bool {
+ switch tp {
+ case mysql.TypeTiny, mysql.TypeShort, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong, mysql.TypeYear:
+ return true
+ }
+ return false
+}
+
+// IsTypeNumeric returns a boolean indicating whether the tp is numeric type.
+func IsTypeNumeric(tp byte) bool {
+ switch tp {
+ case mysql.TypeBit, mysql.TypeTiny, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong, mysql.TypeNewDecimal,
+ mysql.TypeFloat, mysql.TypeDouble, mysql.TypeShort:
+ return true
+ }
+ return false
+}
+
+// IsTemporalWithDate returns a boolean indicating
+// whether the tp is time type with date.
+func IsTemporalWithDate(tp byte) bool {
+ return IsTypeTime(tp)
+}
+
+// IsBinaryStr returns a boolean indicating
+// whether the field type is a binary string type.
+func IsBinaryStr(ft *FieldType) bool {
+ return ft.Collate == charset.CollationBin && IsString(ft.Tp)
+}
+
+// IsNonBinaryStr returns a boolean indicating
+// whether the field type is a non-binary string type.
+func IsNonBinaryStr(ft *FieldType) bool {
+ if ft.Collate != charset.CollationBin && IsString(ft.Tp) {
+ return true
+ }
+ return false
+}
+
+// NeedRestoredData returns if a type needs restored data.
+// If the type is char and the collation is _bin, NeedRestoredData() returns false.
+func NeedRestoredData(ft *FieldType) bool {
+ if IsNonBinaryStr(ft) && !(collate.IsBinCollation(ft.Collate) && !IsTypeVarchar(ft.Tp)) {
+ return true
+ }
+ return false
+}
+
+// IsString returns a boolean indicating
+// whether the field type is a string type.
+func IsString(tp byte) bool {
+ return IsTypeChar(tp) || IsTypeBlob(tp) || IsTypeVarchar(tp) || IsTypeUnspecified(tp)
+}
+
+var kind2Str = map[byte]string{
+ KindNull: "null",
+ KindInt64: "bigint",
+ KindUint64: "unsigned bigint",
+ KindFloat32: "float",
+ KindFloat64: "double",
+ KindString: "char",
+ KindBytes: "bytes",
+ KindBinaryLiteral: "bit/hex literal",
+ KindMysqlDecimal: "decimal",
+ KindMysqlDuration: "time",
+ KindMysqlEnum: "enum",
+ KindMysqlBit: "bit",
+ KindMysqlSet: "set",
+ KindMysqlTime: "datetime",
+ KindInterface: "interface",
+ KindMinNotNull: "min_not_null",
+ KindMaxValue: "max_value",
+ KindRaw: "raw",
+ KindMysqlJSON: "json",
+}
+
+// TypeStr converts tp to a string.
+var TypeStr = ast.TypeStr
+
+// KindStr converts kind to a string.
+func KindStr(kind byte) (r string) {
+ return kind2Str[kind]
+}
+
+// TypeToStr converts a field to a string.
+// It is used for converting Text to Blob,
+// or converting Char to Binary.
+// Args:
+// tp: type enum
+// cs: charset
+var TypeToStr = ast.TypeToStr
+
+// EOFAsNil filtrates errors,
+// If err is equal to io.EOF returns nil.
+func EOFAsNil(err error) error {
+ if terror.ErrorEqual(err, io.EOF) {
+ return nil
+ }
+ return errors.Trace(err)
+}
+
+// InvOp2 returns an invalid operation error.
+func InvOp2(x, y interface{}, o opcode.Op) (interface{}, error) {
+ return nil, errors.Errorf("Invalid operation: %v %v %v (mismatched types %T and %T)", x, o, y, x, y)
+}
+
+// overflow returns an overflowed error.
+func overflow(v interface{}, tp byte) error {
+ return ErrOverflow.GenWithStack("constant %v overflows %s", v, TypeStr(tp))
+}
+
+// IsTypeTemporal checks if a type is a temporal type.
+func IsTypeTemporal(tp byte) bool {
+ switch tp {
+ case mysql.TypeDuration, mysql.TypeDatetime, mysql.TypeTimestamp,
+ mysql.TypeDate, mysql.TypeNewDate:
+ return true
+ }
+ return false
+}
diff --git a/pkg/types/eval_type.go b/pkg/types/eval_type.go
new file mode 100644
index 0000000000000000000000000000000000000000..3eb17cae856f9738890b11084690b3a0fbbbb925
--- /dev/null
+++ b/pkg/types/eval_type.go
@@ -0,0 +1,38 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import ast "github.com/pingcap/parser/types"
+
+// EvalType indicates the specified types that arguments and result of a built-in function should be.
+type EvalType = ast.EvalType
+
+const (
+ // ETInt represents type INT in evaluation.
+ ETInt = ast.ETInt
+ // ETReal represents type REAL in evaluation.
+ ETReal = ast.ETReal
+ // ETDecimal represents type DECIMAL in evaluation.
+ ETDecimal = ast.ETDecimal
+ // ETString represents type STRING in evaluation.
+ ETString = ast.ETString
+ // ETDatetime represents type DATETIME in evaluation.
+ ETDatetime = ast.ETDatetime
+ // ETTimestamp represents type TIMESTAMP in evaluation.
+ ETTimestamp = ast.ETTimestamp
+ // ETDuration represents type DURATION in evaluation.
+ ETDuration = ast.ETDuration
+ // ETJson represents type JSON in evaluation.
+ ETJson = ast.ETJson
+)
diff --git a/pkg/types/field_type.go b/pkg/types/field_type.go
new file mode 100644
index 0000000000000000000000000000000000000000..5ee9ec34ed4e266f4d04c2dfb8372c4fba984fde
--- /dev/null
+++ b/pkg/types/field_type.go
@@ -0,0 +1,1305 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "strconv"
+
+ "github.com/pingcap/parser/charset"
+ "github.com/pingcap/parser/mysql"
+ ast "github.com/pingcap/parser/types"
+ "matrixbase/pkg/types/json"
+ "matrixbase/pkg/util/collate"
+ utilMath "matrixbase/pkg/util/math"
+)
+
+// UnspecifiedLength is unspecified length.
+const UnspecifiedLength = -1
+
+// ErrorLength is error length for blob or text.
+const ErrorLength = 0
+
+// FieldType records field type information.
+type FieldType = ast.FieldType
+
+// NewFieldType returns a FieldType,
+// with a type and other information about field type.
+func NewFieldType(tp byte) *FieldType {
+ ft := &FieldType{
+ Tp: tp,
+ Flen: UnspecifiedLength,
+ Decimal: UnspecifiedLength,
+ }
+ if tp != mysql.TypeVarchar && tp != mysql.TypeVarString && tp != mysql.TypeString {
+ ft.Collate = charset.CollationBin
+ } else {
+ ft.Collate = mysql.DefaultCollationName
+ }
+ // TODO: use DefaultCharsetForType to set charset and collate
+ return ft
+}
+
+// NewFieldTypeWithCollation returns a FieldType,
+// with a type and other information about field type.
+func NewFieldTypeWithCollation(tp byte, collation string, length int) *FieldType {
+ return &FieldType{
+ Tp: tp,
+ Flen: length,
+ Decimal: UnspecifiedLength,
+ Collate: collation,
+ }
+}
+
+// AggFieldType aggregates field types for a multi-argument function like `IF`, `IFNULL`, `COALESCE`
+// whose return type is determined by the arguments' FieldTypes.
+// Aggregation is performed by MergeFieldType function.
+func AggFieldType(tps []*FieldType) *FieldType {
+ var currType FieldType
+ isMixedSign := false
+ for i, t := range tps {
+ if i == 0 && currType.Tp == mysql.TypeUnspecified {
+ currType = *t
+ continue
+ }
+ mtp := MergeFieldType(currType.Tp, t.Tp)
+ isMixedSign = isMixedSign || (mysql.HasUnsignedFlag(currType.Flag) != mysql.HasUnsignedFlag(t.Flag))
+ currType.Tp = mtp
+ currType.Flag = mergeTypeFlag(currType.Flag, t.Flag)
+ }
+ // integral promotion when tps contains signed and unsigned
+ if isMixedSign && IsTypeInteger(currType.Tp) {
+ bumpRange := false // indicate one of tps bump currType range
+ for _, t := range tps {
+ bumpRange = bumpRange || (mysql.HasUnsignedFlag(t.Flag) && (t.Tp == currType.Tp || t.Tp == mysql.TypeBit))
+ }
+ if bumpRange {
+ switch currType.Tp {
+ case mysql.TypeTiny:
+ currType.Tp = mysql.TypeShort
+ case mysql.TypeShort:
+ currType.Tp = mysql.TypeInt24
+ case mysql.TypeInt24:
+ currType.Tp = mysql.TypeLong
+ case mysql.TypeLong:
+ currType.Tp = mysql.TypeLonglong
+ case mysql.TypeLonglong:
+ currType.Tp = mysql.TypeNewDecimal
+ }
+ }
+ }
+
+ if mysql.HasUnsignedFlag(currType.Flag) && !isMixedSign {
+ currType.Flag |= mysql.UnsignedFlag
+ }
+
+ return &currType
+}
+
+// AggregateEvalType aggregates arguments' EvalType of a multi-argument function.
+func AggregateEvalType(fts []*FieldType, flag *uint) EvalType {
+ var (
+ aggregatedEvalType = ETString
+ unsigned bool
+ gotFirst bool
+ gotBinString bool
+ )
+ lft := fts[0]
+ for _, ft := range fts {
+ if ft.Tp == mysql.TypeNull {
+ continue
+ }
+ et := ft.EvalType()
+ rft := ft
+ if (IsTypeBlob(ft.Tp) || IsTypeVarchar(ft.Tp) || IsTypeChar(ft.Tp)) && mysql.HasBinaryFlag(ft.Flag) {
+ gotBinString = true
+ }
+ if !gotFirst {
+ gotFirst = true
+ aggregatedEvalType = et
+ unsigned = mysql.HasUnsignedFlag(ft.Flag)
+ } else {
+ aggregatedEvalType = mergeEvalType(aggregatedEvalType, et, lft, rft, unsigned, mysql.HasUnsignedFlag(ft.Flag))
+ unsigned = unsigned && mysql.HasUnsignedFlag(ft.Flag)
+ }
+ lft = rft
+ }
+ SetTypeFlag(flag, mysql.UnsignedFlag, unsigned)
+ SetTypeFlag(flag, mysql.BinaryFlag, !aggregatedEvalType.IsStringKind() || gotBinString)
+ return aggregatedEvalType
+}
+
+func mergeEvalType(lhs, rhs EvalType, lft, rft *FieldType, isLHSUnsigned, isRHSUnsigned bool) EvalType {
+ if lft.Tp == mysql.TypeUnspecified || rft.Tp == mysql.TypeUnspecified {
+ if lft.Tp == rft.Tp {
+ return ETString
+ }
+ if lft.Tp == mysql.TypeUnspecified {
+ lhs = rhs
+ } else {
+ rhs = lhs
+ }
+ }
+ if lhs.IsStringKind() || rhs.IsStringKind() {
+ return ETString
+ } else if lhs == ETReal || rhs == ETReal {
+ return ETReal
+ } else if lhs == ETDecimal || rhs == ETDecimal || isLHSUnsigned != isRHSUnsigned {
+ return ETDecimal
+ }
+ return ETInt
+}
+
+// SetTypeFlag turns the flagItem on or off.
+func SetTypeFlag(flag *uint, flagItem uint, on bool) {
+ if on {
+ *flag |= flagItem
+ } else {
+ *flag &= ^flagItem
+ }
+}
+
+// DefaultParamTypeForValue returns the default FieldType for the parameterized value.
+func DefaultParamTypeForValue(value interface{}, tp *FieldType) {
+ switch value.(type) {
+ case nil:
+ tp.Tp = mysql.TypeVarString
+ tp.Flen = UnspecifiedLength
+ tp.Decimal = UnspecifiedLength
+ default:
+ DefaultTypeForValue(value, tp, mysql.DefaultCharset, mysql.DefaultCollationName)
+ if hasVariantFieldLength(tp) {
+ tp.Flen = UnspecifiedLength
+ }
+ if tp.Tp == mysql.TypeUnspecified {
+ tp.Tp = mysql.TypeVarString
+ }
+ }
+}
+
+func hasVariantFieldLength(tp *FieldType) bool {
+ switch tp.Tp {
+ case mysql.TypeLonglong, mysql.TypeVarString, mysql.TypeDouble, mysql.TypeBlob,
+ mysql.TypeBit, mysql.TypeDuration, mysql.TypeEnum, mysql.TypeSet:
+ return true
+ }
+ return false
+}
+
+// DefaultTypeForValue returns the default FieldType for the value.
+func DefaultTypeForValue(value interface{}, tp *FieldType, char string, collate string) {
+ switch x := value.(type) {
+ case nil:
+ tp.Tp = mysql.TypeNull
+ tp.Flen = 0
+ tp.Decimal = 0
+ SetBinChsClnFlag(tp)
+ case bool:
+ tp.Tp = mysql.TypeLonglong
+ tp.Flen = 1
+ tp.Decimal = 0
+ tp.Flag |= mysql.IsBooleanFlag
+ SetBinChsClnFlag(tp)
+ case int:
+ tp.Tp = mysql.TypeLonglong
+ tp.Flen = utilMath.StrLenOfInt64Fast(int64(x))
+ tp.Decimal = 0
+ SetBinChsClnFlag(tp)
+ case int64:
+ tp.Tp = mysql.TypeLonglong
+ tp.Flen = utilMath.StrLenOfInt64Fast(x)
+ tp.Decimal = 0
+ SetBinChsClnFlag(tp)
+ case uint64:
+ tp.Tp = mysql.TypeLonglong
+ tp.Flag |= mysql.UnsignedFlag
+ tp.Flen = utilMath.StrLenOfUint64Fast(x)
+ tp.Decimal = 0
+ SetBinChsClnFlag(tp)
+ case string:
+ tp.Tp = mysql.TypeVarString
+ // TODO: tp.Flen should be len(x) * 3 (max bytes length of CharsetUTF8)
+ tp.Flen = len(x)
+ tp.Decimal = UnspecifiedLength
+ tp.Charset, tp.Collate = char, collate
+ case float32:
+ tp.Tp = mysql.TypeFloat
+ s := strconv.FormatFloat(float64(x), 'f', -1, 32)
+ tp.Flen = len(s)
+ tp.Decimal = UnspecifiedLength
+ SetBinChsClnFlag(tp)
+ case float64:
+ tp.Tp = mysql.TypeDouble
+ s := strconv.FormatFloat(x, 'f', -1, 64)
+ tp.Flen = len(s)
+ tp.Decimal = UnspecifiedLength
+ SetBinChsClnFlag(tp)
+ case []byte:
+ tp.Tp = mysql.TypeBlob
+ tp.Flen = len(x)
+ tp.Decimal = UnspecifiedLength
+ SetBinChsClnFlag(tp)
+ case BitLiteral:
+ tp.Tp = mysql.TypeVarString
+ tp.Flen = len(x)
+ tp.Decimal = 0
+ SetBinChsClnFlag(tp)
+ case HexLiteral:
+ tp.Tp = mysql.TypeVarString
+ tp.Flen = len(x) * 3
+ tp.Decimal = 0
+ tp.Flag |= mysql.UnsignedFlag
+ SetBinChsClnFlag(tp)
+ case BinaryLiteral:
+ tp.Tp = mysql.TypeBit
+ tp.Flen = len(x) * 8
+ tp.Decimal = 0
+ SetBinChsClnFlag(tp)
+ tp.Flag &= ^mysql.BinaryFlag
+ tp.Flag |= mysql.UnsignedFlag
+ case Time:
+ tp.Tp = x.Type()
+ switch x.Type() {
+ case mysql.TypeDate:
+ tp.Flen = mysql.MaxDateWidth
+ tp.Decimal = UnspecifiedLength
+ case mysql.TypeDatetime, mysql.TypeTimestamp:
+ tp.Flen = mysql.MaxDatetimeWidthNoFsp
+ if x.Fsp() > DefaultFsp { // consider point('.') and the fractional part.
+ tp.Flen += int(x.Fsp()) + 1
+ }
+ tp.Decimal = int(x.Fsp())
+ }
+ SetBinChsClnFlag(tp)
+ case Duration:
+ tp.Tp = mysql.TypeDuration
+ tp.Flen = len(x.String())
+ if x.Fsp > DefaultFsp { // consider point('.') and the fractional part.
+ tp.Flen = int(x.Fsp) + 1
+ }
+ tp.Decimal = int(x.Fsp)
+ SetBinChsClnFlag(tp)
+ case *MyDecimal:
+ tp.Tp = mysql.TypeNewDecimal
+ tp.Flen = len(x.ToString())
+ tp.Decimal = int(x.digitsFrac)
+ SetBinChsClnFlag(tp)
+ case Enum:
+ tp.Tp = mysql.TypeEnum
+ tp.Flen = len(x.Name)
+ tp.Decimal = UnspecifiedLength
+ SetBinChsClnFlag(tp)
+ case Set:
+ tp.Tp = mysql.TypeSet
+ tp.Flen = len(x.Name)
+ tp.Decimal = UnspecifiedLength
+ SetBinChsClnFlag(tp)
+ case json.BinaryJSON:
+ tp.Tp = mysql.TypeJSON
+ tp.Flen = UnspecifiedLength
+ tp.Decimal = 0
+ tp.Charset = charset.CharsetUTF8MB4
+ tp.Collate = charset.CollationUTF8MB4
+ default:
+ tp.Tp = mysql.TypeUnspecified
+ tp.Flen = UnspecifiedLength
+ tp.Decimal = UnspecifiedLength
+ }
+}
+
+// DefaultCharsetForType returns the default charset/collation for mysql type.
+func DefaultCharsetForType(tp byte) (string, string) {
+ switch tp {
+ case mysql.TypeVarString, mysql.TypeString, mysql.TypeVarchar:
+ // Default charset for string types is utf8mb4.
+ return mysql.DefaultCharset, mysql.DefaultCollationName
+ }
+ return charset.CharsetBin, charset.CollationBin
+}
+
+// MergeFieldType merges two MySQL type to a new type.
+// This is used in hybrid field type expression.
+// For example "select case c when 1 then 2 when 2 then 'tidb' from t;"
+// The result field type of the case expression is the merged type of the two when clause.
+// See https://github.com/mysql/mysql-server/blob/5.7/sql/field.cc#L1042
+func MergeFieldType(a byte, b byte) byte {
+ ia := getFieldTypeIndex(a)
+ ib := getFieldTypeIndex(b)
+ return fieldTypeMergeRules[ia][ib]
+}
+
+// mergeTypeFlag merges two MySQL type flag to a new one
+// currently only NotNullFlag and UnsignedFlag is checked
+// todo more flag need to be checked
+func mergeTypeFlag(a, b uint) uint {
+ return a & (b&mysql.NotNullFlag | ^mysql.NotNullFlag) & (b&mysql.UnsignedFlag | ^mysql.UnsignedFlag)
+}
+
+func getFieldTypeIndex(tp byte) int {
+ itp := int(tp)
+ if itp < fieldTypeTearFrom {
+ return itp
+ }
+ return fieldTypeTearFrom + itp - fieldTypeTearTo - 1
+}
+
+const (
+ fieldTypeTearFrom = int(mysql.TypeBit) + 1
+ fieldTypeTearTo = int(mysql.TypeJSON) - 1
+ fieldTypeNum = fieldTypeTearFrom + (255 - fieldTypeTearTo)
+)
+
+var fieldTypeMergeRules = [fieldTypeNum][fieldTypeNum]byte{
+ /* mysql.TypeUnspecified -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeNewDecimal, mysql.TypeNewDecimal,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeNewDecimal, mysql.TypeNewDecimal,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeDouble, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeUnspecified, mysql.TypeUnspecified,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeTiny -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeNewDecimal, mysql.TypeTiny,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeShort, mysql.TypeLong,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeFloat, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeTiny, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeLonglong, mysql.TypeInt24,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeTiny,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeShort -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeNewDecimal, mysql.TypeShort,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeShort, mysql.TypeLong,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeFloat, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeShort, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeLonglong, mysql.TypeInt24,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeShort,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeLong -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeNewDecimal, mysql.TypeLong,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeLong, mysql.TypeLong,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeDouble, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeLong, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeLonglong, mysql.TypeLong,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeLong,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeFloat -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeDouble, mysql.TypeFloat,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeFloat, mysql.TypeDouble,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeFloat, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeFloat, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeFloat, mysql.TypeFloat,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeFloat,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeDouble, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeDouble -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeDouble, mysql.TypeDouble,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeDouble, mysql.TypeDouble,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeDouble, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeDouble, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeDouble, mysql.TypeDouble,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeDouble,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeDouble, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeNull -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeNewDecimal, mysql.TypeTiny,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeShort, mysql.TypeLong,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeFloat, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeNull, mysql.TypeTimestamp,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeLonglong, mysql.TypeLonglong,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeDate, mysql.TypeDuration,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeDatetime, mysql.TypeYear,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeNewDate, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeBit,
+ // mysql.TypeJSON
+ mysql.TypeJSON,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeNewDecimal, mysql.TypeEnum,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeSet, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeGeometry,
+ },
+ /* mysql.TypeTimestamp -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeTimestamp, mysql.TypeTimestamp,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeDatetime, mysql.TypeDatetime,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeDatetime, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeNewDate, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeLonglong -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeNewDecimal, mysql.TypeLonglong,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeLonglong, mysql.TypeLonglong,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeDouble, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeLonglong, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeLonglong, mysql.TypeLong,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeLonglong,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeNewDate, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeInt24 -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeNewDecimal, mysql.TypeInt24,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeInt24, mysql.TypeLong,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeFloat, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeInt24, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeLonglong, mysql.TypeInt24,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeInt24,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeNewDate, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeDate -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeDate, mysql.TypeDatetime,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeDate, mysql.TypeDatetime,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeDatetime, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeNewDate, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeTime -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeDuration, mysql.TypeDatetime,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeDatetime, mysql.TypeDuration,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeDatetime, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeNewDate, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeDatetime -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeDatetime, mysql.TypeDatetime,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeDatetime, mysql.TypeDatetime,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeDatetime, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeNewDate, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeYear -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeUnspecified, mysql.TypeTiny,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeShort, mysql.TypeLong,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeFloat, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeYear, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeLonglong, mysql.TypeInt24,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeYear,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeNewDate -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeNewDate, mysql.TypeDatetime,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeNewDate, mysql.TypeDatetime,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeDatetime, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeNewDate, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeVarchar -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ },
+ /* mysql.TypeBit -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeBit, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeBit,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeJSON -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNewFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeJSON, mysql.TypeVarchar,
+ // mysql.TypeLongLONG mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate MYSQL_TYPE_TIME
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime MYSQL_TYPE_YEAR
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeJSON,
+ // mysql.TypeNewDecimal MYSQL_TYPE_ENUM
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeLongBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeLongBlob, mysql.TypeVarchar,
+ // mysql.TypeString MYSQL_TYPE_GEOMETRY
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeNewDecimal -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeNewDecimal, mysql.TypeNewDecimal,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeNewDecimal, mysql.TypeNewDecimal,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeDouble, mysql.TypeDouble,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeNewDecimal, mysql.TypeNewDecimal,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeNewDecimal,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeNewDecimal, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeEnum -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeEnum, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeSet -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeSet, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeVarchar,
+ },
+ /* mysql.TypeTinyBlob -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeTinyBlob,
+ // mysql.TypeJSON
+ mysql.TypeLongBlob,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeTinyBlob,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeTinyBlob, mysql.TypeTinyBlob,
+ },
+ /* mysql.TypeMediumBlob -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeMediumBlob,
+ // mysql.TypeJSON
+ mysql.TypeLongBlob,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeMediumBlob, mysql.TypeMediumBlob,
+ },
+ /* mysql.TypeLongBlob -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeLongBlob,
+ // mysql.TypeJSON
+ mysql.TypeLongBlob,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeLongBlob, mysql.TypeLongBlob,
+ },
+ /* mysql.TypeBlob -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeBlob,
+ // mysql.TypeJSON
+ mysql.TypeLongBlob,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeBlob,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeBlob, mysql.TypeBlob,
+ },
+ /* mysql.TypeVarString -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ },
+ /* mysql.TypeString -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeString, mysql.TypeString,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeString, mysql.TypeString,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeString, mysql.TypeString,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeString, mysql.TypeString,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeString, mysql.TypeString,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeString, mysql.TypeString,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeString, mysql.TypeString,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeString, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeString,
+ // mysql.TypeJSON
+ mysql.TypeString,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeString, mysql.TypeString,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeString, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeString,
+ },
+ /* mysql.TypeGeometry -> */
+ {
+ // mysql.TypeUnspecified mysql.TypeTiny
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeShort mysql.TypeLong
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeFloat mysql.TypeDouble
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNull mysql.TypeTimestamp
+ mysql.TypeGeometry, mysql.TypeVarchar,
+ // mysql.TypeLonglong mysql.TypeInt24
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDate mysql.TypeTime
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeDatetime mysql.TypeYear
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeNewDate mysql.TypeVarchar
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeBit <16>-<244>
+ mysql.TypeVarchar,
+ // mysql.TypeJSON
+ mysql.TypeVarchar,
+ // mysql.TypeNewDecimal mysql.TypeEnum
+ mysql.TypeVarchar, mysql.TypeVarchar,
+ // mysql.TypeSet mysql.TypeTinyBlob
+ mysql.TypeVarchar, mysql.TypeTinyBlob,
+ // mysql.TypeMediumBlob mysql.TypeLongBlob
+ mysql.TypeMediumBlob, mysql.TypeLongBlob,
+ // mysql.TypeBlob mysql.TypeVarString
+ mysql.TypeBlob, mysql.TypeVarchar,
+ // mysql.TypeString mysql.TypeGeometry
+ mysql.TypeString, mysql.TypeGeometry,
+ },
+}
+
+// SetBinChsClnFlag sets charset, collation as 'binary' and adds binaryFlag to FieldType.
+func SetBinChsClnFlag(ft *FieldType) {
+ ft.Charset = charset.CharsetBin
+ ft.Collate = charset.CollationBin
+ ft.Flag |= mysql.BinaryFlag
+}
+
+// VarStorageLen indicates this column is a variable length column.
+const VarStorageLen = ast.VarStorageLen
+
+// CommonHandleNeedRestoredData indicates whether the column can be decoded directly from the common handle.
+// If can, then returns false. Otherwise returns true.
+func CommonHandleNeedRestoredData(ft *FieldType) bool {
+ return collate.NewCollationEnabled() &&
+ ft.EvalType() == ETString &&
+ !mysql.HasBinaryFlag(ft.Flag)
+}
diff --git a/pkg/types/fsp.go b/pkg/types/fsp.go
new file mode 100644
index 0000000000000000000000000000000000000000..a3b15c61389b6f9adf704b39271df377bfa0970d
--- /dev/null
+++ b/pkg/types/fsp.go
@@ -0,0 +1,102 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "math"
+ "strconv"
+ "strings"
+
+ "github.com/pingcap/errors"
+)
+
+const (
+ // UnspecifiedFsp is the unspecified fractional seconds part.
+ UnspecifiedFsp = int8(-1)
+ // MaxFsp is the maximum digit of fractional seconds part.
+ MaxFsp = int8(6)
+ // MinFsp is the minimum digit of fractional seconds part.
+ MinFsp = int8(0)
+ // DefaultFsp is the default digit of fractional seconds part.
+ // MySQL use 0 as the default Fsp.
+ DefaultFsp = int8(0)
+)
+
+// CheckFsp checks whether fsp is in valid range.
+func CheckFsp(fsp int) (int8, error) {
+ if fsp == int(UnspecifiedFsp) {
+ return DefaultFsp, nil
+ }
+ if fsp < int(MinFsp) {
+ return DefaultFsp, errors.Errorf("Invalid fsp %d", fsp)
+ } else if fsp > int(MaxFsp) {
+ return MaxFsp, nil
+ }
+ return int8(fsp), nil
+}
+
+// ParseFrac parses the input string according to fsp, returns the microsecond,
+// and also a bool value to indice overflow. eg:
+// "999" fsp=2 will overflow.
+func ParseFrac(s string, fsp int8) (v int, overflow bool, err error) {
+ if len(s) == 0 {
+ return 0, false, nil
+ }
+
+ fsp, err = CheckFsp(int(fsp))
+ if err != nil {
+ return 0, false, errors.Trace(err)
+ }
+
+ if int(fsp) >= len(s) {
+ tmp, e := strconv.ParseInt(s, 10, 64)
+ if e != nil {
+ return 0, false, errors.Trace(e)
+ }
+ v = int(float64(tmp) * math.Pow10(int(MaxFsp)-len(s)))
+ return
+ }
+
+ // Round when fsp < string length.
+ tmp, e := strconv.ParseInt(s[:fsp+1], 10, 64)
+ if e != nil {
+ return 0, false, errors.Trace(e)
+ }
+ tmp = (tmp + 5) / 10
+
+ if float64(tmp) >= math.Pow10(int(fsp)) {
+ // overflow
+ return 0, true, nil
+ }
+
+ // Get the final frac, with 6 digit number
+ // 1236 round 3 -> 124 -> 124000
+ // 0312 round 2 -> 3 -> 30000
+ // 999 round 2 -> 100 -> overflow
+ v = int(float64(tmp) * math.Pow10(int(MaxFsp-fsp)))
+ return
+}
+
+// alignFrac is used to generate alignment frac, like `100` -> `100000` ,`-100` -> `-100000`
+func alignFrac(s string, fsp int) string {
+ sl := len(s)
+ if sl > 0 && s[0] == '-' {
+ sl = sl - 1
+ }
+ if sl < fsp {
+ return s + strings.Repeat("0", fsp-sl)
+ }
+
+ return s
+}
diff --git a/pkg/types/helper.go b/pkg/types/helper.go
new file mode 100644
index 0000000000000000000000000000000000000000..e0ea721c53a966033bd82bebca240e07a484da81
--- /dev/null
+++ b/pkg/types/helper.go
@@ -0,0 +1,200 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "math"
+ "strings"
+ "unicode"
+
+ "github.com/pingcap/errors"
+)
+
+// RoundFloat rounds float val to the nearest even integer value with float64 format, like MySQL Round function.
+// RoundFloat uses default rounding mode, see https://dev.mysql.com/doc/refman/5.7/en/precision-math-rounding.html
+// so rounding use "round to nearest even".
+// e.g, 1.5 -> 2, -1.5 -> -2.
+func RoundFloat(f float64) float64 {
+ return math.RoundToEven(f)
+}
+
+// Round rounds the argument f to dec decimal places.
+// dec defaults to 0 if not specified. dec can be negative
+// to cause dec digits left of the decimal point of the
+// value f to become zero.
+func Round(f float64, dec int) float64 {
+ shift := math.Pow10(dec)
+ tmp := f * shift
+ if math.IsInf(tmp, 0) {
+ return f
+ }
+ result := RoundFloat(tmp) / shift
+ if math.IsNaN(result) {
+ return 0
+ }
+ return result
+}
+
+// Truncate truncates the argument f to dec decimal places.
+// dec defaults to 0 if not specified. dec can be negative
+// to cause dec digits left of the decimal point of the
+// value f to become zero.
+func Truncate(f float64, dec int) float64 {
+ shift := math.Pow10(dec)
+ tmp := f * shift
+ if math.IsInf(tmp, 0) {
+ return f
+ }
+ return math.Trunc(tmp) / shift
+}
+
+// GetMaxFloat gets the max float for given flen and decimal.
+func GetMaxFloat(flen int, decimal int) float64 {
+ intPartLen := flen - decimal
+ f := math.Pow10(intPartLen)
+ f -= math.Pow10(-decimal)
+ return f
+}
+
+// TruncateFloat tries to truncate f.
+// If the result exceeds the max/min float that flen/decimal allowed, returns the max/min float allowed.
+func TruncateFloat(f float64, flen int, decimal int) (float64, error) {
+ if math.IsNaN(f) {
+ // nan returns 0
+ return 0, ErrOverflow.GenWithStackByArgs("DOUBLE", "")
+ }
+
+ maxF := GetMaxFloat(flen, decimal)
+
+ if !math.IsInf(f, 0) {
+ f = Round(f, decimal)
+ }
+
+ var err error
+ if f > maxF {
+ f = maxF
+ err = ErrOverflow.GenWithStackByArgs("DOUBLE", "")
+ } else if f < -maxF {
+ f = -maxF
+ err = ErrOverflow.GenWithStackByArgs("DOUBLE", "")
+ }
+
+ return f, errors.Trace(err)
+}
+
+func isSpace(c byte) bool {
+ return c == ' ' || c == '\t'
+}
+
+func isDigit(c byte) bool {
+ return c >= '0' && c <= '9'
+}
+
+// Returns true if the given byte is an ASCII punctuation character (printable and non-alphanumeric).
+func isPunctuation(c byte) bool {
+ return (c >= 0x21 && c <= 0x2F) || (c >= 0x3A && c <= 0x40) || (c >= 0x5B && c <= 0x60) || (c >= 0x7B && c <= 0x7E)
+}
+
+func myMax(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func myMaxInt8(a, b int8) int8 {
+ if a > b {
+ return a
+ }
+ return b
+}
+
+func myMin(a, b int) int {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+func myMinInt8(a, b int8) int8 {
+ if a < b {
+ return a
+ }
+ return b
+}
+
+const (
+ maxUint = uint64(math.MaxUint64)
+ uintCutOff = maxUint/uint64(10) + 1
+ intCutOff = uint64(math.MaxInt64) + 1
+)
+
+// strToInt converts a string to an integer in best effort.
+func strToInt(str string) (int64, error) {
+ str = strings.TrimSpace(str)
+ if len(str) == 0 {
+ return 0, ErrTruncated
+ }
+ negative := false
+ i := 0
+ if str[i] == '-' {
+ negative = true
+ i++
+ } else if str[i] == '+' {
+ i++
+ }
+
+ var (
+ err error
+ hasNum = false
+ )
+ r := uint64(0)
+ for ; i < len(str); i++ {
+ if !unicode.IsDigit(rune(str[i])) {
+ err = ErrTruncated
+ break
+ }
+ hasNum = true
+ if r >= uintCutOff {
+ r = 0
+ err = errors.Trace(ErrBadNumber)
+ break
+ }
+ r = r * uint64(10)
+
+ r1 := r + uint64(str[i]-'0')
+ if r1 < r || r1 > maxUint {
+ r = 0
+ err = errors.Trace(ErrBadNumber)
+ break
+ }
+ r = r1
+ }
+ if !hasNum {
+ err = ErrTruncated
+ }
+
+ if !negative && r >= intCutOff {
+ return math.MaxInt64, errors.Trace(ErrBadNumber)
+ }
+
+ if negative && r > intCutOff {
+ return math.MinInt64, errors.Trace(ErrBadNumber)
+ }
+
+ if negative {
+ r = -r
+ }
+ return int64(r), err
+}
diff --git a/pkg/types/json/binary.go b/pkg/types/json/binary.go
new file mode 100644
index 0000000000000000000000000000000000000000..5c2d2b2d22d61dc5d1b5913395ea6a6554a1953e
--- /dev/null
+++ b/pkg/types/json/binary.go
@@ -0,0 +1,673 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package json
+
+import (
+ "bytes"
+ "encoding/binary"
+ "encoding/json"
+ "fmt"
+ "math"
+ "reflect"
+ "sort"
+ "strconv"
+ "strings"
+ "unicode/utf8"
+
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser/terror"
+ "matrixbase/pkg/util/hack"
+)
+
+/*
+ The binary JSON format from MySQL 5.7 is as follows:
+
+ JSON doc ::= type value
+ type ::=
+ 0x01 | // large JSON object
+ 0x03 | // large JSON array
+ 0x04 | // literal (true/false/null)
+ 0x05 | // int16
+ 0x06 | // uint16
+ 0x07 | // int32
+ 0x08 | // uint32
+ 0x09 | // int64
+ 0x0a | // uint64
+ 0x0b | // double
+ 0x0c | // utf8mb4 string
+
+ value ::=
+ object |
+ array |
+ literal |
+ number |
+ string |
+
+ object ::= element-count size key-entry* value-entry* key* value*
+
+ array ::= element-count size value-entry* value*
+
+ // number of members in object or number of elements in array
+ element-count ::= uint32
+
+ // number of bytes in the binary representation of the object or array
+ size ::= uint32
+
+ key-entry ::= key-offset key-length
+
+ key-offset ::= uint32
+
+ key-length ::= uint16 // key length must be less than 64KB
+
+ value-entry ::= type offset-or-inlined-value
+
+ // This field holds either the offset to where the value is stored,
+ // or the value itself if it is small enough to be inlined (that is,
+ // if it is a JSON literal or a small enough [u]int).
+ offset-or-inlined-value ::= uint32
+
+ key ::= utf8mb4-data
+
+ literal ::=
+ 0x00 | // JSON null literal
+ 0x01 | // JSON true literal
+ 0x02 | // JSON false literal
+
+ number ::= .... // little-endian format for [u]int(16|32|64), whereas
+ // double is stored in a platform-independent, eight-byte
+ // format using float8store()
+
+ string ::= data-length utf8mb4-data
+
+ data-length ::= uint8* // If the high bit of a byte is 1, the length
+ // field is continued in the next byte,
+ // otherwise it is the last byte of the length
+ // field. So we need 1 byte to represent
+ // lengths up to 127, 2 bytes to represent
+ // lengths up to 16383, and so on...
+*/
+
+// BinaryJSON represents a binary encoded JSON object.
+// It can be randomly accessed without deserialization.
+type BinaryJSON struct {
+ TypeCode TypeCode
+ Value []byte
+}
+
+// String implements fmt.Stringer interface.
+func (bj BinaryJSON) String() string {
+ out, err := bj.MarshalJSON()
+ terror.Log(err)
+ return string(out)
+}
+
+// Copy makes a copy of the BinaryJSON
+func (bj BinaryJSON) Copy() BinaryJSON {
+ buf := make([]byte, len(bj.Value))
+ copy(buf, bj.Value)
+ return BinaryJSON{TypeCode: bj.TypeCode, Value: buf}
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (bj BinaryJSON) MarshalJSON() ([]byte, error) {
+ buf := make([]byte, 0, len(bj.Value)*3/2)
+ return bj.marshalTo(buf)
+}
+
+func (bj BinaryJSON) marshalTo(buf []byte) ([]byte, error) {
+ switch bj.TypeCode {
+ case TypeCodeString:
+ return marshalStringTo(buf, bj.GetString()), nil
+ case TypeCodeLiteral:
+ return marshalLiteralTo(buf, bj.Value[0]), nil
+ case TypeCodeInt64:
+ return strconv.AppendInt(buf, bj.GetInt64(), 10), nil
+ case TypeCodeUint64:
+ return strconv.AppendUint(buf, bj.GetUint64(), 10), nil
+ case TypeCodeFloat64:
+ return bj.marshalFloat64To(buf)
+ case TypeCodeArray:
+ return bj.marshalArrayTo(buf)
+ case TypeCodeObject:
+ return bj.marshalObjTo(buf)
+ }
+ return buf, nil
+}
+
+// IsZero return a boolean indicate whether BinaryJSON is Zero
+func (bj BinaryJSON) IsZero() bool {
+ isZero := false
+ switch bj.TypeCode {
+ case TypeCodeString:
+ isZero = false
+ case TypeCodeLiteral:
+ isZero = false
+ case TypeCodeInt64:
+ isZero = bj.GetInt64() == 0
+ case TypeCodeUint64:
+ isZero = bj.GetUint64() == 0
+ case TypeCodeFloat64:
+ isZero = bj.GetFloat64() == 0
+ case TypeCodeArray:
+ isZero = false
+ case TypeCodeObject:
+ isZero = false
+ }
+ return isZero
+}
+
+// GetInt64 gets the int64 value.
+func (bj BinaryJSON) GetInt64() int64 {
+ return int64(endian.Uint64(bj.Value))
+}
+
+// GetUint64 gets the uint64 value.
+func (bj BinaryJSON) GetUint64() uint64 {
+ return endian.Uint64(bj.Value)
+}
+
+// GetFloat64 gets the float64 value.
+func (bj BinaryJSON) GetFloat64() float64 {
+ return math.Float64frombits(bj.GetUint64())
+}
+
+// GetString gets the string value.
+func (bj BinaryJSON) GetString() []byte {
+ strLen, lenLen := uint64(bj.Value[0]), 1
+ if strLen >= utf8.RuneSelf {
+ strLen, lenLen = binary.Uvarint(bj.Value)
+ }
+ return bj.Value[lenLen : lenLen+int(strLen)]
+}
+
+// GetKeys gets the keys of the object
+func (bj BinaryJSON) GetKeys() BinaryJSON {
+ count := bj.GetElemCount()
+ ret := make([]BinaryJSON, 0, count)
+ for i := 0; i < count; i++ {
+ ret = append(ret, CreateBinary(string(bj.objectGetKey(i))))
+ }
+ return buildBinaryArray(ret)
+}
+
+// GetElemCount gets the count of Object or Array.
+func (bj BinaryJSON) GetElemCount() int {
+ return int(endian.Uint32(bj.Value))
+}
+
+func (bj BinaryJSON) arrayGetElem(idx int) BinaryJSON {
+ return bj.valEntryGet(headerSize + idx*valEntrySize)
+}
+
+func (bj BinaryJSON) objectGetKey(i int) []byte {
+ keyOff := int(endian.Uint32(bj.Value[headerSize+i*keyEntrySize:]))
+ keyLen := int(endian.Uint16(bj.Value[headerSize+i*keyEntrySize+keyLenOff:]))
+ return bj.Value[keyOff : keyOff+keyLen]
+}
+
+func (bj BinaryJSON) objectGetVal(i int) BinaryJSON {
+ elemCount := bj.GetElemCount()
+ return bj.valEntryGet(headerSize + elemCount*keyEntrySize + i*valEntrySize)
+}
+
+func (bj BinaryJSON) valEntryGet(valEntryOff int) BinaryJSON {
+ tpCode := bj.Value[valEntryOff]
+ valOff := endian.Uint32(bj.Value[valEntryOff+valTypeSize:])
+ switch tpCode {
+ case TypeCodeLiteral:
+ return BinaryJSON{TypeCode: TypeCodeLiteral, Value: bj.Value[valEntryOff+valTypeSize : valEntryOff+valTypeSize+1]}
+ case TypeCodeUint64, TypeCodeInt64, TypeCodeFloat64:
+ return BinaryJSON{TypeCode: tpCode, Value: bj.Value[valOff : valOff+8]}
+ case TypeCodeString:
+ strLen, lenLen := uint64(bj.Value[valOff]), 1
+ if strLen >= utf8.RuneSelf {
+ strLen, lenLen = binary.Uvarint(bj.Value[valOff:])
+ }
+ totalLen := uint32(lenLen) + uint32(strLen)
+ return BinaryJSON{TypeCode: tpCode, Value: bj.Value[valOff : valOff+totalLen]}
+ }
+ dataSize := endian.Uint32(bj.Value[valOff+dataSizeOff:])
+ return BinaryJSON{TypeCode: tpCode, Value: bj.Value[valOff : valOff+dataSize]}
+}
+
+func (bj BinaryJSON) marshalFloat64To(buf []byte) ([]byte, error) {
+ // NOTE: copied from Go standard library.
+ f := bj.GetFloat64()
+ if math.IsInf(f, 0) || math.IsNaN(f) {
+ return buf, &json.UnsupportedValueError{Str: strconv.FormatFloat(f, 'g', -1, 64)}
+ }
+
+ // Convert as if by ES6 number to string conversion.
+ // This matches most other JSON generators.
+ // See golang.org/issue/6384 and golang.org/issue/14135.
+ // Like fmt %g, but the exponent cutoffs are different
+ // and exponents themselves are not padded to two digits.
+ abs := math.Abs(f)
+ ffmt := byte('f')
+ // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
+ if abs != 0 {
+ if abs < 1e-6 || abs >= 1e21 {
+ ffmt = 'e'
+ }
+ }
+ buf = strconv.AppendFloat(buf, f, ffmt, -1, 64)
+ if ffmt == 'e' {
+ // clean up e-09 to e-9
+ n := len(buf)
+ if n >= 4 && buf[n-4] == 'e' && buf[n-3] == '-' && buf[n-2] == '0' {
+ buf[n-2] = buf[n-1]
+ buf = buf[:n-1]
+ }
+ }
+ return buf, nil
+}
+
+func (bj BinaryJSON) marshalArrayTo(buf []byte) ([]byte, error) {
+ elemCount := int(endian.Uint32(bj.Value))
+ buf = append(buf, '[')
+ for i := 0; i < elemCount; i++ {
+ if i != 0 {
+ buf = append(buf, ", "...)
+ }
+ var err error
+ buf, err = bj.arrayGetElem(i).marshalTo(buf)
+ if err != nil {
+ return nil, errors.Trace(err)
+ }
+ }
+ return append(buf, ']'), nil
+}
+
+func (bj BinaryJSON) marshalObjTo(buf []byte) ([]byte, error) {
+ elemCount := int(endian.Uint32(bj.Value))
+ buf = append(buf, '{')
+ for i := 0; i < elemCount; i++ {
+ if i != 0 {
+ buf = append(buf, ", "...)
+ }
+ buf = marshalStringTo(buf, bj.objectGetKey(i))
+ buf = append(buf, ": "...)
+ var err error
+ buf, err = bj.objectGetVal(i).marshalTo(buf)
+ if err != nil {
+ return nil, errors.Trace(err)
+ }
+ }
+ return append(buf, '}'), nil
+}
+
+func marshalStringTo(buf, s []byte) []byte {
+ // NOTE: copied from Go standard library.
+ // NOTE: keep in sync with string above.
+ buf = append(buf, '"')
+ start := 0
+ for i := 0; i < len(s); {
+ if b := s[i]; b < utf8.RuneSelf {
+ if safeSet[b] {
+ i++
+ continue
+ }
+ if start < i {
+ buf = append(buf, s[start:i]...)
+ }
+ switch b {
+ case '\\', '"':
+ buf = append(buf, '\\', b)
+ case '\n':
+ buf = append(buf, '\\', 'n')
+ case '\r':
+ buf = append(buf, '\\', 'r')
+ case '\t':
+ buf = append(buf, '\\', 't')
+ default:
+ // This encodes bytes < 0x20 except for \t, \n and \r.
+ // If escapeHTML is set, it also escapes <, >, and &
+ // because they can lead to security holes when
+ // user-controlled strings are rendered into JSON
+ // and served to some browsers.
+ buf = append(buf, `\u00`...)
+ buf = append(buf, hexChars[b>>4], hexChars[b&0xF])
+ }
+ i++
+ start = i
+ continue
+ }
+ c, size := utf8.DecodeRune(s[i:])
+ if c == utf8.RuneError && size == 1 {
+ if start < i {
+ buf = append(buf, s[start:i]...)
+ }
+ buf = append(buf, `\ufffd`...)
+ i += size
+ start = i
+ continue
+ }
+ // U+2028 is LINE SEPARATOR.
+ // U+2029 is PARAGRAPH SEPARATOR.
+ // They are both technically valid characters in JSON strings,
+ // but don't work in JSONP, which has to be evaluated as JavaScript,
+ // and can lead to security holes there. It is valid JSON to
+ // escape them, so we do so unconditionally.
+ // See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+ if c == '\u2028' || c == '\u2029' {
+ if start < i {
+ buf = append(buf, s[start:i]...)
+ }
+ buf = append(buf, `\u202`...)
+ buf = append(buf, hexChars[c&0xF])
+ i += size
+ start = i
+ continue
+ }
+ i += size
+ }
+ if start < len(s) {
+ buf = append(buf, s[start:]...)
+ }
+ buf = append(buf, '"')
+ return buf
+}
+
+func marshalLiteralTo(b []byte, litType byte) []byte {
+ switch litType {
+ case LiteralFalse:
+ return append(b, "false"...)
+ case LiteralTrue:
+ return append(b, "true"...)
+ case LiteralNil:
+ return append(b, "null"...)
+ }
+ return b
+}
+
+// ParseBinaryFromString parses a json from string.
+func ParseBinaryFromString(s string) (bj BinaryJSON, err error) {
+ if len(s) == 0 {
+ err = ErrInvalidJSONText.GenWithStackByArgs("The document is empty")
+ return
+ }
+ data := hack.Slice(s)
+ if !json.Valid(data) {
+ err = ErrInvalidJSONText.GenWithStackByArgs("The document root must not be followed by other values.")
+ return
+ }
+ if err = bj.UnmarshalJSON(data); err != nil && !ErrJSONObjectKeyTooLong.Equal(err) {
+ err = ErrInvalidJSONText.GenWithStackByArgs(err)
+ }
+ return
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface.
+func (bj *BinaryJSON) UnmarshalJSON(data []byte) error {
+ var decoder = json.NewDecoder(bytes.NewReader(data))
+ decoder.UseNumber()
+ var in interface{}
+ err := decoder.Decode(&in)
+ if err != nil {
+ return errors.Trace(err)
+ }
+ buf := make([]byte, 0, len(data))
+ var typeCode TypeCode
+ typeCode, buf, err = appendBinary(buf, in)
+ if err != nil {
+ return errors.Trace(err)
+ }
+ bj.TypeCode = typeCode
+ bj.Value = buf
+ return nil
+}
+
+// HashValue converts certain JSON values for aggregate comparisons.
+// For example int64(3) == float64(3.0)
+func (bj BinaryJSON) HashValue(buf []byte) []byte {
+ switch bj.TypeCode {
+ case TypeCodeInt64:
+ // Convert to a FLOAT if no precision is lost.
+ // In the future, it will be better to convert to a DECIMAL value instead
+ // See: https://github.com/pingcap/tidb/issues/9988
+ if bj.GetInt64() == int64(float64(bj.GetInt64())) {
+ buf = appendBinaryFloat64(buf, float64(bj.GetInt64()))
+ } else {
+ buf = append(buf, bj.Value...)
+ }
+ case TypeCodeArray:
+ elemCount := int(endian.Uint32(bj.Value))
+ for i := 0; i < elemCount; i++ {
+ buf = bj.arrayGetElem(i).HashValue(buf)
+ }
+ case TypeCodeObject:
+ elemCount := int(endian.Uint32(bj.Value))
+ for i := 0; i < elemCount; i++ {
+ buf = append(buf, bj.objectGetKey(i)...)
+ buf = bj.objectGetVal(i).HashValue(buf)
+ }
+ default:
+ buf = append(buf, bj.Value...)
+ }
+ return buf
+}
+
+// CreateBinary creates a BinaryJSON from interface.
+func CreateBinary(in interface{}) BinaryJSON {
+ typeCode, buf, err := appendBinary(nil, in)
+ if err != nil {
+ panic(err)
+ }
+ return BinaryJSON{TypeCode: typeCode, Value: buf}
+}
+
+func appendBinary(buf []byte, in interface{}) (TypeCode, []byte, error) {
+ var typeCode byte
+ var err error
+ switch x := in.(type) {
+ case nil:
+ typeCode = TypeCodeLiteral
+ buf = append(buf, LiteralNil)
+ case bool:
+ typeCode = TypeCodeLiteral
+ if x {
+ buf = append(buf, LiteralTrue)
+ } else {
+ buf = append(buf, LiteralFalse)
+ }
+ case int64:
+ typeCode = TypeCodeInt64
+ buf = appendBinaryUint64(buf, uint64(x))
+ case uint64:
+ typeCode = TypeCodeUint64
+ buf = appendBinaryUint64(buf, x)
+ case float64:
+ typeCode = TypeCodeFloat64
+ buf = appendBinaryFloat64(buf, x)
+ case json.Number:
+ typeCode, buf, err = appendBinaryNumber(buf, x)
+ if err != nil {
+ return typeCode, nil, errors.Trace(err)
+ }
+ case string:
+ typeCode = TypeCodeString
+ buf = appendBinaryString(buf, x)
+ case BinaryJSON:
+ typeCode = x.TypeCode
+ buf = append(buf, x.Value...)
+ case []interface{}:
+ typeCode = TypeCodeArray
+ buf, err = appendBinaryArray(buf, x)
+ if err != nil {
+ return typeCode, nil, errors.Trace(err)
+ }
+ case map[string]interface{}:
+ typeCode = TypeCodeObject
+ buf, err = appendBinaryObject(buf, x)
+ if err != nil {
+ return typeCode, nil, errors.Trace(err)
+ }
+ default:
+ msg := fmt.Sprintf(unknownTypeErrorMsg, reflect.TypeOf(in))
+ err = errors.New(msg)
+ }
+ return typeCode, buf, err
+}
+
+func appendZero(buf []byte, length int) []byte {
+ var tmp [8]byte
+ rem := length % 8
+ loop := length / 8
+ for i := 0; i < loop; i++ {
+ buf = append(buf, tmp[:]...)
+ }
+ for i := 0; i < rem; i++ {
+ buf = append(buf, 0)
+ }
+ return buf
+}
+
+func appendUint32(buf []byte, v uint32) []byte {
+ var tmp [4]byte
+ endian.PutUint32(tmp[:], v)
+ return append(buf, tmp[:]...)
+}
+
+func appendBinaryNumber(buf []byte, x json.Number) (TypeCode, []byte, error) {
+ // The type interpretation process is as follows:
+ // - Attempt float64 if it contains Ee.
+ // - Next attempt int64
+ // - Then uint64 (valid in MySQL JSON, not in JSON decode library)
+ // - Then float64
+ // - Return an error
+ if strings.ContainsAny(string(x), "Ee.") {
+ f64, err := x.Float64()
+ if err != nil {
+ return TypeCodeFloat64, nil, errors.Trace(err)
+ }
+ return TypeCodeFloat64, appendBinaryFloat64(buf, f64), nil
+ } else if val, err := x.Int64(); err == nil {
+ return TypeCodeInt64, appendBinaryUint64(buf, uint64(val)), nil
+ } else if val, err := strconv.ParseUint(string(x), 10, 64); err == nil {
+ return TypeCodeUint64, appendBinaryUint64(buf, val), nil
+ }
+ val, err := x.Float64()
+ if err == nil {
+ return TypeCodeFloat64, appendBinaryFloat64(buf, val), nil
+ }
+ var typeCode TypeCode
+ return typeCode, nil, errors.Trace(err)
+}
+
+func appendBinaryString(buf []byte, v string) []byte {
+ begin := len(buf)
+ buf = appendZero(buf, binary.MaxVarintLen64)
+ lenLen := binary.PutUvarint(buf[begin:], uint64(len(v)))
+ buf = buf[:len(buf)-binary.MaxVarintLen64+lenLen]
+ buf = append(buf, v...)
+ return buf
+}
+
+func appendBinaryFloat64(buf []byte, v float64) []byte {
+ off := len(buf)
+ buf = appendZero(buf, 8)
+ endian.PutUint64(buf[off:], math.Float64bits(v))
+ return buf
+}
+
+func appendBinaryUint64(buf []byte, v uint64) []byte {
+ off := len(buf)
+ buf = appendZero(buf, 8)
+ endian.PutUint64(buf[off:], v)
+ return buf
+}
+
+func appendBinaryArray(buf []byte, array []interface{}) ([]byte, error) {
+ docOff := len(buf)
+ buf = appendUint32(buf, uint32(len(array)))
+ buf = appendZero(buf, dataSizeOff)
+ valEntryBegin := len(buf)
+ buf = appendZero(buf, len(array)*valEntrySize)
+ for i, val := range array {
+ var err error
+ buf, err = appendBinaryValElem(buf, docOff, valEntryBegin+i*valEntrySize, val)
+ if err != nil {
+ return nil, errors.Trace(err)
+ }
+ }
+ docSize := len(buf) - docOff
+ endian.PutUint32(buf[docOff+dataSizeOff:], uint32(docSize))
+ return buf, nil
+}
+
+func appendBinaryValElem(buf []byte, docOff, valEntryOff int, val interface{}) ([]byte, error) {
+ var typeCode TypeCode
+ var err error
+ elemDocOff := len(buf)
+ typeCode, buf, err = appendBinary(buf, val)
+ if err != nil {
+ return nil, errors.Trace(err)
+ }
+ switch typeCode {
+ case TypeCodeLiteral:
+ litCode := buf[elemDocOff]
+ buf = buf[:elemDocOff]
+ buf[valEntryOff] = TypeCodeLiteral
+ buf[valEntryOff+1] = litCode
+ return buf, nil
+ }
+ buf[valEntryOff] = typeCode
+ valOff := elemDocOff - docOff
+ endian.PutUint32(buf[valEntryOff+1:], uint32(valOff))
+ return buf, nil
+}
+
+type field struct {
+ key string
+ val interface{}
+}
+
+func appendBinaryObject(buf []byte, x map[string]interface{}) ([]byte, error) {
+ docOff := len(buf)
+ buf = appendUint32(buf, uint32(len(x)))
+ buf = appendZero(buf, dataSizeOff)
+ keyEntryBegin := len(buf)
+ buf = appendZero(buf, len(x)*keyEntrySize)
+ valEntryBegin := len(buf)
+ buf = appendZero(buf, len(x)*valEntrySize)
+
+ fields := make([]field, 0, len(x))
+ for key, val := range x {
+ fields = append(fields, field{key: key, val: val})
+ }
+ sort.Slice(fields, func(i, j int) bool {
+ return fields[i].key < fields[j].key
+ })
+ for i, field := range fields {
+ keyEntryOff := keyEntryBegin + i*keyEntrySize
+ keyOff := len(buf) - docOff
+ keyLen := uint32(len(field.key))
+ if keyLen > math.MaxUint16 {
+ return nil, ErrJSONObjectKeyTooLong
+ }
+ endian.PutUint32(buf[keyEntryOff:], uint32(keyOff))
+ endian.PutUint16(buf[keyEntryOff+keyLenOff:], uint16(keyLen))
+ buf = append(buf, field.key...)
+ }
+ for i, field := range fields {
+ var err error
+ buf, err = appendBinaryValElem(buf, docOff, valEntryBegin+i*valEntrySize, field.val)
+ if err != nil {
+ return nil, errors.Trace(err)
+ }
+ }
+ docSize := len(buf) - docOff
+ endian.PutUint32(buf[docOff+dataSizeOff:], uint32(docSize))
+ return buf, nil
+}
diff --git a/pkg/types/json/binary_functions.go b/pkg/types/json/binary_functions.go
new file mode 100644
index 0000000000000000000000000000000000000000..ed2ca0dfe223fa8dbdec64734ea0d73a8ba4b378
--- /dev/null
+++ b/pkg/types/json/binary_functions.go
@@ -0,0 +1,1161 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package json
+
+import (
+ "bytes"
+ "encoding/binary"
+ "encoding/hex"
+ "fmt"
+ "math"
+ "sort"
+ "unicode/utf8"
+
+ "github.com/pingcap/errors"
+ "matrixbase/pkg/util/hack"
+ "matrixbase/pkg/util/stringutil"
+)
+
+// Type returns type of BinaryJSON as string.
+func (bj BinaryJSON) Type() string {
+ switch bj.TypeCode {
+ case TypeCodeObject:
+ return "OBJECT"
+ case TypeCodeArray:
+ return "ARRAY"
+ case TypeCodeLiteral:
+ switch bj.Value[0] {
+ case LiteralNil:
+ return "NULL"
+ default:
+ return "BOOLEAN"
+ }
+ case TypeCodeInt64:
+ return "INTEGER"
+ case TypeCodeUint64:
+ return "UNSIGNED INTEGER"
+ case TypeCodeFloat64:
+ return "DOUBLE"
+ case TypeCodeString:
+ return "STRING"
+ default:
+ msg := fmt.Sprintf(unknownTypeCodeErrorMsg, bj.TypeCode)
+ panic(msg)
+ }
+}
+
+// Unquote is for JSON_UNQUOTE.
+func (bj BinaryJSON) Unquote() (string, error) {
+ switch bj.TypeCode {
+ case TypeCodeString:
+ str := string(hack.String(bj.GetString()))
+ return UnquoteString(str)
+ default:
+ return bj.String(), nil
+ }
+}
+
+// UnquoteString remove quotes in a string,
+// including the quotes at the head and tail of string.
+func UnquoteString(str string) (string, error) {
+ strLen := len(str)
+ if strLen < 2 {
+ return str, nil
+ }
+ head, tail := str[0], str[strLen-1]
+ if head == '"' && tail == '"' {
+ // Remove prefix and suffix '"' before unquoting
+ return unquoteString(str[1 : strLen-1])
+ }
+ // if value is not double quoted, do nothing
+ return str, nil
+}
+
+// unquoteString recognizes the escape sequences shown in:
+// https://dev.mysql.com/doc/refman/5.7/en/json-modification-functions.html#json-unquote-character-escape-sequences
+func unquoteString(s string) (string, error) {
+ ret := new(bytes.Buffer)
+ for i := 0; i < len(s); i++ {
+ if s[i] == '\\' {
+ i++
+ if i == len(s) {
+ return "", errors.New("Missing a closing quotation mark in string")
+ }
+ switch s[i] {
+ case '"':
+ ret.WriteByte('"')
+ case 'b':
+ ret.WriteByte('\b')
+ case 'f':
+ ret.WriteByte('\f')
+ case 'n':
+ ret.WriteByte('\n')
+ case 'r':
+ ret.WriteByte('\r')
+ case 't':
+ ret.WriteByte('\t')
+ case '\\':
+ ret.WriteByte('\\')
+ case 'u':
+ if i+4 > len(s) {
+ return "", errors.Errorf("Invalid unicode: %s", s[i+1:])
+ }
+ char, size, err := decodeEscapedUnicode(hack.Slice(s[i+1 : i+5]))
+ if err != nil {
+ return "", errors.Trace(err)
+ }
+ ret.Write(char[0:size])
+ i += 4
+ default:
+ // For all other escape sequences, backslash is ignored.
+ ret.WriteByte(s[i])
+ }
+ } else {
+ ret.WriteByte(s[i])
+ }
+ }
+ return ret.String(), nil
+}
+
+// decodeEscapedUnicode decodes unicode into utf8 bytes specified in RFC 3629.
+// According RFC 3629, the max length of utf8 characters is 4 bytes.
+// And MySQL use 4 bytes to represent the unicode which must be in [0, 65536).
+func decodeEscapedUnicode(s []byte) (char [4]byte, size int, err error) {
+ size, err = hex.Decode(char[0:2], s)
+ if err != nil || size != 2 {
+ // The unicode must can be represented in 2 bytes.
+ return char, 0, errors.Trace(err)
+ }
+ var unicode uint16
+ err = binary.Read(bytes.NewReader(char[0:2]), binary.BigEndian, &unicode)
+ if err != nil {
+ return char, 0, errors.Trace(err)
+ }
+ size = utf8.RuneLen(rune(unicode))
+ utf8.EncodeRune(char[0:size], rune(unicode))
+ return
+}
+
+// quoteString escapes interior quote and other characters for JSON_QUOTE
+// https://dev.mysql.com/doc/refman/5.7/en/json-creation-functions.html#function_json-quote
+// TODO: add JSON_QUOTE builtin
+func quoteString(s string) string {
+ var escapeByteMap = map[byte]string{
+ '\\': "\\\\",
+ '"': "\\\"",
+ '\b': "\\b",
+ '\f': "\\f",
+ '\n': "\\n",
+ '\r': "\\r",
+ '\t': "\\t",
+ }
+
+ ret := new(bytes.Buffer)
+ ret.WriteByte('"')
+
+ start := 0
+ hasEscaped := false
+
+ for i := 0; i < len(s); {
+ if b := s[i]; b < utf8.RuneSelf {
+ escaped, ok := escapeByteMap[b]
+ if ok {
+ if start < i {
+ ret.WriteString(s[start:i])
+ }
+ hasEscaped = true
+ ret.WriteString(escaped)
+ i++
+ start = i
+ } else {
+ i++
+ }
+ } else {
+ c, size := utf8.DecodeRune([]byte(s[i:]))
+ if c == utf8.RuneError && size == 1 { // refer to codes of `binary.marshalStringTo`
+ if start < i {
+ ret.WriteString(s[start:i])
+ }
+ hasEscaped = true
+ ret.WriteString(`\ufffd`)
+ i += size
+ start = i
+ continue
+ }
+ i += size
+ }
+ }
+
+ if start < len(s) {
+ ret.WriteString(s[start:])
+ }
+
+ if hasEscaped {
+ ret.WriteByte('"')
+ return ret.String()
+ }
+ return ret.String()[1:]
+}
+
+// Extract receives several path expressions as arguments, matches them in bj, and returns:
+// ret: target JSON matched any path expressions. maybe autowrapped as an array.
+// found: true if any path expressions matched.
+func (bj BinaryJSON) Extract(pathExprList []PathExpression) (ret BinaryJSON, found bool) {
+ buf := make([]BinaryJSON, 0, 1)
+ for _, pathExpr := range pathExprList {
+ buf = bj.extractTo(buf, pathExpr)
+ }
+ if len(buf) == 0 {
+ found = false
+ } else if len(pathExprList) == 1 && len(buf) == 1 {
+ // If pathExpr contains asterisks, len(elemList) won't be 1
+ // even if len(pathExprList) equals to 1.
+ found = true
+ ret = buf[0]
+ } else {
+ found = true
+ ret = buildBinaryArray(buf)
+ }
+ return
+}
+
+func (bj BinaryJSON) extractTo(buf []BinaryJSON, pathExpr PathExpression) []BinaryJSON {
+ if len(pathExpr.legs) == 0 {
+ return append(buf, bj)
+ }
+ currentLeg, subPathExpr := pathExpr.popOneLeg()
+ if currentLeg.typ == pathLegIndex {
+ if bj.TypeCode != TypeCodeArray {
+ if currentLeg.arrayIndex <= 0 && currentLeg.arrayIndex != arrayIndexAsterisk {
+ buf = bj.extractTo(buf, subPathExpr)
+ }
+ return buf
+ }
+ elemCount := bj.GetElemCount()
+ if currentLeg.arrayIndex == arrayIndexAsterisk {
+ for i := 0; i < elemCount; i++ {
+ buf = bj.arrayGetElem(i).extractTo(buf, subPathExpr)
+ }
+ } else if currentLeg.arrayIndex < elemCount {
+ buf = bj.arrayGetElem(currentLeg.arrayIndex).extractTo(buf, subPathExpr)
+ }
+ } else if currentLeg.typ == pathLegKey && bj.TypeCode == TypeCodeObject {
+ elemCount := bj.GetElemCount()
+ if currentLeg.dotKey == "*" {
+ for i := 0; i < elemCount; i++ {
+ buf = bj.objectGetVal(i).extractTo(buf, subPathExpr)
+ }
+ } else {
+ child, ok := bj.objectSearchKey(hack.Slice(currentLeg.dotKey))
+ if ok {
+ buf = child.extractTo(buf, subPathExpr)
+ }
+ }
+ } else if currentLeg.typ == pathLegDoubleAsterisk {
+ buf = bj.extractTo(buf, subPathExpr)
+ if bj.TypeCode == TypeCodeArray {
+ elemCount := bj.GetElemCount()
+ for i := 0; i < elemCount; i++ {
+ buf = bj.arrayGetElem(i).extractTo(buf, pathExpr)
+ }
+ } else if bj.TypeCode == TypeCodeObject {
+ elemCount := bj.GetElemCount()
+ for i := 0; i < elemCount; i++ {
+ buf = bj.objectGetVal(i).extractTo(buf, pathExpr)
+ }
+ }
+ }
+ return buf
+}
+
+func (bj BinaryJSON) objectSearchKey(key []byte) (BinaryJSON, bool) {
+ elemCount := bj.GetElemCount()
+ idx := sort.Search(elemCount, func(i int) bool {
+ return bytes.Compare(bj.objectGetKey(i), key) >= 0
+ })
+ if idx < elemCount && bytes.Equal(bj.objectGetKey(idx), key) {
+ return bj.objectGetVal(idx), true
+ }
+ return BinaryJSON{}, false
+}
+
+func buildBinaryArray(elems []BinaryJSON) BinaryJSON {
+ totalSize := headerSize + len(elems)*valEntrySize
+ for _, elem := range elems {
+ if elem.TypeCode != TypeCodeLiteral {
+ totalSize += len(elem.Value)
+ }
+ }
+ buf := make([]byte, headerSize+len(elems)*valEntrySize, totalSize)
+ endian.PutUint32(buf, uint32(len(elems)))
+ endian.PutUint32(buf[dataSizeOff:], uint32(totalSize))
+ buf = buildBinaryElements(buf, headerSize, elems)
+ return BinaryJSON{TypeCode: TypeCodeArray, Value: buf}
+}
+
+func buildBinaryElements(buf []byte, entryStart int, elems []BinaryJSON) []byte {
+ for i, elem := range elems {
+ buf[entryStart+i*valEntrySize] = elem.TypeCode
+ if elem.TypeCode == TypeCodeLiteral {
+ buf[entryStart+i*valEntrySize+valTypeSize] = elem.Value[0]
+ } else {
+ endian.PutUint32(buf[entryStart+i*valEntrySize+valTypeSize:], uint32(len(buf)))
+ buf = append(buf, elem.Value...)
+ }
+ }
+ return buf
+}
+
+func buildBinaryObject(keys [][]byte, elems []BinaryJSON) (BinaryJSON, error) {
+ totalSize := headerSize + len(elems)*(keyEntrySize+valEntrySize)
+ for i, elem := range elems {
+ if elem.TypeCode != TypeCodeLiteral {
+ totalSize += len(elem.Value)
+ }
+ totalSize += len(keys[i])
+ }
+ buf := make([]byte, headerSize+len(elems)*(keyEntrySize+valEntrySize), totalSize)
+ endian.PutUint32(buf, uint32(len(elems)))
+ endian.PutUint32(buf[dataSizeOff:], uint32(totalSize))
+ for i, key := range keys {
+ if len(key) > math.MaxUint16 {
+ return BinaryJSON{}, ErrJSONObjectKeyTooLong
+ }
+ endian.PutUint32(buf[headerSize+i*keyEntrySize:], uint32(len(buf)))
+ endian.PutUint16(buf[headerSize+i*keyEntrySize+keyLenOff:], uint16(len(key)))
+ buf = append(buf, key...)
+ }
+ entryStart := headerSize + len(elems)*keyEntrySize
+ buf = buildBinaryElements(buf, entryStart, elems)
+ return BinaryJSON{TypeCode: TypeCodeObject, Value: buf}, nil
+}
+
+// Modify modifies a JSON object by insert, replace or set.
+// All path expressions cannot contain * or ** wildcard.
+// If any error occurs, the input won't be changed.
+func (bj BinaryJSON) Modify(pathExprList []PathExpression, values []BinaryJSON, mt ModifyType) (retj BinaryJSON, err error) {
+ if len(pathExprList) != len(values) {
+ // TODO: should return 1582(42000)
+ return retj, errors.New("Incorrect parameter count")
+ }
+ for _, pathExpr := range pathExprList {
+ if pathExpr.flags.containsAnyAsterisk() {
+ // TODO: should return 3149(42000)
+ return retj, errors.New("Invalid path expression")
+ }
+ }
+ for i := 0; i < len(pathExprList); i++ {
+ pathExpr, value := pathExprList[i], values[i]
+ modifier := &binaryModifier{bj: bj}
+ switch mt {
+ case ModifyInsert:
+ bj = modifier.insert(pathExpr, value)
+ case ModifyReplace:
+ bj = modifier.replace(pathExpr, value)
+ case ModifySet:
+ bj = modifier.set(pathExpr, value)
+ }
+ if modifier.err != nil {
+ return BinaryJSON{}, modifier.err
+ }
+ }
+ return bj, nil
+}
+
+// ArrayInsert insert a BinaryJSON into the given array cell.
+// All path expressions cannot contain * or ** wildcard.
+// If any error occurs, the input won't be changed.
+func (bj BinaryJSON) ArrayInsert(pathExpr PathExpression, value BinaryJSON) (res BinaryJSON, err error) {
+ // Check the path is a index
+ if len(pathExpr.legs) < 1 {
+ return bj, ErrInvalidJSONPathArrayCell
+ }
+ parentPath, lastLeg := pathExpr.popOneLastLeg()
+ if lastLeg.typ != pathLegIndex {
+ return bj, ErrInvalidJSONPathArrayCell
+ }
+ // Find the target array
+ obj, exists := bj.Extract([]PathExpression{parentPath})
+ if !exists || obj.TypeCode != TypeCodeArray {
+ return bj, nil
+ }
+
+ idx := lastLeg.arrayIndex
+ count := obj.GetElemCount()
+ if idx >= count {
+ idx = count
+ }
+ // Insert into the array
+ newArray := make([]BinaryJSON, 0, count+1)
+ for i := 0; i < idx; i++ {
+ elem := obj.arrayGetElem(i)
+ newArray = append(newArray, elem)
+ }
+ newArray = append(newArray, value)
+ for i := idx; i < count; i++ {
+ elem := obj.arrayGetElem(i)
+ newArray = append(newArray, elem)
+ }
+ obj = buildBinaryArray(newArray)
+
+ bj, err = bj.Modify([]PathExpression{parentPath}, []BinaryJSON{obj}, ModifySet)
+ if err != nil {
+ return bj, err
+ }
+ return bj, nil
+}
+
+// Remove removes the elements indicated by pathExprList from JSON.
+func (bj BinaryJSON) Remove(pathExprList []PathExpression) (BinaryJSON, error) {
+ for _, pathExpr := range pathExprList {
+ if len(pathExpr.legs) == 0 {
+ // TODO: should return 3153(42000)
+ return bj, errors.New("Invalid path expression")
+ }
+ if pathExpr.flags.containsAnyAsterisk() {
+ // TODO: should return 3149(42000)
+ return bj, errors.New("Invalid path expression")
+ }
+ modifer := &binaryModifier{bj: bj}
+ bj = modifer.remove(pathExpr)
+ if modifer.err != nil {
+ return BinaryJSON{}, modifer.err
+ }
+ }
+ return bj, nil
+}
+
+type binaryModifier struct {
+ bj BinaryJSON
+ modifyPtr *byte
+ modifyValue BinaryJSON
+ err error
+}
+
+func (bm *binaryModifier) set(path PathExpression, newBj BinaryJSON) BinaryJSON {
+ result := make([]BinaryJSON, 0, 1)
+ result = bm.bj.extractTo(result, path)
+ if len(result) > 0 {
+ bm.modifyPtr = &result[0].Value[0]
+ bm.modifyValue = newBj
+ return bm.rebuild()
+ }
+ bm.doInsert(path, newBj)
+ if bm.err != nil {
+ return BinaryJSON{}
+ }
+ return bm.rebuild()
+}
+
+func (bm *binaryModifier) replace(path PathExpression, newBj BinaryJSON) BinaryJSON {
+ result := make([]BinaryJSON, 0, 1)
+ result = bm.bj.extractTo(result, path)
+ if len(result) == 0 {
+ return bm.bj
+ }
+ bm.modifyPtr = &result[0].Value[0]
+ bm.modifyValue = newBj
+ return bm.rebuild()
+}
+
+func (bm *binaryModifier) insert(path PathExpression, newBj BinaryJSON) BinaryJSON {
+ result := make([]BinaryJSON, 0, 1)
+ result = bm.bj.extractTo(result, path)
+ if len(result) > 0 {
+ return bm.bj
+ }
+ bm.doInsert(path, newBj)
+ if bm.err != nil {
+ return BinaryJSON{}
+ }
+ return bm.rebuild()
+}
+
+// doInsert inserts the newBj to its parent, and builds the new parent.
+func (bm *binaryModifier) doInsert(path PathExpression, newBj BinaryJSON) {
+ parentPath, lastLeg := path.popOneLastLeg()
+ result := make([]BinaryJSON, 0, 1)
+ result = bm.bj.extractTo(result, parentPath)
+ if len(result) == 0 {
+ return
+ }
+ parentBj := result[0]
+ if lastLeg.typ == pathLegIndex {
+ bm.modifyPtr = &parentBj.Value[0]
+ if parentBj.TypeCode != TypeCodeArray {
+ bm.modifyValue = buildBinaryArray([]BinaryJSON{parentBj, newBj})
+ return
+ }
+ elemCount := parentBj.GetElemCount()
+ elems := make([]BinaryJSON, 0, elemCount+1)
+ for i := 0; i < elemCount; i++ {
+ elems = append(elems, parentBj.arrayGetElem(i))
+ }
+ elems = append(elems, newBj)
+ bm.modifyValue = buildBinaryArray(elems)
+ return
+ }
+ if parentBj.TypeCode != TypeCodeObject {
+ return
+ }
+ bm.modifyPtr = &parentBj.Value[0]
+ elemCount := parentBj.GetElemCount()
+ insertKey := hack.Slice(lastLeg.dotKey)
+ insertIdx := sort.Search(elemCount, func(i int) bool {
+ return bytes.Compare(parentBj.objectGetKey(i), insertKey) >= 0
+ })
+ keys := make([][]byte, 0, elemCount+1)
+ elems := make([]BinaryJSON, 0, elemCount+1)
+ for i := 0; i < elemCount; i++ {
+ if i == insertIdx {
+ keys = append(keys, insertKey)
+ elems = append(elems, newBj)
+ }
+ keys = append(keys, parentBj.objectGetKey(i))
+ elems = append(elems, parentBj.objectGetVal(i))
+ }
+ if insertIdx == elemCount {
+ keys = append(keys, insertKey)
+ elems = append(elems, newBj)
+ }
+ bm.modifyValue, bm.err = buildBinaryObject(keys, elems)
+ return
+}
+
+func (bm *binaryModifier) remove(path PathExpression) BinaryJSON {
+ result := make([]BinaryJSON, 0, 1)
+ result = bm.bj.extractTo(result, path)
+ if len(result) == 0 {
+ return bm.bj
+ }
+ bm.doRemove(path)
+ if bm.err != nil {
+ return BinaryJSON{}
+ }
+ return bm.rebuild()
+}
+
+func (bm *binaryModifier) doRemove(path PathExpression) {
+ parentPath, lastLeg := path.popOneLastLeg()
+ result := make([]BinaryJSON, 0, 1)
+ result = bm.bj.extractTo(result, parentPath)
+ if len(result) == 0 {
+ return
+ }
+ parentBj := result[0]
+ if lastLeg.typ == pathLegIndex {
+ if parentBj.TypeCode != TypeCodeArray {
+ return
+ }
+ bm.modifyPtr = &parentBj.Value[0]
+ elemCount := parentBj.GetElemCount()
+ elems := make([]BinaryJSON, 0, elemCount-1)
+ for i := 0; i < elemCount; i++ {
+ if i != lastLeg.arrayIndex {
+ elems = append(elems, parentBj.arrayGetElem(i))
+ }
+ }
+ bm.modifyValue = buildBinaryArray(elems)
+ return
+ }
+ if parentBj.TypeCode != TypeCodeObject {
+ return
+ }
+ bm.modifyPtr = &parentBj.Value[0]
+ elemCount := parentBj.GetElemCount()
+ removeKey := hack.Slice(lastLeg.dotKey)
+ keys := make([][]byte, 0, elemCount+1)
+ elems := make([]BinaryJSON, 0, elemCount+1)
+ for i := 0; i < elemCount; i++ {
+ key := parentBj.objectGetKey(i)
+ if !bytes.Equal(key, removeKey) {
+ keys = append(keys, parentBj.objectGetKey(i))
+ elems = append(elems, parentBj.objectGetVal(i))
+ }
+ }
+ bm.modifyValue, bm.err = buildBinaryObject(keys, elems)
+ return
+}
+
+// rebuild merges the old and the modified JSON into a new BinaryJSON
+func (bm *binaryModifier) rebuild() BinaryJSON {
+ buf := make([]byte, 0, len(bm.bj.Value)+len(bm.modifyValue.Value))
+ value, tpCode := bm.rebuildTo(buf)
+ return BinaryJSON{TypeCode: tpCode, Value: value}
+}
+
+func (bm *binaryModifier) rebuildTo(buf []byte) ([]byte, TypeCode) {
+ if bm.modifyPtr == &bm.bj.Value[0] {
+ bm.modifyPtr = nil
+ return append(buf, bm.modifyValue.Value...), bm.modifyValue.TypeCode
+ } else if bm.modifyPtr == nil {
+ return append(buf, bm.bj.Value...), bm.bj.TypeCode
+ }
+ bj := bm.bj
+ switch bj.TypeCode {
+ case TypeCodeLiteral, TypeCodeInt64, TypeCodeUint64, TypeCodeFloat64, TypeCodeString:
+ return append(buf, bj.Value...), bj.TypeCode
+ }
+ docOff := len(buf)
+ elemCount := bj.GetElemCount()
+ var valEntryStart int
+ if bj.TypeCode == TypeCodeArray {
+ copySize := headerSize + elemCount*valEntrySize
+ valEntryStart = headerSize
+ buf = append(buf, bj.Value[:copySize]...)
+ } else {
+ copySize := headerSize + elemCount*(keyEntrySize+valEntrySize)
+ valEntryStart = headerSize + elemCount*keyEntrySize
+ buf = append(buf, bj.Value[:copySize]...)
+ if elemCount > 0 {
+ firstKeyOff := int(endian.Uint32(bj.Value[headerSize:]))
+ lastKeyOff := int(endian.Uint32(bj.Value[headerSize+(elemCount-1)*keyEntrySize:]))
+ lastKeyLen := int(endian.Uint16(bj.Value[headerSize+(elemCount-1)*keyEntrySize+keyLenOff:]))
+ buf = append(buf, bj.Value[firstKeyOff:lastKeyOff+lastKeyLen]...)
+ }
+ }
+ for i := 0; i < elemCount; i++ {
+ valEntryOff := valEntryStart + i*valEntrySize
+ elem := bj.valEntryGet(valEntryOff)
+ bm.bj = elem
+ var tpCode TypeCode
+ valOff := len(buf) - docOff
+ buf, tpCode = bm.rebuildTo(buf)
+ buf[docOff+valEntryOff] = tpCode
+ if tpCode == TypeCodeLiteral {
+ lastIdx := len(buf) - 1
+ endian.PutUint32(buf[docOff+valEntryOff+valTypeSize:], uint32(buf[lastIdx]))
+ buf = buf[:lastIdx]
+ } else {
+ endian.PutUint32(buf[docOff+valEntryOff+valTypeSize:], uint32(valOff))
+ }
+ }
+ endian.PutUint32(buf[docOff+dataSizeOff:], uint32(len(buf)-docOff))
+ return buf, bj.TypeCode
+}
+
+// floatEpsilon is the acceptable error quantity when comparing two float numbers.
+const floatEpsilon = 1.e-8
+
+// compareFloat64 returns an integer comparing the float64 x to y,
+// allowing precision loss.
+func compareFloat64PrecisionLoss(x, y float64) int {
+ if x-y < floatEpsilon && y-x < floatEpsilon {
+ return 0
+ } else if x-y < 0 {
+ return -1
+ }
+ return 1
+}
+
+func compareInt64(x int64, y int64) int {
+ if x < y {
+ return -1
+ } else if x == y {
+ return 0
+ }
+
+ return 1
+}
+
+func compareFloat64(x float64, y float64) int {
+ if x < y {
+ return -1
+ } else if x == y {
+ return 0
+ }
+
+ return 1
+}
+
+func compareUint64(x uint64, y uint64) int {
+ if x < y {
+ return -1
+ } else if x == y {
+ return 0
+ }
+
+ return 1
+}
+
+func compareInt64Uint64(x int64, y uint64) int {
+ if x < 0 {
+ return -1
+ }
+ return compareUint64(uint64(x), y)
+}
+
+func compareFloat64Int64(x float64, y int64) int {
+ return compareFloat64PrecisionLoss(x, float64(y))
+}
+
+func compareFloat64Uint64(x float64, y uint64) int {
+ return compareFloat64PrecisionLoss(x, float64(y))
+}
+
+// CompareBinary compares two binary json objects. Returns -1 if left < right,
+// 0 if left == right, else returns 1.
+func CompareBinary(left, right BinaryJSON) int {
+ precedence1 := jsonTypePrecedences[left.Type()]
+ precedence2 := jsonTypePrecedences[right.Type()]
+ var cmp int
+ if precedence1 == precedence2 {
+ if precedence1 == jsonTypePrecedences["NULL"] {
+ // for JSON null.
+ cmp = 0
+ }
+ switch left.TypeCode {
+ case TypeCodeLiteral:
+ // false is less than true.
+ cmp = int(right.Value[0]) - int(left.Value[0])
+ case TypeCodeInt64:
+ switch right.TypeCode {
+ case TypeCodeInt64:
+ cmp = compareInt64(left.GetInt64(), right.GetInt64())
+ case TypeCodeUint64:
+ cmp = compareInt64Uint64(left.GetInt64(), right.GetUint64())
+ case TypeCodeFloat64:
+ cmp = -compareFloat64Int64(right.GetFloat64(), left.GetInt64())
+ }
+ case TypeCodeUint64:
+ switch right.TypeCode {
+ case TypeCodeInt64:
+ cmp = -compareInt64Uint64(right.GetInt64(), left.GetUint64())
+ case TypeCodeUint64:
+ cmp = compareUint64(left.GetUint64(), right.GetUint64())
+ case TypeCodeFloat64:
+ cmp = -compareFloat64Uint64(right.GetFloat64(), left.GetUint64())
+ }
+ case TypeCodeFloat64:
+ switch right.TypeCode {
+ case TypeCodeInt64:
+ cmp = compareFloat64Int64(left.GetFloat64(), right.GetInt64())
+ case TypeCodeUint64:
+ cmp = compareFloat64Uint64(left.GetFloat64(), right.GetUint64())
+ case TypeCodeFloat64:
+ cmp = compareFloat64(left.GetFloat64(), right.GetFloat64())
+ }
+ case TypeCodeString:
+ cmp = bytes.Compare(left.GetString(), right.GetString())
+ case TypeCodeArray:
+ leftCount := left.GetElemCount()
+ rightCount := right.GetElemCount()
+ for i := 0; i < leftCount && i < rightCount; i++ {
+ elem1 := left.arrayGetElem(i)
+ elem2 := right.arrayGetElem(i)
+ cmp = CompareBinary(elem1, elem2)
+ if cmp != 0 {
+ return cmp
+ }
+ }
+ cmp = leftCount - rightCount
+ case TypeCodeObject:
+ // reference:
+ // https://github.com/mysql/mysql-server/blob/ee4455a33b10f1b1886044322e4893f587b319ed/sql/json_dom.cc#L2561
+ leftCount, rightCount := left.GetElemCount(), right.GetElemCount()
+ cmp := compareInt64(int64(leftCount), int64(rightCount))
+ if cmp != 0 {
+ return cmp
+ }
+ for i := 0; i < leftCount; i++ {
+ leftKey, rightKey := left.objectGetKey(i), right.objectGetKey(i)
+ cmp = bytes.Compare(leftKey, rightKey)
+ if cmp != 0 {
+ return cmp
+ }
+ cmp = CompareBinary(left.objectGetVal(i), right.objectGetVal(i))
+ if cmp != 0 {
+ return cmp
+ }
+ }
+ }
+ } else {
+ cmp = precedence1 - precedence2
+ }
+ return cmp
+}
+
+// MergeBinary merges multiple BinaryJSON into one according the following rules:
+// 1) adjacent arrays are merged to a single array;
+// 2) adjacent object are merged to a single object;
+// 3) a scalar value is autowrapped as an array before merge;
+// 4) an adjacent array and object are merged by autowrapping the object as an array.
+func MergeBinary(bjs []BinaryJSON) BinaryJSON {
+ var remain = bjs
+ var objects []BinaryJSON
+ var results []BinaryJSON
+ for len(remain) > 0 {
+ if remain[0].TypeCode != TypeCodeObject {
+ results = append(results, remain[0])
+ remain = remain[1:]
+ } else {
+ objects, remain = getAdjacentObjects(remain)
+ results = append(results, mergeBinaryObject(objects))
+ }
+ }
+ if len(results) == 1 {
+ return results[0]
+ }
+ return mergeBinaryArray(results)
+}
+
+func getAdjacentObjects(bjs []BinaryJSON) (objects, remain []BinaryJSON) {
+ for i := 0; i < len(bjs); i++ {
+ if bjs[i].TypeCode != TypeCodeObject {
+ return bjs[:i], bjs[i:]
+ }
+ }
+ return bjs, nil
+}
+
+func mergeBinaryArray(elems []BinaryJSON) BinaryJSON {
+ buf := make([]BinaryJSON, 0, len(elems))
+ for i := 0; i < len(elems); i++ {
+ elem := elems[i]
+ if elem.TypeCode != TypeCodeArray {
+ buf = append(buf, elem)
+ } else {
+ childCount := elem.GetElemCount()
+ for j := 0; j < childCount; j++ {
+ buf = append(buf, elem.arrayGetElem(j))
+ }
+ }
+ }
+ return buildBinaryArray(buf)
+}
+
+func mergeBinaryObject(objects []BinaryJSON) BinaryJSON {
+ keyValMap := make(map[string]BinaryJSON)
+ keys := make([][]byte, 0, len(keyValMap))
+ for _, obj := range objects {
+ elemCount := obj.GetElemCount()
+ for i := 0; i < elemCount; i++ {
+ key := obj.objectGetKey(i)
+ val := obj.objectGetVal(i)
+ if old, ok := keyValMap[string(key)]; ok {
+ keyValMap[string(key)] = MergeBinary([]BinaryJSON{old, val})
+ } else {
+ keyValMap[string(key)] = val
+ keys = append(keys, key)
+ }
+ }
+ }
+ sort.Slice(keys, func(i, j int) bool {
+ return bytes.Compare(keys[i], keys[j]) < 0
+ })
+ values := make([]BinaryJSON, len(keys))
+ for i, key := range keys {
+ values[i] = keyValMap[string(key)]
+ }
+ binaryObject, err := buildBinaryObject(keys, values)
+ if err != nil {
+ panic("mergeBinaryObject should never panic, please contact the TiDB team for help")
+ }
+ return binaryObject
+}
+
+// PeekBytesAsJSON trys to peek some bytes from b, until
+// we can deserialize a JSON from those bytes.
+func PeekBytesAsJSON(b []byte) (n int, err error) {
+ if len(b) <= 0 {
+ err = errors.New("Cant peek from empty bytes")
+ return
+ }
+ switch c := b[0]; c {
+ case TypeCodeObject, TypeCodeArray:
+ if len(b) >= valTypeSize+headerSize {
+ size := endian.Uint32(b[valTypeSize+dataSizeOff:])
+ n = valTypeSize + int(size)
+ return
+ }
+ case TypeCodeString:
+ strLen, lenLen := binary.Uvarint(b[valTypeSize:])
+ return valTypeSize + int(strLen) + lenLen, nil
+ case TypeCodeInt64, TypeCodeUint64, TypeCodeFloat64:
+ n = valTypeSize + 8
+ return
+ case TypeCodeLiteral:
+ n = valTypeSize + 1
+ return
+ }
+ err = errors.New("Invalid JSON bytes")
+ return
+}
+
+// ContainsBinary check whether JSON document contains specific target according the following rules:
+// 1) object contains a target object if and only if every key is contained in source object and the value associated with the target key is contained in the value associated with the source key;
+// 2) array contains a target nonarray if and only if the target is contained in some element of the array;
+// 3) array contains a target array if and only if every element is contained in some element of the array;
+// 4) scalar contains a target scalar if and only if they are comparable and are equal;
+func ContainsBinary(obj, target BinaryJSON) bool {
+ switch obj.TypeCode {
+ case TypeCodeObject:
+ if target.TypeCode == TypeCodeObject {
+ len := target.GetElemCount()
+ for i := 0; i < len; i++ {
+ key := target.objectGetKey(i)
+ val := target.objectGetVal(i)
+ if exp, exists := obj.objectSearchKey(key); !exists || !ContainsBinary(exp, val) {
+ return false
+ }
+ }
+ return true
+ }
+ return false
+ case TypeCodeArray:
+ if target.TypeCode == TypeCodeArray {
+ len := target.GetElemCount()
+ for i := 0; i < len; i++ {
+ if !ContainsBinary(obj, target.arrayGetElem(i)) {
+ return false
+ }
+ }
+ return true
+ }
+ len := obj.GetElemCount()
+ for i := 0; i < len; i++ {
+ if ContainsBinary(obj.arrayGetElem(i), target) {
+ return true
+ }
+ }
+ return false
+ default:
+ return CompareBinary(obj, target) == 0
+ }
+}
+
+// GetElemDepth for JSON_DEPTH
+// Returns the maximum depth of a JSON document
+// rules referenced by MySQL JSON_DEPTH function
+// [https://dev.mysql.com/doc/refman/5.7/en/json-attribute-functions.html#function_json-depth]
+// 1) An empty array, empty object, or scalar value has depth 1.
+// 2) A nonempty array containing only elements of depth 1 or nonempty object containing only member values of depth 1 has depth 2.
+// 3) Otherwise, a JSON document has depth greater than 2.
+// e.g. depth of '{}', '[]', 'true': 1
+// e.g. depth of '[10, 20]', '[[], {}]': 2
+// e.g. depth of '[10, {"a": 20}]': 3
+func (bj BinaryJSON) GetElemDepth() int {
+ switch bj.TypeCode {
+ case TypeCodeObject:
+ len := bj.GetElemCount()
+ maxDepth := 0
+ for i := 0; i < len; i++ {
+ obj := bj.objectGetVal(i)
+ depth := obj.GetElemDepth()
+ if depth > maxDepth {
+ maxDepth = depth
+ }
+ }
+ return maxDepth + 1
+ case TypeCodeArray:
+ len := bj.GetElemCount()
+ maxDepth := 0
+ for i := 0; i < len; i++ {
+ obj := bj.arrayGetElem(i)
+ depth := obj.GetElemDepth()
+ if depth > maxDepth {
+ maxDepth = depth
+ }
+ }
+ return maxDepth + 1
+ default:
+ return 1
+ }
+}
+
+// Search for JSON_Search
+// rules referenced by MySQL JSON_SEARCH function
+// [https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html#function_json-search]
+func (bj BinaryJSON) Search(containType string, search string, escape byte, pathExpres []PathExpression) (res BinaryJSON, isNull bool, err error) {
+ if containType != ContainsPathOne && containType != ContainsPathAll {
+ return res, true, ErrInvalidJSONPath
+ }
+ patChars, patTypes := stringutil.CompilePattern(search, escape)
+
+ result := make([]interface{}, 0)
+ walkFn := func(fullpath PathExpression, bj BinaryJSON) (stop bool, err error) {
+ if bj.TypeCode == TypeCodeString && stringutil.DoMatch(string(bj.GetString()), patChars, patTypes) {
+ result = append(result, fullpath.String())
+ if containType == ContainsPathOne {
+ return true, nil
+ }
+ }
+ return false, nil
+ }
+ if len(pathExpres) != 0 {
+ err := bj.Walk(walkFn, pathExpres...)
+ if err != nil {
+ return res, true, err
+ }
+ } else {
+ err := bj.Walk(walkFn)
+ if err != nil {
+ return res, true, err
+ }
+ }
+ switch len(result) {
+ case 0:
+ return res, true, nil
+ case 1:
+ return CreateBinary(result[0]), false, nil
+ default:
+ return CreateBinary(result), false, nil
+ }
+
+}
+
+// extractCallbackFn: the type of CALLBACK function for extractToCallback
+type extractCallbackFn func(fullpath PathExpression, bj BinaryJSON) (stop bool, err error)
+
+// extractToCallback: callback alternative of extractTo
+// would be more effective when walk through the whole JSON is unnecessary
+// NOTICE: path [0] & [*] for JSON object other than array is INVALID, which is different from extractTo.
+func (bj BinaryJSON) extractToCallback(pathExpr PathExpression, callbackFn extractCallbackFn, fullpath PathExpression) (stop bool, err error) {
+ if len(pathExpr.legs) == 0 {
+ return callbackFn(fullpath, bj)
+ }
+
+ currentLeg, subPathExpr := pathExpr.popOneLeg()
+ if currentLeg.typ == pathLegIndex && bj.TypeCode == TypeCodeArray {
+ elemCount := bj.GetElemCount()
+ if currentLeg.arrayIndex == arrayIndexAsterisk {
+ for i := 0; i < elemCount; i++ {
+ // buf = bj.arrayGetElem(i).extractTo(buf, subPathExpr)
+ path := fullpath.pushBackOneIndexLeg(i)
+ stop, err = bj.arrayGetElem(i).extractToCallback(subPathExpr, callbackFn, path)
+ if stop || err != nil {
+ return
+ }
+ }
+ } else if currentLeg.arrayIndex < elemCount {
+ // buf = bj.arrayGetElem(currentLeg.arrayIndex).extractTo(buf, subPathExpr)
+ path := fullpath.pushBackOneIndexLeg(currentLeg.arrayIndex)
+ stop, err = bj.arrayGetElem(currentLeg.arrayIndex).extractToCallback(subPathExpr, callbackFn, path)
+ if stop || err != nil {
+ return
+ }
+ }
+ } else if currentLeg.typ == pathLegKey && bj.TypeCode == TypeCodeObject {
+ elemCount := bj.GetElemCount()
+ if currentLeg.dotKey == "*" {
+ for i := 0; i < elemCount; i++ {
+ // buf = bj.objectGetVal(i).extractTo(buf, subPathExpr)
+ path := fullpath.pushBackOneKeyLeg(string(bj.objectGetKey(i)))
+ stop, err = bj.objectGetVal(i).extractToCallback(subPathExpr, callbackFn, path)
+ if stop || err != nil {
+ return
+ }
+ }
+ } else {
+ child, ok := bj.objectSearchKey(hack.Slice(currentLeg.dotKey))
+ if ok {
+ // buf = child.extractTo(buf, subPathExpr)
+ path := fullpath.pushBackOneKeyLeg(currentLeg.dotKey)
+ stop, err = child.extractToCallback(subPathExpr, callbackFn, path)
+ if stop || err != nil {
+ return
+ }
+ }
+ }
+ } else if currentLeg.typ == pathLegDoubleAsterisk {
+ // buf = bj.extractTo(buf, subPathExpr)
+ stop, err = bj.extractToCallback(subPathExpr, callbackFn, fullpath)
+ if stop || err != nil {
+ return
+ }
+
+ if bj.TypeCode == TypeCodeArray {
+ elemCount := bj.GetElemCount()
+ for i := 0; i < elemCount; i++ {
+ // buf = bj.arrayGetElem(i).extractTo(buf, pathExpr)
+ path := fullpath.pushBackOneIndexLeg(i)
+ stop, err = bj.arrayGetElem(i).extractToCallback(pathExpr, callbackFn, path)
+ if stop || err != nil {
+ return
+ }
+ }
+ } else if bj.TypeCode == TypeCodeObject {
+ elemCount := bj.GetElemCount()
+ for i := 0; i < elemCount; i++ {
+ // buf = bj.objectGetVal(i).extractTo(buf, pathExpr)
+ path := fullpath.pushBackOneKeyLeg(string(bj.objectGetKey(i)))
+ stop, err = bj.objectGetVal(i).extractToCallback(pathExpr, callbackFn, path)
+ if stop || err != nil {
+ return
+ }
+ }
+ }
+ }
+ return false, nil
+}
+
+// BinaryJSONWalkFunc is used as callback function for BinaryJSON.Walk
+type BinaryJSONWalkFunc func(fullpath PathExpression, bj BinaryJSON) (stop bool, err error)
+
+// Walk traverse BinaryJSON objects
+func (bj BinaryJSON) Walk(walkFn BinaryJSONWalkFunc, pathExprList ...PathExpression) (err error) {
+ pathSet := make(map[string]bool)
+
+ var doWalk extractCallbackFn
+ doWalk = func(fullpath PathExpression, bj BinaryJSON) (stop bool, err error) {
+ pathStr := fullpath.String()
+ if _, ok := pathSet[pathStr]; ok {
+ return false, nil
+ }
+
+ stop, err = walkFn(fullpath, bj)
+ pathSet[pathStr] = true
+ if stop || err != nil {
+ return
+ }
+
+ if bj.TypeCode == TypeCodeArray {
+ elemCount := bj.GetElemCount()
+ for i := 0; i < elemCount; i++ {
+ path := fullpath.pushBackOneIndexLeg(i)
+ stop, err = doWalk(path, bj.arrayGetElem(i))
+ if stop || err != nil {
+ return
+ }
+ }
+ } else if bj.TypeCode == TypeCodeObject {
+ elemCount := bj.GetElemCount()
+ for i := 0; i < elemCount; i++ {
+ path := fullpath.pushBackOneKeyLeg(string(bj.objectGetKey(i)))
+ stop, err = doWalk(path, bj.objectGetVal(i))
+ if stop || err != nil {
+ return
+ }
+ }
+ }
+ return false, nil
+ }
+
+ fullpath := PathExpression{legs: make([]pathLeg, 0, 32), flags: pathExpressionFlag(0)}
+ if len(pathExprList) > 0 {
+ for _, pathExpr := range pathExprList {
+ var stop bool
+ stop, err = bj.extractToCallback(pathExpr, doWalk, fullpath)
+ if stop || err != nil {
+ return err
+ }
+ }
+ } else {
+ _, err = doWalk(fullpath, bj)
+ if err != nil {
+ return
+ }
+ }
+ return nil
+}
diff --git a/pkg/types/json/binary_functions_test.go b/pkg/types/json/binary_functions_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1d63e880e8aae0e51aff594f1e8a0fdf936ae5cb
--- /dev/null
+++ b/pkg/types/json/binary_functions_test.go
@@ -0,0 +1,31 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package json
+
+import (
+ . "github.com/pingcap/check"
+)
+
+var _ = Suite(&testJSONFuncSuite{})
+
+type testJSONFuncSuite struct{}
+
+func (s *testJSONFuncSuite) TestdecodeEscapedUnicode(c *C) {
+ c.Parallel()
+ in := "597d"
+ r, size, err := decodeEscapedUnicode([]byte(in))
+ c.Assert(string(r[:]), Equals, "好\x00")
+ c.Assert(size, Equals, 3)
+ c.Assert(err, IsNil)
+
+}
diff --git a/pkg/types/json/binary_test.go b/pkg/types/json/binary_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..bd375746a046cbd3d14868474f154c2d3188016e
--- /dev/null
+++ b/pkg/types/json/binary_test.go
@@ -0,0 +1,629 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package json
+
+import (
+ "math"
+ "strings"
+ "testing"
+
+ . "github.com/pingcap/check"
+)
+
+var _ = Suite(&testJSONSuite{})
+
+type testJSONSuite struct{}
+
+func TestT(t *testing.T) {
+ TestingT(t)
+}
+
+func (s *testJSONSuite) TestBinaryJSONMarshalUnmarshal(c *C) {
+ c.Parallel()
+ strs := []string{
+ `{"a": [1, "2", {"aa": "bb"}, 4, null], "b": true, "c": null}`,
+ `{"aaaaaaaaaaa": [1, "2", {"aa": "bb"}, 4.1], "bbbbbbbbbb": true, "ccccccccc": "d"}`,
+ `[{"a": 1, "b": true}, 3, 3.5, "hello, world", null, true]`,
+ `{"a": "&<>"}`,
+ }
+ for _, str := range strs {
+ parsedBJ := mustParseBinaryFromString(c, str)
+ c.Assert(parsedBJ.String(), Equals, str)
+ }
+}
+
+func (s *testJSONSuite) TestBinaryJSONExtract(c *C) {
+ c.Parallel()
+ bj1 := mustParseBinaryFromString(c, `{"\"hello\"": "world", "a": [1, "2", {"aa": "bb"}, 4.0, {"aa": "cc"}], "b": true, "c": ["d"]}`)
+ bj2 := mustParseBinaryFromString(c, `[{"a": 1, "b": true}, 3, 3.5, "hello, world", null, true]`)
+
+ var tests = []struct {
+ bj BinaryJSON
+ pathExprStrings []string
+ expected BinaryJSON
+ found bool
+ err error
+ }{
+ // test extract with only one path expression.
+ {bj1, []string{"$.a"}, mustParseBinaryFromString(c, `[1, "2", {"aa": "bb"}, 4.0, {"aa": "cc"}]`), true, nil},
+ {bj2, []string{"$.a"}, mustParseBinaryFromString(c, "null"), false, nil},
+ {bj1, []string{"$[0]"}, bj1, true, nil}, // in Extract, autowraped bj1 as an array.
+ {bj2, []string{"$[0]"}, mustParseBinaryFromString(c, `{"a": 1, "b": true}`), true, nil},
+ {bj1, []string{"$.a[2].aa"}, mustParseBinaryFromString(c, `"bb"`), true, nil},
+ {bj1, []string{"$.a[*].aa"}, mustParseBinaryFromString(c, `["bb", "cc"]`), true, nil},
+ {bj1, []string{"$.*[0]"}, mustParseBinaryFromString(c, `["world", 1, true, "d"]`), true, nil},
+ {bj1, []string{`$.a[*]."aa"`}, mustParseBinaryFromString(c, `["bb", "cc"]`), true, nil},
+ {bj1, []string{`$."\"hello\""`}, mustParseBinaryFromString(c, `"world"`), true, nil},
+ {bj1, []string{`$**[1]`}, mustParseBinaryFromString(c, `"2"`), true, nil},
+
+ // test extract with multi path expressions.
+ {bj1, []string{"$.a", "$[5]"}, mustParseBinaryFromString(c, `[[1, "2", {"aa": "bb"}, 4.0, {"aa": "cc"}]]`), true, nil},
+ {bj2, []string{"$.a", "$[0]"}, mustParseBinaryFromString(c, `[{"a": 1, "b": true}]`), true, nil},
+ }
+
+ for _, tt := range tests {
+ var pathExprList = make([]PathExpression, 0)
+ for _, peStr := range tt.pathExprStrings {
+ pe, err := ParseJSONPathExpr(peStr)
+ c.Assert(err, IsNil)
+ pathExprList = append(pathExprList, pe)
+ }
+
+ result, found := tt.bj.Extract(pathExprList)
+ c.Assert(found, Equals, tt.found)
+ if found {
+ c.Assert(result.String(), Equals, tt.expected.String())
+ }
+ }
+}
+
+func (s *testJSONSuite) TestBinaryJSONType(c *C) {
+ c.Parallel()
+ var tests = []struct {
+ In string
+ Out string
+ }{
+ {`{"a": "b"}`, "OBJECT"},
+ {`["a", "b"]`, "ARRAY"},
+ {`3`, "INTEGER"},
+ {`3.0`, "DOUBLE"},
+ {`null`, "NULL"},
+ {`true`, "BOOLEAN"},
+ }
+ for _, tt := range tests {
+ bj := mustParseBinaryFromString(c, tt.In)
+ c.Assert(bj.Type(), Equals, tt.Out)
+ }
+ // we can't parse '9223372036854775808' to JSON::Uint64 now,
+ // because go builtin JSON parser treats that as DOUBLE.
+ c.Assert(CreateBinary(uint64(1<<63)).Type(), Equals, "UNSIGNED INTEGER")
+}
+
+func (s *testJSONSuite) TestBinaryJSONUnquote(c *C) {
+ var tests = []struct {
+ j string
+ unquoted string
+ }{
+ {j: `3`, unquoted: "3"},
+ {j: `"3"`, unquoted: "3"},
+ {j: `"[{\"x\":\"{\\\"y\\\":12}\"}]"`, unquoted: `[{"x":"{\"y\":12}"}]`},
+ {j: `"hello, \"escaped quotes\" world"`, unquoted: "hello, \"escaped quotes\" world"},
+ {j: "\"\\u4f60\"", unquoted: "你"},
+ {j: `true`, unquoted: "true"},
+ {j: `null`, unquoted: "null"},
+ {j: `{"a": [1, 2]}`, unquoted: `{"a": [1, 2]}`},
+ {j: `"\""`, unquoted: `"`},
+ {j: `"'"`, unquoted: `'`},
+ {j: `"''"`, unquoted: `''`},
+ {j: `""`, unquoted: ``},
+ }
+ for _, tt := range tests {
+ bj := mustParseBinaryFromString(c, tt.j)
+ unquoted, err := bj.Unquote()
+ c.Assert(err, IsNil)
+ c.Assert(unquoted, Equals, tt.unquoted)
+ }
+}
+
+func (s *testJSONSuite) TestQuoteString(c *C) {
+ var tests = []struct {
+ j string
+ quoted string
+ }{
+ {j: "3", quoted: `3`},
+ {j: "hello, \"escaped quotes\" world", quoted: `"hello, \"escaped quotes\" world"`},
+ {j: "你", quoted: `你`},
+ {j: "true", quoted: `true`},
+ {j: "null", quoted: `null`},
+ {j: `"`, quoted: `"\""`},
+ {j: `'`, quoted: `'`},
+ {j: `''`, quoted: `''`},
+ {j: ``, quoted: ``},
+ {j: "\\ \" \b \f \n \r \t", quoted: `"\\ \" \b \f \n \r \t"`},
+ }
+ for _, tt := range tests {
+ c.Assert(quoteString(tt.j), Equals, tt.quoted)
+ }
+}
+
+func (s *testJSONSuite) TestBinaryJSONModify(c *C) {
+ c.Parallel()
+ var tests = []struct {
+ base string
+ setField string
+ setValue string
+ expected string
+ success bool
+ mt ModifyType
+ }{
+ {`null`, "$", `{}`, `{}`, true, ModifySet},
+ {`{}`, "$.a", `3`, `{"a": 3}`, true, ModifySet},
+ {`{"a": 3}`, "$.a", `[]`, `{"a": []}`, true, ModifyReplace},
+ {`{"a": 3}`, "$.b", `"3"`, `{"a": 3, "b": "3"}`, true, ModifySet},
+ {`{"a": []}`, "$.a[0]", `3`, `{"a": [3]}`, true, ModifySet},
+ {`{"a": [3]}`, "$.a[1]", `4`, `{"a": [3, 4]}`, true, ModifyInsert},
+ {`{"a": [3]}`, "$[0]", `4`, `4`, true, ModifySet},
+ {`{"a": [3]}`, "$[1]", `4`, `[{"a": [3]}, 4]`, true, ModifySet},
+ {`{"b": true}`, "$.b", `false`, `{"b": false}`, true, ModifySet},
+
+ // nothing changed because the path is empty and we want to insert.
+ {`{}`, "$", `1`, `{}`, true, ModifyInsert},
+ // nothing changed because the path without last leg doesn't exist.
+ {`{"a": [3, 4]}`, "$.b[1]", `3`, `{"a": [3, 4]}`, true, ModifySet},
+ // nothing changed because the path without last leg doesn't exist.
+ {`{"a": [3, 4]}`, "$.a[2].b", `3`, `{"a": [3, 4]}`, true, ModifySet},
+ // nothing changed because we want to insert but the full path exists.
+ {`{"a": [3, 4]}`, "$.a[0]", `30`, `{"a": [3, 4]}`, true, ModifyInsert},
+ // nothing changed because we want to replace but the full path doesn't exist.
+ {`{"a": [3, 4]}`, "$.a[2]", `30`, `{"a": [3, 4]}`, true, ModifyReplace},
+
+ // bad path expression.
+ {"null", "$.*", "{}", "null", false, ModifySet},
+ {"null", "$[*]", "{}", "null", false, ModifySet},
+ {"null", "$**.a", "{}", "null", false, ModifySet},
+ {"null", "$**[3]", "{}", "null", false, ModifySet},
+ }
+ for _, tt := range tests {
+ pathExpr, err := ParseJSONPathExpr(tt.setField)
+ c.Assert(err, IsNil)
+
+ base := mustParseBinaryFromString(c, tt.base)
+ value := mustParseBinaryFromString(c, tt.setValue)
+ expected := mustParseBinaryFromString(c, tt.expected)
+ obtain, err := base.Modify([]PathExpression{pathExpr}, []BinaryJSON{value}, tt.mt)
+ if tt.success {
+ c.Assert(err, IsNil)
+ c.Assert(obtain.String(), Equals, expected.String())
+ } else {
+ c.Assert(err, NotNil)
+ }
+ }
+}
+
+func (s *testJSONSuite) TestBinaryJSONRemove(c *C) {
+ c.Parallel()
+ var tests = []struct {
+ base string
+ path string
+ expected string
+ success bool
+ }{
+ {`null`, "$", `{}`, false},
+ {`{"a":[3]}`, "$.a[*]", `{"a":[3]}`, false},
+ {`{}`, "$.a", `{}`, true},
+ {`{"a":3}`, "$.a", `{}`, true},
+ {`{"a":1,"b":2,"c":3}`, "$.b", `{"a":1,"c":3}`, true},
+ {`{"a":1,"b":2,"c":3}`, "$.d", `{"a":1,"b":2,"c":3}`, true},
+ {`{"a":3}`, "$[0]", `{"a":3}`, true},
+ {`{"a":[3,4,5]}`, "$.a[0]", `{"a":[4,5]}`, true},
+ {`{"a":[3,4,5]}`, "$.a[1]", `{"a":[3,5]}`, true},
+ {`{"a":[3,4,5]}`, "$.a[4]", `{"a":[3,4,5]}`, true},
+ {`{"a": [1, 2, {"aa": "xx"}]}`, "$.a[2].aa", `{"a": [1, 2, {}]}`, true},
+ }
+ for _, tt := range tests {
+ pathExpr, err := ParseJSONPathExpr(tt.path)
+ c.Assert(err, IsNil)
+
+ base := mustParseBinaryFromString(c, tt.base)
+ expected := mustParseBinaryFromString(c, tt.expected)
+ obtain, err := base.Remove([]PathExpression{pathExpr})
+ if tt.success {
+ c.Assert(err, IsNil)
+ c.Assert(obtain.String(), Equals, expected.String())
+ } else {
+ c.Assert(err, NotNil)
+ }
+ }
+}
+
+func (s *testJSONSuite) TestCompareBinary(c *C) {
+ c.Parallel()
+ jNull := mustParseBinaryFromString(c, `null`)
+ jBoolTrue := mustParseBinaryFromString(c, `true`)
+ jBoolFalse := mustParseBinaryFromString(c, `false`)
+ jIntegerLarge := CreateBinary(uint64(1 << 63))
+ jIntegerSmall := mustParseBinaryFromString(c, `3`)
+ jStringLarge := mustParseBinaryFromString(c, `"hello, world"`)
+ jStringSmall := mustParseBinaryFromString(c, `"hello"`)
+ jArrayLarge := mustParseBinaryFromString(c, `["a", "c"]`)
+ jArraySmall := mustParseBinaryFromString(c, `["a", "b"]`)
+ jObject := mustParseBinaryFromString(c, `{"a": "b"}`)
+
+ var tests = []struct {
+ left BinaryJSON
+ right BinaryJSON
+ result int
+ }{
+ {jNull, jIntegerSmall, -1},
+ {jIntegerSmall, jIntegerLarge, -1},
+ {jIntegerLarge, jStringSmall, -1},
+ {jStringSmall, jStringLarge, -1},
+ {jStringLarge, jObject, -1},
+ {jObject, jArraySmall, -1},
+ {jArraySmall, jArrayLarge, -1},
+ {jArrayLarge, jBoolFalse, -1},
+ {jBoolFalse, jBoolTrue, -1},
+ {CreateBinary(int64(922337203685477580)), CreateBinary(int64(922337203685477580)), 0},
+ {CreateBinary(int64(922337203685477580)), CreateBinary(int64(922337203685477581)), -1},
+ {CreateBinary(int64(922337203685477581)), CreateBinary(int64(922337203685477580)), 1},
+
+ {CreateBinary(int64(-1)), CreateBinary(uint64(18446744073709551615)), -1},
+ {CreateBinary(int64(922337203685477580)), CreateBinary(uint64(922337203685477581)), -1},
+ {CreateBinary(int64(2)), CreateBinary(uint64(1)), 1},
+ {CreateBinary(int64(math.MaxInt64)), CreateBinary(uint64(math.MaxInt64)), 0},
+
+ {CreateBinary(uint64(18446744073709551615)), CreateBinary(int64(-1)), 1},
+ {CreateBinary(uint64(922337203685477581)), CreateBinary(int64(922337203685477580)), 1},
+ {CreateBinary(uint64(1)), CreateBinary(int64(2)), -1},
+ {CreateBinary(uint64(math.MaxInt64)), CreateBinary(int64(math.MaxInt64)), 0},
+
+ {CreateBinary(float64(9.0)), CreateBinary(int64(9)), 0},
+ {CreateBinary(float64(8.9)), CreateBinary(int64(9)), -1},
+ {CreateBinary(float64(9.1)), CreateBinary(int64(9)), 1},
+
+ {CreateBinary(float64(9.0)), CreateBinary(uint64(9)), 0},
+ {CreateBinary(float64(8.9)), CreateBinary(uint64(9)), -1},
+ {CreateBinary(float64(9.1)), CreateBinary(uint64(9)), 1},
+
+ {CreateBinary(int64(9)), CreateBinary(float64(9.0)), 0},
+ {CreateBinary(int64(9)), CreateBinary(float64(8.9)), 1},
+ {CreateBinary(int64(9)), CreateBinary(float64(9.1)), -1},
+
+ {CreateBinary(uint64(9)), CreateBinary(float64(9.0)), 0},
+ {CreateBinary(uint64(9)), CreateBinary(float64(8.9)), 1},
+ {CreateBinary(uint64(9)), CreateBinary(float64(9.1)), -1},
+ }
+ for _, tt := range tests {
+ cmp := CompareBinary(tt.left, tt.right)
+ c.Assert(cmp == tt.result, IsTrue, Commentf("left: %v, right: %v, expect: %v, got: %v", tt.left, tt.right, tt.result, cmp))
+ }
+}
+
+func (s *testJSONSuite) TestBinaryJSONMerge(c *C) {
+ c.Parallel()
+ var tests = []struct {
+ suffixes []string
+ expected string
+ }{
+ {[]string{`{"a": 1}`, `{"b": 2}`}, `{"a": 1, "b": 2}`},
+ {[]string{`{"a": 1}`, `{"a": 2}`}, `{"a": [1, 2]}`},
+ {[]string{`[1]`, `[2]`}, `[1, 2]`},
+ {[]string{`{"a": 1}`, `[1]`}, `[{"a": 1}, 1]`},
+ {[]string{`[1]`, `{"a": 1}`}, `[1, {"a": 1}]`},
+ {[]string{`{"a": 1}`, `4`}, `[{"a": 1}, 4]`},
+ {[]string{`[1]`, `4`}, `[1, 4]`},
+ {[]string{`4`, `{"a": 1}`}, `[4, {"a": 1}]`},
+ {[]string{`4`, `1`}, `[4, 1]`},
+ {[]string{`{}`, `[]`}, `[{}]`},
+ }
+
+ for _, tt := range tests {
+ suffixes := make([]BinaryJSON, 0, len(tt.suffixes)+1)
+ for _, s := range tt.suffixes {
+ suffixes = append(suffixes, mustParseBinaryFromString(c, s))
+ }
+ result := MergeBinary(suffixes)
+ cmp := CompareBinary(result, mustParseBinaryFromString(c, tt.expected))
+ c.Assert(cmp, Equals, 0)
+ }
+}
+
+func mustParseBinaryFromString(c *C, s string) BinaryJSON {
+ bj, err := ParseBinaryFromString(s)
+ c.Assert(err, IsNil)
+ return bj
+}
+
+const benchStr = `{"a":[1,"2",{"aa":"bb"},4,null],"b":true,"c":null}`
+
+func BenchmarkBinaryMarshal(b *testing.B) {
+ b.ReportAllocs()
+ b.SetBytes(int64(len(benchStr)))
+ bj, _ := ParseBinaryFromString(benchStr)
+ for i := 0; i < b.N; i++ {
+ _, _ = bj.MarshalJSON()
+ }
+}
+
+func (s *testJSONSuite) TestBinaryJSONContains(c *C) {
+ c.Parallel()
+ var tests = []struct {
+ input string
+ target string
+ expected bool
+ }{
+ {`{}`, `{}`, true},
+ {`{"a":1}`, `{}`, true},
+ {`{"a":1}`, `1`, false},
+ {`{"a":[1]}`, `[1]`, false},
+ {`{"b":2, "c":3}`, `{"c":3}`, true},
+ {`1`, `1`, true},
+ {`[1]`, `1`, true},
+ {`[1,2]`, `[1]`, true},
+ {`[1,2]`, `[1,3]`, false},
+ {`[1,2]`, `["1"]`, false},
+ {`[1,2,[1,3]]`, `[1,3]`, true},
+ {`[1,2,[1,[5,[3]]]]`, `[1,3]`, true},
+ {`[1,2,[1,[5,{"a":[2,3]}]]]`, `[1,{"a":[3]}]`, true},
+ {`[{"a":1}]`, `{"a":1}`, true},
+ {`[{"a":1,"b":2}]`, `{"a":1}`, true},
+ {`[{"a":{"a":1},"b":2}]`, `{"a":1}`, false},
+ }
+
+ for _, tt := range tests {
+ obj := mustParseBinaryFromString(c, tt.input)
+ target := mustParseBinaryFromString(c, tt.target)
+ c.Assert(ContainsBinary(obj, target), Equals, tt.expected)
+ }
+}
+
+func (s *testJSONSuite) TestBinaryJSONCopy(c *C) {
+ c.Parallel()
+ strs := []string{
+ `{"a": [1, "2", {"aa": "bb"}, 4, null], "b": true, "c": null}`,
+ `{"aaaaaaaaaaa": [1, "2", {"aa": "bb"}, 4.1], "bbbbbbbbbb": true, "ccccccccc": "d"}`,
+ `[{"a": 1, "b": true}, 3, 3.5, "hello, world", null, true]`,
+ }
+ for _, str := range strs {
+ parsedBJ := mustParseBinaryFromString(c, str)
+ c.Assert(parsedBJ.Copy().String(), Equals, parsedBJ.String())
+ }
+}
+func (s *testJSONSuite) TestGetKeys(c *C) {
+ c.Parallel()
+ parsedBJ := mustParseBinaryFromString(c, "[]")
+ c.Assert(parsedBJ.GetKeys().String(), Equals, "[]")
+ parsedBJ = mustParseBinaryFromString(c, "{}")
+ c.Assert(parsedBJ.GetKeys().String(), Equals, "[]")
+
+ b := strings.Builder{}
+ b.WriteString("{\"")
+ for i := 0; i < 65536; i++ {
+ b.WriteByte('a')
+ }
+ b.WriteString("\": 1}")
+ parsedBJ, err := ParseBinaryFromString(b.String())
+ c.Assert(err, NotNil)
+ c.Assert(err.Error(), Equals, "[types:8129]TiDB does not yet support JSON objects with the key length >= 65536")
+}
+
+func (s *testJSONSuite) TestBinaryJSONDepth(c *C) {
+ c.Parallel()
+ var tests = []struct {
+ input string
+ expected int
+ }{
+ {`{}`, 1},
+ {`[]`, 1},
+ {`true`, 1},
+ {`[10, 20]`, 2},
+ {`[[], {}]`, 2},
+ {`[10, {"a": 20}]`, 3},
+ {`{"Person": {"Name": "Homer", "Age": 39, "Hobbies": ["Eating", "Sleeping"]} }`, 4},
+ }
+
+ for _, tt := range tests {
+ obj := mustParseBinaryFromString(c, tt.input)
+ c.Assert(obj.GetElemDepth(), Equals, tt.expected)
+ }
+}
+
+func (s *testJSONSuite) TestParseBinaryFromString(c *C) {
+ c.Parallel()
+ obj, err := ParseBinaryFromString("")
+ c.Assert(obj.String(), Equals, "")
+ c.Assert(err, ErrorMatches, "*The document is empty*")
+ obj, err = ParseBinaryFromString(`"a""`)
+ c.Assert(obj.String(), Equals, "")
+ c.Assert(err, ErrorMatches, "*The document root must not be followed by other values.*")
+}
+
+func (s *testJSONSuite) TestCreateBinary(c *C) {
+ c.Parallel()
+ bj := CreateBinary(int64(1 << 62))
+ c.Assert(bj.TypeCode, Equals, TypeCodeInt64)
+ c.Assert(bj.Value, NotNil)
+ bj = CreateBinary(123456789.1234567)
+ c.Assert(bj.TypeCode, Equals, TypeCodeFloat64)
+ bj = CreateBinary(0.00000001)
+ c.Assert(bj.TypeCode, Equals, TypeCodeFloat64)
+ bj = CreateBinary(1e-20)
+ c.Assert(bj.TypeCode, Equals, TypeCodeFloat64)
+ c.Assert(bj.Value, NotNil)
+ bj2 := CreateBinary(bj)
+ c.Assert(bj2.TypeCode, Equals, bj.TypeCode)
+ c.Assert(bj2.Value, NotNil)
+ func() {
+ defer func() {
+ r := recover()
+ c.Assert(r, ErrorMatches, "unknown type:.*")
+ }()
+ bj = CreateBinary(int8(123))
+ c.Assert(bj.TypeCode, Equals, bj.TypeCode)
+ }()
+
+}
+
+func (s *testJSONSuite) TestFunctions(c *C) {
+ c.Parallel()
+ testByte := []byte{'\\', 'b', 'f', 'n', 'r', 't', 'u', 'z', '0'}
+ testOutput, err := unquoteString(string(testByte))
+ c.Assert(testOutput, Equals, "\bfnrtuz0")
+ c.Assert(err, IsNil)
+ n, err := PeekBytesAsJSON(testByte)
+ c.Assert(n, Equals, 0)
+ c.Assert(err, ErrorMatches, "Invalid JSON bytes")
+ n, err = PeekBytesAsJSON([]byte(""))
+ c.Assert(n, Equals, 0)
+ c.Assert(err, ErrorMatches, "Cant peek from empty bytes")
+}
+
+func (s *testJSONSuite) TestBinaryJSONExtractCallback(c *C) {
+ bj1 := mustParseBinaryFromString(c, `{"\"hello\"": "world", "a": [1, "2", {"aa": "bb"}, 4.0, {"aa": "cc"}], "b": true, "c": ["d"]}`)
+ bj2 := mustParseBinaryFromString(c, `[{"a": 1, "b": true}, 3, 3.5, "hello, world", null, true]`)
+
+ type ExpectedPair struct {
+ path string
+ bj BinaryJSON
+ }
+ var tests = []struct {
+ bj BinaryJSON
+ pathExpr string
+ expected []ExpectedPair
+ }{
+ {bj1, "$.a", []ExpectedPair{
+ {"$.a", mustParseBinaryFromString(c, `[1, "2", {"aa": "bb"}, 4.0, {"aa": "cc"}]`)},
+ }},
+ {bj2, "$.a", []ExpectedPair{}},
+ {bj1, "$[0]", []ExpectedPair{}}, // in extractToCallback/Walk/Search, DON'T autowraped bj as an array.
+ {bj2, "$[0]", []ExpectedPair{
+ {"$[0]", mustParseBinaryFromString(c, `{"a": 1, "b": true}`)},
+ }},
+ {bj1, "$.a[2].aa", []ExpectedPair{
+ {"$.a[2].aa", mustParseBinaryFromString(c, `"bb"`)},
+ }},
+ {bj1, "$.a[*].aa", []ExpectedPair{
+ {"$.a[2].aa", mustParseBinaryFromString(c, `"bb"`)},
+ {"$.a[4].aa", mustParseBinaryFromString(c, `"cc"`)},
+ }},
+ {bj1, "$.*[0]", []ExpectedPair{
+ // {"$.\"hello\"[0]", mustParseBinaryFromString(c, `"world"`)}, // NO autowraped as an array.
+ {"$.a[0]", mustParseBinaryFromString(c, `1`)},
+ // {"$.b[0]", mustParseBinaryFromString(c, `true`)}, // NO autowraped as an array.
+ {"$.c[0]", mustParseBinaryFromString(c, `"d"`)},
+ }},
+ {bj1, `$.a[*]."aa"`, []ExpectedPair{
+ {"$.a[2].aa", mustParseBinaryFromString(c, `"bb"`)},
+ {"$.a[4].aa", mustParseBinaryFromString(c, `"cc"`)},
+ }},
+ {bj1, `$."\"hello\""`, []ExpectedPair{
+ {`$."\"hello\""`, mustParseBinaryFromString(c, `"world"`)},
+ }},
+ {bj1, `$**[1]`, []ExpectedPair{
+ {`$.a[1]`, mustParseBinaryFromString(c, `"2"`)},
+ }},
+ }
+
+ for _, tt := range tests {
+ pe, err := ParseJSONPathExpr(tt.pathExpr)
+ c.Assert(err, IsNil)
+
+ count := 0
+ cb := func(fullpath PathExpression, bj BinaryJSON) (stop bool, err error) {
+ c.Assert(count, Less, len(tt.expected))
+ if count < len(tt.expected) {
+ c.Assert(fullpath.String(), Equals, tt.expected[count].path)
+ c.Assert(bj.String(), Equals, tt.expected[count].bj.String())
+ }
+ count++
+ return false, nil
+ }
+ fullpath := PathExpression{legs: make([]pathLeg, 0), flags: pathExpressionFlag(0)}
+ _, err = tt.bj.extractToCallback(pe, cb, fullpath)
+ c.Assert(err, IsNil)
+ c.Assert(count, Equals, len(tt.expected))
+ }
+}
+
+func (s *testJSONSuite) TestBinaryJSONWalk(c *C) {
+ bj1 := mustParseBinaryFromString(c, `["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]`)
+ bj2 := mustParseBinaryFromString(c, `{}`)
+
+ type ExpectedPair struct {
+ path string
+ bj BinaryJSON
+ }
+ var tests = []struct {
+ bj BinaryJSON
+ paths []string
+ expected []ExpectedPair
+ }{
+ {bj1, []string{}, []ExpectedPair{
+ {`$`, mustParseBinaryFromString(c, `["abc", [{"k": "10"}, "def"], {"x":"abc"}, {"y":"bcd"}]`)},
+ {`$[0]`, mustParseBinaryFromString(c, `"abc"`)},
+ {`$[1]`, mustParseBinaryFromString(c, `[{"k": "10"}, "def"]`)},
+ {`$[1][0]`, mustParseBinaryFromString(c, `{"k": "10"}`)},
+ {`$[1][0].k`, mustParseBinaryFromString(c, `"10"`)},
+ {`$[1][1]`, mustParseBinaryFromString(c, `"def"`)},
+ {`$[2]`, mustParseBinaryFromString(c, `{"x":"abc"}`)},
+ {`$[2].x`, mustParseBinaryFromString(c, `"abc"`)},
+ {`$[3]`, mustParseBinaryFromString(c, `{"y":"bcd"}`)},
+ {`$[3].y`, mustParseBinaryFromString(c, `"bcd"`)},
+ }},
+ {bj1, []string{`$[1]`}, []ExpectedPair{
+ {`$[1]`, mustParseBinaryFromString(c, `[{"k": "10"}, "def"]`)},
+ {`$[1][0]`, mustParseBinaryFromString(c, `{"k": "10"}`)},
+ {`$[1][0].k`, mustParseBinaryFromString(c, `"10"`)},
+ {`$[1][1]`, mustParseBinaryFromString(c, `"def"`)},
+ }},
+ {bj1, []string{`$[1]`, `$[1]`}, []ExpectedPair{ // test for unique
+ {`$[1]`, mustParseBinaryFromString(c, `[{"k": "10"}, "def"]`)},
+ {`$[1][0]`, mustParseBinaryFromString(c, `{"k": "10"}`)},
+ {`$[1][0].k`, mustParseBinaryFromString(c, `"10"`)},
+ {`$[1][1]`, mustParseBinaryFromString(c, `"def"`)},
+ }},
+ {bj1, []string{`$.m`}, []ExpectedPair{}},
+ {bj2, []string{}, []ExpectedPair{
+ {`$`, mustParseBinaryFromString(c, `{}`)},
+ }},
+ }
+
+ for _, tt := range tests {
+ count := 0
+ cb := func(fullpath PathExpression, bj BinaryJSON) (stop bool, err error) {
+ c.Assert(count, Less, len(tt.expected))
+ if count < len(tt.expected) {
+ c.Assert(fullpath.String(), Equals, tt.expected[count].path)
+ c.Assert(bj.String(), Equals, tt.expected[count].bj.String())
+ }
+ count++
+ return false, nil
+ }
+
+ var err error
+ if len(tt.paths) > 0 {
+ peList := make([]PathExpression, 0, len(tt.paths))
+ for _, path := range tt.paths {
+ pe, errPath := ParseJSONPathExpr(path)
+ c.Assert(errPath, IsNil)
+ peList = append(peList, pe)
+ }
+ err = tt.bj.Walk(cb, peList...)
+ } else {
+ err = tt.bj.Walk(cb)
+ }
+ c.Assert(err, IsNil)
+ c.Assert(count, Equals, len(tt.expected))
+ }
+}
diff --git a/pkg/types/json/constants.go b/pkg/types/json/constants.go
new file mode 100644
index 0000000000000000000000000000000000000000..bd88f335833e4c9f23c36ee2e89a0e9176aebf97
--- /dev/null
+++ b/pkg/types/json/constants.go
@@ -0,0 +1,235 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package json
+
+import (
+ "encoding/binary"
+ "unicode/utf8"
+
+ mysql "matrixbase/pkg/errno"
+ "matrixbase/pkg/util/dbterror"
+)
+
+// TypeCode indicates JSON type.
+type TypeCode = byte
+
+const (
+ // TypeCodeObject indicates the JSON is an object.
+ TypeCodeObject TypeCode = 0x01
+ // TypeCodeArray indicates the JSON is an array.
+ TypeCodeArray TypeCode = 0x03
+ // TypeCodeLiteral indicates the JSON is a literal.
+ TypeCodeLiteral TypeCode = 0x04
+ // TypeCodeInt64 indicates the JSON is a signed integer.
+ TypeCodeInt64 TypeCode = 0x09
+ // TypeCodeUint64 indicates the JSON is a unsigned integer.
+ TypeCodeUint64 TypeCode = 0x0a
+ // TypeCodeFloat64 indicates the JSON is a double float number.
+ TypeCodeFloat64 TypeCode = 0x0b
+ // TypeCodeString indicates the JSON is a string.
+ TypeCodeString TypeCode = 0x0c
+)
+
+const (
+ // LiteralNil represents JSON null.
+ LiteralNil byte = 0x00
+ // LiteralTrue represents JSON true.
+ LiteralTrue byte = 0x01
+ // LiteralFalse represents JSON false.
+ LiteralFalse byte = 0x02
+)
+
+const unknownTypeCodeErrorMsg = "unknown type code: %d"
+const unknownTypeErrorMsg = "unknown type: %s"
+
+// safeSet holds the value true if the ASCII character with the given array
+// position can be represented inside a JSON string without any further
+// escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), and the backslash character ("\").
+var safeSet = [utf8.RuneSelf]bool{
+ ' ': true,
+ '!': true,
+ '"': false,
+ '#': true,
+ '$': true,
+ '%': true,
+ '&': true,
+ '\'': true,
+ '(': true,
+ ')': true,
+ '*': true,
+ '+': true,
+ ',': true,
+ '-': true,
+ '.': true,
+ '/': true,
+ '0': true,
+ '1': true,
+ '2': true,
+ '3': true,
+ '4': true,
+ '5': true,
+ '6': true,
+ '7': true,
+ '8': true,
+ '9': true,
+ ':': true,
+ ';': true,
+ '<': true,
+ '=': true,
+ '>': true,
+ '?': true,
+ '@': true,
+ 'A': true,
+ 'B': true,
+ 'C': true,
+ 'D': true,
+ 'E': true,
+ 'F': true,
+ 'G': true,
+ 'H': true,
+ 'I': true,
+ 'J': true,
+ 'K': true,
+ 'L': true,
+ 'M': true,
+ 'N': true,
+ 'O': true,
+ 'P': true,
+ 'Q': true,
+ 'R': true,
+ 'S': true,
+ 'T': true,
+ 'U': true,
+ 'V': true,
+ 'W': true,
+ 'X': true,
+ 'Y': true,
+ 'Z': true,
+ '[': true,
+ '\\': false,
+ ']': true,
+ '^': true,
+ '_': true,
+ '`': true,
+ 'a': true,
+ 'b': true,
+ 'c': true,
+ 'd': true,
+ 'e': true,
+ 'f': true,
+ 'g': true,
+ 'h': true,
+ 'i': true,
+ 'j': true,
+ 'k': true,
+ 'l': true,
+ 'm': true,
+ 'n': true,
+ 'o': true,
+ 'p': true,
+ 'q': true,
+ 'r': true,
+ 's': true,
+ 't': true,
+ 'u': true,
+ 'v': true,
+ 'w': true,
+ 'x': true,
+ 'y': true,
+ 'z': true,
+ '{': true,
+ '|': true,
+ '}': true,
+ '~': true,
+ '\u007f': true,
+}
+
+var (
+ hexChars = "0123456789abcdef"
+ endian = binary.LittleEndian
+)
+
+const (
+ headerSize = 8 // element size + data size.
+ dataSizeOff = 4
+ keyEntrySize = 6 // keyOff + keyLen
+ keyLenOff = 4
+ valTypeSize = 1
+ valEntrySize = 5
+)
+
+// jsonTypePrecedences is for comparing two json.
+// See: https://dev.mysql.com/doc/refman/5.7/en/json.html#json-comparison
+var jsonTypePrecedences = map[string]int{
+ "BLOB": -1,
+ "BIT": -2,
+ "OPAQUE": -3,
+ "DATETIME": -4,
+ "TIME": -5,
+ "DATE": -6,
+ "BOOLEAN": -7,
+ "ARRAY": -8,
+ "OBJECT": -9,
+ "STRING": -10,
+ "INTEGER": -11,
+ "UNSIGNED INTEGER": -11,
+ "DOUBLE": -11,
+ "NULL": -12,
+}
+
+// ModifyType is for modify a JSON. There are three valid values:
+// ModifyInsert, ModifyReplace and ModifySet.
+type ModifyType byte
+
+const (
+ // ModifyInsert is for insert a new element into a JSON.
+ ModifyInsert ModifyType = 0x01
+ // ModifyReplace is for replace an old elemList from a JSON.
+ ModifyReplace ModifyType = 0x02
+ // ModifySet = ModifyInsert | ModifyReplace
+ ModifySet ModifyType = 0x03
+)
+
+var (
+ // ErrInvalidJSONText means invalid JSON text.
+ ErrInvalidJSONText = dbterror.ClassJSON.NewStd(mysql.ErrInvalidJSONText)
+ // ErrInvalidJSONPath means invalid JSON path.
+ ErrInvalidJSONPath = dbterror.ClassJSON.NewStd(mysql.ErrInvalidJSONPath)
+ // ErrInvalidJSONData means invalid JSON data.
+ ErrInvalidJSONData = dbterror.ClassJSON.NewStd(mysql.ErrInvalidJSONData)
+ // ErrInvalidJSONPathWildcard means invalid JSON path that contain wildcard characters.
+ ErrInvalidJSONPathWildcard = dbterror.ClassJSON.NewStd(mysql.ErrInvalidJSONPathWildcard)
+ // ErrInvalidJSONContainsPathType means invalid JSON contains path type.
+ ErrInvalidJSONContainsPathType = dbterror.ClassJSON.NewStd(mysql.ErrInvalidJSONContainsPathType)
+ // ErrJSONDocumentNULLKey means that json's key is null
+ ErrJSONDocumentNULLKey = dbterror.ClassJSON.NewStd(mysql.ErrJSONDocumentNULLKey)
+ // ErrInvalidJSONPathArrayCell means invalid JSON path for an array cell.
+ ErrInvalidJSONPathArrayCell = dbterror.ClassJSON.NewStd(mysql.ErrInvalidJSONPathArrayCell)
+ // ErrUnsupportedSecondArgumentType means unsupported second argument type in json_objectagg
+ ErrUnsupportedSecondArgumentType = dbterror.ClassJSON.NewStd(mysql.ErrUnsupportedSecondArgumentType)
+ // ErrJSONObjectKeyTooLong means JSON object with key length >= 65536 which is not yet supported.
+ ErrJSONObjectKeyTooLong = dbterror.ClassTypes.NewStdErr(mysql.ErrJSONObjectKeyTooLong, mysql.MySQLErrName[mysql.ErrJSONObjectKeyTooLong])
+)
+
+// json_contains_path function type choices
+// See: https://dev.mysql.com/doc/refman/5.7/en/json-search-functions.html#function_json-contains-path
+const (
+ // 'all': 1 if all paths exist within the document, 0 otherwise.
+ ContainsPathAll = "all"
+ // 'one': 1 if at least one path exists within the document, 0 otherwise.
+ ContainsPathOne = "one"
+)
diff --git a/pkg/types/json/path_expr.go b/pkg/types/json/path_expr.go
new file mode 100644
index 0000000000000000000000000000000000000000..ede4ce11aa89b1057b9d5d8d16aab0f9307adad0
--- /dev/null
+++ b/pkg/types/json/path_expr.go
@@ -0,0 +1,262 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package json
+
+import (
+ "regexp"
+ "strconv"
+ "strings"
+
+ "github.com/pingcap/errors"
+)
+
+/*
+ From MySQL 5.7, JSON path expression grammar:
+ pathExpression ::= scope (pathLeg)*
+ scope ::= [ columnReference ] '$'
+ columnReference ::= // omit...
+ pathLeg ::= member | arrayLocation | '**'
+ member ::= '.' (keyName | '*')
+ arrayLocation ::= '[' (non-negative-integer | '*') ']'
+ keyName ::= ECMAScript-identifier | ECMAScript-string-literal
+
+ And some implementation limits in MySQL 5.7:
+ 1) columnReference in scope must be empty now;
+ 2) double asterisk(**) could not be last leg;
+
+ Examples:
+ select json_extract('{"a": "b", "c": [1, "2"]}', '$.a') -> "b"
+ select json_extract('{"a": "b", "c": [1, "2"]}', '$.c') -> [1, "2"]
+ select json_extract('{"a": "b", "c": [1, "2"]}', '$.a', '$.c') -> ["b", [1, "2"]]
+ select json_extract('{"a": "b", "c": [1, "2"]}', '$.c[0]') -> 1
+ select json_extract('{"a": "b", "c": [1, "2"]}', '$.c[2]') -> NULL
+ select json_extract('{"a": "b", "c": [1, "2"]}', '$.c[*]') -> [1, "2"]
+ select json_extract('{"a": "b", "c": [1, "2"]}', '$.*') -> ["b", [1, "2"]]
+*/
+
+// [a-zA-Z_][a-zA-Z0-9_]* matches any identifier;
+// "[^"\\]*(\\.[^"\\]*)*" matches any string literal which can carry escaped quotes;
+var jsonPathExprLegRe = regexp.MustCompile(`(\.\s*([a-zA-Z_][a-zA-Z0-9_]*|\*|"[^"\\]*(\\.[^"\\]*)*")|(\[\s*([0-9]+|\*)\s*\])|\*\*)`)
+
+type pathLegType byte
+
+const (
+ // pathLegKey indicates the path leg with '.key'.
+ pathLegKey pathLegType = 0x01
+ // pathLegIndex indicates the path leg with form '[number]'.
+ pathLegIndex pathLegType = 0x02
+ // pathLegDoubleAsterisk indicates the path leg with form '**'.
+ pathLegDoubleAsterisk pathLegType = 0x03
+)
+
+// pathLeg is only used by PathExpression.
+type pathLeg struct {
+ typ pathLegType
+ arrayIndex int // if typ is pathLegIndex, the value should be parsed into here.
+ dotKey string // if typ is pathLegKey, the key should be parsed into here.
+}
+
+// arrayIndexAsterisk is for parsing `*` into a number.
+// we need this number represent "all".
+const arrayIndexAsterisk = -1
+
+// pathExpressionFlag holds attributes of PathExpression
+type pathExpressionFlag byte
+
+const (
+ pathExpressionContainsAsterisk pathExpressionFlag = 0x01
+ pathExpressionContainsDoubleAsterisk pathExpressionFlag = 0x02
+)
+
+// containsAnyAsterisk returns true if pef contains any asterisk.
+func (pef pathExpressionFlag) containsAnyAsterisk() bool {
+ pef &= pathExpressionContainsAsterisk | pathExpressionContainsDoubleAsterisk
+ return byte(pef) != 0
+}
+
+// PathExpression is for JSON path expression.
+type PathExpression struct {
+ legs []pathLeg
+ flags pathExpressionFlag
+}
+
+// popOneLeg returns a pathLeg, and a child PathExpression without that leg.
+func (pe PathExpression) popOneLeg() (pathLeg, PathExpression) {
+ newPe := PathExpression{
+ legs: pe.legs[1:],
+ flags: 0,
+ }
+ for _, leg := range newPe.legs {
+ if leg.typ == pathLegIndex && leg.arrayIndex == -1 {
+ newPe.flags |= pathExpressionContainsAsterisk
+ } else if leg.typ == pathLegKey && leg.dotKey == "*" {
+ newPe.flags |= pathExpressionContainsAsterisk
+ } else if leg.typ == pathLegDoubleAsterisk {
+ newPe.flags |= pathExpressionContainsDoubleAsterisk
+ }
+ }
+ return pe.legs[0], newPe
+}
+
+// popOneLastLeg returns the a parent PathExpression and the last pathLeg
+func (pe PathExpression) popOneLastLeg() (PathExpression, pathLeg) {
+ lastLegIdx := len(pe.legs) - 1
+ lastLeg := pe.legs[lastLegIdx]
+ // It is used only in modification, it has been checked that there is no asterisks.
+ return PathExpression{legs: pe.legs[:lastLegIdx]}, lastLeg
+}
+
+// pushBackOneIndexLeg pushback one leg of INDEX type
+func (pe PathExpression) pushBackOneIndexLeg(index int) PathExpression {
+ newPe := PathExpression{
+ legs: append(pe.legs, pathLeg{typ: pathLegIndex, arrayIndex: index}),
+ flags: pe.flags,
+ }
+ if index == -1 {
+ newPe.flags |= pathExpressionContainsAsterisk
+ }
+ return newPe
+}
+
+// pushBackOneKeyLeg pushback one leg of KEY type
+func (pe PathExpression) pushBackOneKeyLeg(key string) PathExpression {
+ newPe := PathExpression{
+ legs: append(pe.legs, pathLeg{typ: pathLegKey, dotKey: key}),
+ flags: pe.flags,
+ }
+ if key == "*" {
+ newPe.flags |= pathExpressionContainsAsterisk
+ }
+ return newPe
+}
+
+// ContainsAnyAsterisk returns true if pe contains any asterisk.
+func (pe PathExpression) ContainsAnyAsterisk() bool {
+ return pe.flags.containsAnyAsterisk()
+}
+
+// ParseJSONPathExpr parses a JSON path expression. Returns a PathExpression
+// object which can be used in JSON_EXTRACT, JSON_SET and so on.
+func ParseJSONPathExpr(pathExpr string) (pe PathExpression, err error) {
+ // Find the position of first '$'. If any no-blank characters in
+ // pathExpr[0: dollarIndex), return an ErrInvalidJSONPath error.
+ dollarIndex := strings.Index(pathExpr, "$")
+ if dollarIndex < 0 {
+ err = ErrInvalidJSONPath.GenWithStackByArgs(pathExpr)
+ return
+ }
+ for i := 0; i < dollarIndex; i++ {
+ if !isBlank(rune(pathExpr[i])) {
+ err = ErrInvalidJSONPath.GenWithStackByArgs(pathExpr)
+ return
+ }
+ }
+
+ pathExprSuffix := strings.TrimFunc(pathExpr[dollarIndex+1:], isBlank)
+ indices := jsonPathExprLegRe.FindAllStringIndex(pathExprSuffix, -1)
+ if len(indices) == 0 && len(pathExprSuffix) != 0 {
+ err = ErrInvalidJSONPath.GenWithStackByArgs(pathExpr)
+ return
+ }
+
+ pe.legs = make([]pathLeg, 0, len(indices))
+ pe.flags = pathExpressionFlag(0)
+
+ lastEnd := 0
+ for _, indice := range indices {
+ start, end := indice[0], indice[1]
+
+ // Check all characters between two legs are blank.
+ for i := lastEnd; i < start; i++ {
+ if !isBlank(rune(pathExprSuffix[i])) {
+ err = ErrInvalidJSONPath.GenWithStackByArgs(pathExpr)
+ return
+ }
+ }
+ lastEnd = end
+
+ if pathExprSuffix[start] == '[' {
+ // The leg is an index of a JSON array.
+ var leg = strings.TrimFunc(pathExprSuffix[start+1:end], isBlank)
+ var indexStr = strings.TrimFunc(leg[0:len(leg)-1], isBlank)
+ var index int
+ if len(indexStr) == 1 && indexStr[0] == '*' {
+ pe.flags |= pathExpressionContainsAsterisk
+ index = arrayIndexAsterisk
+ } else {
+ if index, err = strconv.Atoi(indexStr); err != nil {
+ err = errors.Trace(err)
+ return
+ }
+ }
+ pe.legs = append(pe.legs, pathLeg{typ: pathLegIndex, arrayIndex: index})
+ } else if pathExprSuffix[start] == '.' {
+ // The leg is a key of a JSON object.
+ var key = strings.TrimFunc(pathExprSuffix[start+1:end], isBlank)
+ if len(key) == 1 && key[0] == '*' {
+ pe.flags |= pathExpressionContainsAsterisk
+ } else if key[0] == '"' {
+ // We need unquote the origin string.
+ if key, err = unquoteString(key[1 : len(key)-1]); err != nil {
+ err = ErrInvalidJSONPath.GenWithStackByArgs(pathExpr)
+ return
+ }
+ }
+ pe.legs = append(pe.legs, pathLeg{typ: pathLegKey, dotKey: key})
+ } else {
+ // The leg is '**'.
+ pe.flags |= pathExpressionContainsDoubleAsterisk
+ pe.legs = append(pe.legs, pathLeg{typ: pathLegDoubleAsterisk})
+ }
+ }
+ if len(pe.legs) > 0 {
+ // The last leg of a path expression cannot be '**'.
+ if pe.legs[len(pe.legs)-1].typ == pathLegDoubleAsterisk {
+ err = ErrInvalidJSONPath.GenWithStackByArgs(pathExpr)
+ return
+ }
+ }
+ return
+}
+
+func isBlank(c rune) bool {
+ if c == '\n' || c == '\r' || c == '\t' || c == ' ' {
+ return true
+ }
+ return false
+}
+
+func (pe PathExpression) String() string {
+ var s strings.Builder
+
+ s.WriteString("$")
+ for _, leg := range pe.legs {
+ switch leg.typ {
+ case pathLegIndex:
+ if leg.arrayIndex == -1 {
+ s.WriteString("[*]")
+ } else {
+ s.WriteString("[")
+ s.WriteString(strconv.Itoa(leg.arrayIndex))
+ s.WriteString("]")
+ }
+ case pathLegKey:
+ s.WriteString(".")
+ s.WriteString(quoteString(leg.dotKey))
+ case pathLegDoubleAsterisk:
+ s.WriteString("**")
+ }
+ }
+ return s.String()
+}
diff --git a/pkg/types/json/path_expr_test.go b/pkg/types/json/path_expr_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..5efc648283d0a03d7064fd1d7fa50437f0685b73
--- /dev/null
+++ b/pkg/types/json/path_expr_test.go
@@ -0,0 +1,129 @@
+// Copyright 2017 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package json
+
+import (
+ . "github.com/pingcap/check"
+)
+
+func (s *testJSONSuite) TestContainsAnyAsterisk(c *C) {
+ var tests = []struct {
+ exprString string
+ containsAsterisks bool
+ }{
+ {"$.a[b]", false},
+ {"$.a[*]", true},
+ {"$.*[b]", true},
+ {"$**.a[b]", true},
+ }
+ for _, tt := range tests {
+ pe, err := ParseJSONPathExpr(tt.exprString)
+ c.Assert(err, IsNil)
+ c.Assert(pe.flags.containsAnyAsterisk(), Equals, tt.containsAsterisks)
+ }
+}
+
+func (s *testJSONSuite) TestValidatePathExpr(c *C) {
+ var tests = []struct {
+ exprString string
+ success bool
+ legs int
+ }{
+ {` $ `, true, 0},
+ {" $ . key1 [ 3 ]\t[*].*.key3", true, 5},
+ {" $ . key1 [ 3 ]**[*].*.key3", true, 6},
+ {`$."key1 string"[ 3 ][*].*.key3`, true, 5},
+ {`$."hello \"escaped quotes\" world\\n"[3][*].*.key3`, true, 5},
+
+ {`$.\"escaped quotes\"[3][*].*.key3`, false, 0},
+ {`$.hello \"escaped quotes\" world[3][*].*.key3`, false, 0},
+ {`$NoValidLegsHere`, false, 0},
+ {`$ No Valid Legs Here .a.b.c`, false, 0},
+ }
+
+ for _, tt := range tests {
+ pe, err := ParseJSONPathExpr(tt.exprString)
+ if tt.success {
+ c.Assert(err, IsNil)
+ c.Assert(len(pe.legs), Equals, tt.legs)
+ } else {
+ c.Assert(err, NotNil)
+ }
+ }
+}
+
+func (s *testJSONSuite) TestPathExprToString(c *C) {
+ var tests = []struct {
+ exprString string
+ }{
+ {"$.a[1]"},
+ {"$.a[*]"},
+ {"$.*[2]"},
+ {"$**.a[3]"},
+ {`$."\"hello\""`},
+ }
+ for _, tt := range tests {
+ pe, err := ParseJSONPathExpr(tt.exprString)
+ c.Assert(err, IsNil)
+ c.Assert(pe.String(), Equals, tt.exprString)
+ }
+}
+
+func (s *testJSONSuite) TestPushBackOneIndexLeg(c *C) {
+ var tests = []struct {
+ exprString string
+ index int
+ expected string
+ containsAnyAsterisk bool
+ }{
+ {"$", 1, "$[1]", false},
+ {"$.a[1]", 1, "$.a[1][1]", false},
+ {"$.a[1]", -1, "$.a[1][*]", true},
+ {"$.a[*]", 10, "$.a[*][10]", true},
+ {"$.*[2]", 2, "$.*[2][2]", true},
+ {"$**.a[3]", 3, "$**.a[3][3]", true},
+ }
+ for _, tt := range tests {
+ pe, err := ParseJSONPathExpr(tt.exprString)
+ c.Assert(err, IsNil)
+
+ pe = pe.pushBackOneIndexLeg(tt.index)
+ c.Assert(pe.String(), Equals, tt.expected)
+ c.Assert(pe.ContainsAnyAsterisk(), Equals, tt.containsAnyAsterisk)
+ }
+}
+
+func (s *testJSONSuite) TestPushBackOneKeyLeg(c *C) {
+ var tests = []struct {
+ exprString string
+ key string
+ expected string
+ containsAnyAsterisk bool
+ }{
+ {"$", "aa", "$.aa", false},
+ {"$.a[1]", "aa", "$.a[1].aa", false},
+ {"$.a[1]", "*", "$.a[1].*", true},
+ {"$.a[*]", "k", "$.a[*].k", true},
+ {"$.*[2]", "bb", "$.*[2].bb", true},
+ {"$**.a[3]", "cc", "$**.a[3].cc", true},
+ }
+ for _, tt := range tests {
+ pe, err := ParseJSONPathExpr(tt.exprString)
+ c.Assert(err, IsNil)
+
+ pe = pe.pushBackOneKeyLeg(tt.key)
+ c.Assert(pe.String(), Equals, tt.expected)
+ c.Assert(pe.ContainsAnyAsterisk(), Equals, tt.containsAnyAsterisk)
+ }
+}
diff --git a/pkg/types/mydecimal.go b/pkg/types/mydecimal.go
new file mode 100644
index 0000000000000000000000000000000000000000..acd5ca48ff01de022b5fedcca72181ffa695e764
--- /dev/null
+++ b/pkg/types/mydecimal.go
@@ -0,0 +1,2354 @@
+// Copyright 2016 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "math"
+ "strconv"
+
+ "github.com/pingcap/errors"
+ "github.com/pingcap/log"
+ "github.com/pingcap/parser/mysql"
+ "github.com/pingcap/parser/terror"
+ "go.uber.org/zap"
+)
+
+// RoundMode is the type for round mode.
+type RoundMode int32
+
+// constant values.
+const (
+ ten0 = 1
+ ten1 = 10
+ ten2 = 100
+ ten3 = 1000
+ ten4 = 10000
+ ten5 = 100000
+ ten6 = 1000000
+ ten7 = 10000000
+ ten8 = 100000000
+ ten9 = 1000000000
+
+ maxWordBufLen = 9 // A MyDecimal holds 9 words.
+ digitsPerWord = 9 // A word holds 9 digits.
+ wordSize = 4 // A word is 4 bytes int32.
+ digMask = ten8
+ wordBase = ten9
+ wordMax = wordBase - 1
+ notFixedDec = 31
+
+ DivFracIncr = 4
+
+ // ModeHalfEven rounds normally.
+ ModeHalfEven RoundMode = 5
+ // Truncate just truncates the decimal.
+ ModeTruncate RoundMode = 10
+ // Ceiling is not supported now.
+ modeCeiling RoundMode = 0
+)
+
+var (
+ wordBufLen = 9
+ mod9 = [128]int8{
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 0, 1,
+ }
+ div9 = [128]int{
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 9, 9, 9, 9, 9, 9, 9, 9, 9,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 11, 11, 11, 11, 11, 11, 11, 11, 11,
+ 12, 12, 12, 12, 12, 12, 12, 12, 12,
+ 13, 13, 13, 13, 13, 13, 13, 13, 13,
+ 14, 14,
+ }
+ powers10 = [10]int32{ten0, ten1, ten2, ten3, ten4, ten5, ten6, ten7, ten8, ten9}
+ dig2bytes = [10]int{0, 1, 1, 2, 2, 3, 3, 4, 4, 4}
+ fracMax = [8]int32{
+ 900000000,
+ 990000000,
+ 999000000,
+ 999900000,
+ 999990000,
+ 999999000,
+ 999999900,
+ 999999990,
+ }
+ zeroMyDecimal = MyDecimal{}
+)
+
+// get the zero of MyDecimal with the specified result fraction digits
+func zeroMyDecimalWithFrac(frac int8) MyDecimal {
+ zero := MyDecimal{}
+ zero.digitsFrac = frac
+ zero.resultFrac = frac
+ return zero
+}
+
+// add adds a and b and carry, returns the sum and new carry.
+func add(a, b, carry int32) (int32, int32) {
+ sum := a + b + carry
+ if sum >= wordBase {
+ carry = 1
+ sum -= wordBase
+ } else {
+ carry = 0
+ }
+ return sum, carry
+}
+
+// add2 adds a and b and carry, returns the sum and new carry.
+// It is only used in DecimalMul.
+func add2(a, b, carry int32) (int32, int32) {
+ sum := int64(a) + int64(b) + int64(carry)
+ if sum >= wordBase {
+ carry = 1
+ sum -= wordBase
+ } else {
+ carry = 0
+ }
+
+ if sum >= wordBase {
+ sum -= wordBase
+ carry++
+ }
+ return int32(sum), carry
+}
+
+// sub subtracts b and carry from a, returns the diff and new carry.
+func sub(a, b, carry int32) (int32, int32) {
+ diff := a - b - carry
+ if diff < 0 {
+ carry = 1
+ diff += wordBase
+ } else {
+ carry = 0
+ }
+ return diff, carry
+}
+
+// sub2 subtracts b and carry from a, returns the diff and new carry.
+// the new carry may be 2.
+func sub2(a, b, carry int32) (int32, int32) {
+ diff := a - b - carry
+ if diff < 0 {
+ carry = 1
+ diff += wordBase
+ } else {
+ carry = 0
+ }
+ if diff < 0 {
+ diff += wordBase
+ carry++
+ }
+ return diff, carry
+}
+
+// fixWordCntError limits word count in wordBufLen, and returns overflow or truncate error.
+func fixWordCntError(wordsInt, wordsFrac int) (newWordsInt int, newWordsFrac int, err error) {
+ if wordsInt+wordsFrac > wordBufLen {
+ if wordsInt > wordBufLen {
+ return wordBufLen, 0, ErrOverflow
+ }
+ return wordsInt, wordBufLen - wordsInt, ErrTruncated
+ }
+ return wordsInt, wordsFrac, nil
+}
+
+/*
+ countLeadingZeroes returns the number of leading zeroes that can be removed from fraction.
+
+ @param i start index
+ @param word value to compare against list of powers of 10
+*/
+func countLeadingZeroes(i int, word int32) int {
+ leading := 0
+ for word < powers10[i] {
+ i--
+ leading++
+ }
+ return leading
+}
+
+/*
+ countTrailingZeros returns the number of trailing zeroes that can be removed from fraction.
+
+ @param i start index
+ @param word value to compare against list of powers of 10
+*/
+func countTrailingZeroes(i int, word int32) int {
+ trailing := 0
+ for word%powers10[i] == 0 {
+ i++
+ trailing++
+ }
+ return trailing
+}
+
+func digitsToWords(digits int) int {
+ if digits+digitsPerWord-1 >= 0 && digits+digitsPerWord-1 < 128 {
+ return div9[digits+digitsPerWord-1]
+ }
+ return (digits + digitsPerWord - 1) / digitsPerWord
+}
+
+// MyDecimalStructSize is the struct size of MyDecimal.
+const MyDecimalStructSize = 40
+
+// MyDecimal represents a decimal value.
+type MyDecimal struct {
+ digitsInt int8 // the number of *decimal* digits before the point.
+
+ digitsFrac int8 // the number of decimal digits after the point.
+
+ resultFrac int8 // result fraction digits.
+
+ negative bool
+
+ // wordBuf is an array of int32 words.
+ // A word is an int32 value can hold 9 digits.(0 <= word < wordBase)
+ wordBuf [maxWordBufLen]int32
+}
+
+// IsNegative returns whether a decimal is negative.
+func (d *MyDecimal) IsNegative() bool {
+ return d.negative
+}
+
+// GetDigitsFrac returns the digitsFrac.
+func (d *MyDecimal) GetDigitsFrac() int8 {
+ return d.digitsFrac
+}
+
+// GetDigitsInt returns the digitsInt.
+func (d *MyDecimal) GetDigitsInt() int8 {
+ return d.digitsInt
+}
+
+// String returns the decimal string representation rounded to resultFrac.
+func (d *MyDecimal) String() string {
+ tmp := *d
+ err := tmp.Round(&tmp, int(tmp.resultFrac), ModeHalfEven)
+ terror.Log(errors.Trace(err))
+ return string(tmp.ToString())
+}
+
+func (d *MyDecimal) stringSize() int {
+ // sign, zero integer and dot.
+ return int(d.digitsInt + d.digitsFrac + 3)
+}
+
+func (d *MyDecimal) removeLeadingZeros() (wordIdx int, digitsInt int) {
+ digitsInt = int(d.digitsInt)
+ i := ((digitsInt - 1) % digitsPerWord) + 1
+ for digitsInt > 0 && d.wordBuf[wordIdx] == 0 {
+ digitsInt -= i
+ i = digitsPerWord
+ wordIdx++
+ }
+ if digitsInt > 0 {
+ digitsInt -= countLeadingZeroes((digitsInt-1)%digitsPerWord, d.wordBuf[wordIdx])
+ } else {
+ digitsInt = 0
+ }
+ return
+}
+
+func (d *MyDecimal) removeTrailingZeros() (lastWordIdx int, digitsFrac int) {
+ digitsFrac = int(d.digitsFrac)
+ i := ((digitsFrac - 1) % digitsPerWord) + 1
+ lastWordIdx = digitsToWords(int(d.digitsInt)) + digitsToWords(int(d.digitsFrac))
+ for digitsFrac > 0 && d.wordBuf[lastWordIdx-1] == 0 {
+ digitsFrac -= i
+ i = digitsPerWord
+ lastWordIdx--
+ }
+ if digitsFrac > 0 {
+ digitsFrac -= countTrailingZeroes(9-((digitsFrac-1)%digitsPerWord), d.wordBuf[lastWordIdx-1])
+ } else {
+ digitsFrac = 0
+ }
+ return
+}
+
+// ToString converts decimal to its printable string representation without rounding.
+//
+// RETURN VALUE
+//
+// str - result string
+// errCode - eDecOK/eDecTruncate/eDecOverflow
+//
+func (d *MyDecimal) ToString() (str []byte) {
+ str = make([]byte, d.stringSize())
+ digitsFrac := int(d.digitsFrac)
+ wordStartIdx, digitsInt := d.removeLeadingZeros()
+ if digitsInt+digitsFrac == 0 {
+ digitsInt = 1
+ wordStartIdx = 0
+ }
+
+ digitsIntLen := digitsInt
+ if digitsIntLen == 0 {
+ digitsIntLen = 1
+ }
+ digitsFracLen := digitsFrac
+ length := digitsIntLen + digitsFracLen
+ if d.negative {
+ length++
+ }
+ if digitsFrac > 0 {
+ length++
+ }
+ str = str[:length]
+ strIdx := 0
+ if d.negative {
+ str[strIdx] = '-'
+ strIdx++
+ }
+ var fill int
+ if digitsFrac > 0 {
+ fracIdx := strIdx + digitsIntLen
+ fill = digitsFracLen - digitsFrac
+ wordIdx := wordStartIdx + digitsToWords(digitsInt)
+ str[fracIdx] = '.'
+ fracIdx++
+ for ; digitsFrac > 0; digitsFrac -= digitsPerWord {
+ x := d.wordBuf[wordIdx]
+ wordIdx++
+ for i := myMin(digitsFrac, digitsPerWord); i > 0; i-- {
+ y := x / digMask
+ str[fracIdx] = byte(y) + '0'
+ fracIdx++
+ x -= y * digMask
+ x *= 10
+ }
+ }
+ for ; fill > 0; fill-- {
+ str[fracIdx] = '0'
+ fracIdx++
+ }
+ }
+ fill = digitsIntLen - digitsInt
+ if digitsInt == 0 {
+ fill-- /* symbol 0 before digital point */
+ }
+ for ; fill > 0; fill-- {
+ str[strIdx] = '0'
+ strIdx++
+ }
+ if digitsInt > 0 {
+ strIdx += digitsInt
+ wordIdx := wordStartIdx + digitsToWords(digitsInt)
+ for ; digitsInt > 0; digitsInt -= digitsPerWord {
+ wordIdx--
+ x := d.wordBuf[wordIdx]
+ for i := myMin(digitsInt, digitsPerWord); i > 0; i-- {
+ y := x / 10
+ strIdx--
+ str[strIdx] = '0' + byte(x-y*10)
+ x = y
+ }
+ }
+ } else {
+ str[strIdx] = '0'
+ }
+ return
+}
+
+// FromString parses decimal from string.
+func (d *MyDecimal) FromString(str []byte) error {
+ // strErr is used to check str is bad number or not
+ var strErr error
+ for i := 0; i < len(str); i++ {
+ if !isSpace(str[i]) {
+ str = str[i:]
+ break
+ }
+ }
+ if len(str) == 0 {
+ *d = zeroMyDecimal
+ return ErrBadNumber
+ }
+ switch str[0] {
+ case '-':
+ d.negative = true
+ fallthrough
+ case '+':
+ str = str[1:]
+ }
+ var strIdx int
+ for strIdx < len(str) && isDigit(str[strIdx]) {
+ strIdx++
+ }
+ digitsInt := strIdx
+ var digitsFrac int
+ var endIdx int
+ if strIdx < len(str) && str[strIdx] == '.' {
+ endIdx = strIdx + 1
+ for endIdx < len(str) && isDigit(str[endIdx]) {
+ endIdx++
+ }
+ digitsFrac = endIdx - strIdx - 1
+ } else if strIdx < len(str) && (str[strIdx] != 'e' && str[strIdx] != 'E' && str[strIdx] != ' ') {
+ strErr = ErrBadNumber
+ } else {
+ digitsFrac = 0
+ endIdx = strIdx
+ }
+ if digitsInt+digitsFrac == 0 {
+ *d = zeroMyDecimal
+ return ErrBadNumber
+ }
+ wordsInt := digitsToWords(digitsInt)
+ wordsFrac := digitsToWords(digitsFrac)
+ wordsInt, wordsFrac, err := fixWordCntError(wordsInt, wordsFrac)
+ if err != nil {
+ digitsFrac = wordsFrac * digitsPerWord
+ if err == ErrOverflow {
+ digitsInt = wordsInt * digitsPerWord
+ }
+ }
+ d.digitsInt = int8(digitsInt)
+ d.digitsFrac = int8(digitsFrac)
+ wordIdx := wordsInt
+ strIdxTmp := strIdx
+ var word int32
+ var innerIdx int
+ for digitsInt > 0 {
+ digitsInt--
+ strIdx--
+ word += int32(str[strIdx]-'0') * powers10[innerIdx]
+ innerIdx++
+ if innerIdx == digitsPerWord {
+ wordIdx--
+ d.wordBuf[wordIdx] = word
+ word = 0
+ innerIdx = 0
+ }
+ }
+ if innerIdx != 0 {
+ wordIdx--
+ d.wordBuf[wordIdx] = word
+ }
+
+ wordIdx = wordsInt
+ strIdx = strIdxTmp
+ word = 0
+ innerIdx = 0
+ for digitsFrac > 0 {
+ digitsFrac--
+ strIdx++
+ word = int32(str[strIdx]-'0') + word*10
+ innerIdx++
+ if innerIdx == digitsPerWord {
+ d.wordBuf[wordIdx] = word
+ wordIdx++
+ word = 0
+ innerIdx = 0
+ }
+ }
+ if innerIdx != 0 {
+ d.wordBuf[wordIdx] = word * powers10[digitsPerWord-innerIdx]
+ }
+ if endIdx+1 <= len(str) && (str[endIdx] == 'e' || str[endIdx] == 'E') {
+ exponent, err1 := strToInt(string(str[endIdx+1:]))
+ if err1 != nil {
+ err = errors.Cause(err1)
+ if err != ErrTruncated {
+ *d = zeroMyDecimal
+ }
+ }
+ if exponent > math.MaxInt32/2 {
+ negative := d.negative
+ maxDecimal(wordBufLen*digitsPerWord, 0, d)
+ d.negative = negative
+ err = ErrOverflow
+ }
+ if exponent < math.MinInt32/2 && err != ErrOverflow {
+ *d = zeroMyDecimal
+ err = ErrTruncated
+ }
+ if err != ErrOverflow {
+ shiftErr := d.Shift(int(exponent))
+ if shiftErr != nil {
+ if shiftErr == ErrOverflow {
+ negative := d.negative
+ maxDecimal(wordBufLen*digitsPerWord, 0, d)
+ d.negative = negative
+ }
+ err = shiftErr
+ }
+ }
+ }
+ allZero := true
+ for i := 0; i < wordBufLen; i++ {
+ if d.wordBuf[i] != 0 {
+ allZero = false
+ break
+ }
+ }
+ if allZero {
+ d.negative = false
+ }
+ d.resultFrac = d.digitsFrac
+ if strErr != nil {
+ return strErr
+ }
+ return err
+}
+
+// Shift shifts decimal digits in given number (with rounding if it need), shift > 0 means shift to left shift,
+// shift < 0 means right shift. In fact it is multiplying on 10^shift.
+//
+// RETURN
+// eDecOK OK
+// eDecOverflow operation lead to overflow, number is untoched
+// eDecTruncated number was rounded to fit into buffer
+//
+func (d *MyDecimal) Shift(shift int) error {
+ var err error
+ if shift == 0 {
+ return nil
+ }
+ var (
+ // digitBegin is index of first non zero digit (all indexes from 0).
+ digitBegin int
+ // digitEnd is index of position after last decimal digit.
+ digitEnd int
+ // point is index of digit position just after point.
+ point = digitsToWords(int(d.digitsInt)) * digitsPerWord
+ // new point position.
+ newPoint = point + shift
+ // number of digits in result.
+ digitsInt, digitsFrac int
+ newFront int
+ )
+ digitBegin, digitEnd = d.digitBounds()
+ if digitBegin == digitEnd {
+ *d = zeroMyDecimal
+ return nil
+ }
+
+ digitsInt = newPoint - digitBegin
+ if digitsInt < 0 {
+ digitsInt = 0
+ }
+ digitsFrac = digitEnd - newPoint
+ if digitsFrac < 0 {
+ digitsFrac = 0
+ }
+ wordsInt := digitsToWords(digitsInt)
+ wordsFrac := digitsToWords(digitsFrac)
+ newLen := wordsInt + wordsFrac
+ if newLen > wordBufLen {
+ lack := newLen - wordBufLen
+ if wordsFrac < lack {
+ return ErrOverflow
+ }
+ /* cut off fraction part to allow new number to fit in our buffer */
+ err = ErrTruncated
+ wordsFrac -= lack
+ diff := digitsFrac - wordsFrac*digitsPerWord
+ err1 := d.Round(d, digitEnd-point-diff, ModeHalfEven)
+ if err1 != nil {
+ return errors.Trace(err1)
+ }
+ digitEnd -= diff
+ digitsFrac = wordsFrac * digitsPerWord
+ if digitEnd <= digitBegin {
+ /*
+ We lost all digits (they will be shifted out of buffer), so we can
+ just return 0.
+ */
+ *d = zeroMyDecimal
+ return ErrTruncated
+ }
+ }
+
+ if shift%digitsPerWord != 0 {
+ var lMiniShift, rMiniShift, miniShift int
+ var doLeft bool
+ /*
+ Calculate left/right shift to align decimal digits inside our bug
+ digits correctly.
+ */
+ if shift > 0 {
+ lMiniShift = shift % digitsPerWord
+ rMiniShift = digitsPerWord - lMiniShift
+ doLeft = lMiniShift <= digitBegin
+ } else {
+ rMiniShift = (-shift) % digitsPerWord
+ lMiniShift = digitsPerWord - rMiniShift
+ doLeft = (digitsPerWord*wordBufLen - digitEnd) < rMiniShift
+ }
+ if doLeft {
+ d.doMiniLeftShift(lMiniShift, digitBegin, digitEnd)
+ miniShift = -lMiniShift
+ } else {
+ d.doMiniRightShift(rMiniShift, digitBegin, digitEnd)
+ miniShift = rMiniShift
+ }
+ newPoint += miniShift
+ /*
+ If number is shifted and correctly aligned in buffer we can finish.
+ */
+ if shift+miniShift == 0 && (newPoint-digitsInt) < digitsPerWord {
+ d.digitsInt = int8(digitsInt)
+ d.digitsFrac = int8(digitsFrac)
+ return err /* already shifted as it should be */
+ }
+ digitBegin += miniShift
+ digitEnd += miniShift
+ }
+
+ /* if new 'decimal front' is in first digit, we do not need move digits */
+ newFront = newPoint - digitsInt
+ if newFront >= digitsPerWord || newFront < 0 {
+ /* need to move digits */
+ var wordShift int
+ if newFront > 0 {
+ /* move left */
+ wordShift = newFront / digitsPerWord
+ to := digitBegin/digitsPerWord - wordShift
+ barier := (digitEnd-1)/digitsPerWord - wordShift
+ for ; to <= barier; to++ {
+ d.wordBuf[to] = d.wordBuf[to+wordShift]
+ }
+ for barier += wordShift; to <= barier; to++ {
+ d.wordBuf[to] = 0
+ }
+ wordShift = -wordShift
+ } else {
+ /* move right */
+ wordShift = (1 - newFront) / digitsPerWord
+ to := (digitEnd-1)/digitsPerWord + wordShift
+ barier := digitBegin/digitsPerWord + wordShift
+ for ; to >= barier; to-- {
+ d.wordBuf[to] = d.wordBuf[to-wordShift]
+ }
+ for barier -= wordShift; to >= barier; to-- {
+ d.wordBuf[to] = 0
+ }
+ }
+ digitShift := wordShift * digitsPerWord
+ digitBegin += digitShift
+ digitEnd += digitShift
+ newPoint += digitShift
+ }
+ /*
+ If there are gaps then fill them with 0.
+
+ Only one of following 'for' loops will work because wordIdxBegin <= wordIdxEnd.
+ */
+ wordIdxBegin := digitBegin / digitsPerWord
+ wordIdxEnd := (digitEnd - 1) / digitsPerWord
+ wordIdxNewPoint := 0
+
+ /* We don't want negative new_point below */
+ if newPoint != 0 {
+ wordIdxNewPoint = (newPoint - 1) / digitsPerWord
+ }
+ if wordIdxNewPoint > wordIdxEnd {
+ for wordIdxNewPoint > wordIdxEnd {
+ d.wordBuf[wordIdxNewPoint] = 0
+ wordIdxNewPoint--
+ }
+ } else {
+ for ; wordIdxNewPoint < wordIdxBegin; wordIdxNewPoint++ {
+ d.wordBuf[wordIdxNewPoint] = 0
+ }
+ }
+ d.digitsInt = int8(digitsInt)
+ d.digitsFrac = int8(digitsFrac)
+ return err
+}
+
+/*
+ digitBounds returns bounds of decimal digits in the number.
+
+ start - index (from 0 ) of first decimal digits.
+ end - index of position just after last decimal digit.
+*/
+func (d *MyDecimal) digitBounds() (start, end int) {
+ var i int
+ bufBeg := 0
+ bufLen := digitsToWords(int(d.digitsInt)) + digitsToWords(int(d.digitsFrac))
+ bufEnd := bufLen - 1
+
+ /* find non-zero digit from number beginning */
+ for bufBeg < bufLen && d.wordBuf[bufBeg] == 0 {
+ bufBeg++
+ }
+ if bufBeg >= bufLen {
+ return 0, 0
+ }
+
+ /* find non-zero decimal digit from number beginning */
+ if bufBeg == 0 && d.digitsInt > 0 {
+ i = (int(d.digitsInt) - 1) % digitsPerWord
+ start = digitsPerWord - i - 1
+ } else {
+ i = digitsPerWord - 1
+ start = bufBeg * digitsPerWord
+ }
+ if bufBeg < bufLen {
+ start += countLeadingZeroes(i, d.wordBuf[bufBeg])
+ }
+
+ /* find non-zero digit at the end */
+ for bufEnd > bufBeg && d.wordBuf[bufEnd] == 0 {
+ bufEnd--
+ }
+ /* find non-zero decimal digit from the end */
+ if bufEnd == bufLen-1 && d.digitsFrac > 0 {
+ i = (int(d.digitsFrac)-1)%digitsPerWord + 1
+ end = bufEnd*digitsPerWord + i
+ i = digitsPerWord - i + 1
+ } else {
+ end = (bufEnd + 1) * digitsPerWord
+ i = 1
+ }
+ end -= countTrailingZeroes(i, d.wordBuf[bufEnd])
+ return start, end
+}
+
+/*
+ doMiniLeftShift does left shift for alignment of data in buffer.
+
+ shift number of decimal digits on which it should be shifted
+ beg/end bounds of decimal digits (see digitsBounds())
+
+ NOTE
+ Result fitting in the buffer should be garanted.
+ 'shift' have to be from 1 to digitsPerWord-1 (inclusive)
+*/
+func (d *MyDecimal) doMiniLeftShift(shift, beg, end int) {
+ bufFrom := beg / digitsPerWord
+ bufEnd := (end - 1) / digitsPerWord
+ cShift := digitsPerWord - shift
+ if beg%digitsPerWord < shift {
+ d.wordBuf[bufFrom-1] = d.wordBuf[bufFrom] / powers10[cShift]
+ }
+ for bufFrom < bufEnd {
+ d.wordBuf[bufFrom] = (d.wordBuf[bufFrom]%powers10[cShift])*powers10[shift] + d.wordBuf[bufFrom+1]/powers10[cShift]
+ bufFrom++
+ }
+ d.wordBuf[bufFrom] = (d.wordBuf[bufFrom] % powers10[cShift]) * powers10[shift]
+}
+
+/*
+ doMiniRightShift does right shift for alignment of data in buffer.
+
+ shift number of decimal digits on which it should be shifted
+ beg/end bounds of decimal digits (see digitsBounds())
+
+ NOTE
+ Result fitting in the buffer should be garanted.
+ 'shift' have to be from 1 to digitsPerWord-1 (inclusive)
+*/
+func (d *MyDecimal) doMiniRightShift(shift, beg, end int) {
+ bufFrom := (end - 1) / digitsPerWord
+ bufEnd := beg / digitsPerWord
+ cShift := digitsPerWord - shift
+ if digitsPerWord-((end-1)%digitsPerWord+1) < shift {
+ d.wordBuf[bufFrom+1] = (d.wordBuf[bufFrom] % powers10[shift]) * powers10[cShift]
+ }
+ for bufFrom > bufEnd {
+ d.wordBuf[bufFrom] = d.wordBuf[bufFrom]/powers10[shift] + (d.wordBuf[bufFrom-1]%powers10[shift])*powers10[cShift]
+ bufFrom--
+ }
+ d.wordBuf[bufFrom] = d.wordBuf[bufFrom] / powers10[shift]
+}
+
+// Round rounds the decimal to "frac" digits.
+//
+// to - result buffer. d == to is allowed
+// frac - to what position after fraction point to round. can be negative!
+// roundMode - round to nearest even or truncate
+// ModeHalfEven rounds normally.
+// Truncate just truncates the decimal.
+//
+// NOTES
+// scale can be negative !
+// one TRUNCATED error (line XXX below) isn't treated very logical :(
+//
+// RETURN VALUE
+// eDecOK/eDecTruncated
+func (d *MyDecimal) Round(to *MyDecimal, frac int, roundMode RoundMode) (err error) {
+ // wordsFracTo is the number of fraction words in buffer.
+ wordsFracTo := (frac + 1) / digitsPerWord
+ if frac > 0 {
+ wordsFracTo = digitsToWords(frac)
+ }
+ wordsFrac := digitsToWords(int(d.digitsFrac))
+ wordsInt := digitsToWords(int(d.digitsInt))
+
+ roundDigit := int32(roundMode)
+ /* TODO - fix this code as it won't work for CEILING mode */
+
+ if wordsInt+wordsFracTo > wordBufLen {
+ wordsFracTo = wordBufLen - wordsInt
+ frac = wordsFracTo * digitsPerWord
+ err = ErrTruncated
+ }
+ if int(d.digitsInt)+frac < 0 {
+ *to = zeroMyDecimal
+ return nil
+ }
+ if to != d {
+ copy(to.wordBuf[:], d.wordBuf[:])
+ to.negative = d.negative
+ to.digitsInt = int8(myMin(wordsInt, wordBufLen) * digitsPerWord)
+ }
+ if wordsFracTo > wordsFrac {
+ idx := wordsInt + wordsFrac
+ for wordsFracTo > wordsFrac {
+ wordsFracTo--
+ to.wordBuf[idx] = 0
+ idx++
+ }
+ to.digitsFrac = int8(frac)
+ to.resultFrac = to.digitsFrac
+ return
+ }
+ if frac >= int(d.digitsFrac) {
+ to.digitsFrac = int8(frac)
+ to.resultFrac = to.digitsFrac
+ return
+ }
+
+ // Do increment.
+ toIdx := wordsInt + wordsFracTo - 1
+ if frac == wordsFracTo*digitsPerWord {
+ doInc := false
+ switch roundMode {
+ // Notice: No support for ceiling mode now.
+ case modeCeiling:
+ // If any word after scale is not zero, do increment.
+ // e.g ceiling 3.0001 to scale 1, gets 3.1
+ idx := toIdx + (wordsFrac - wordsFracTo)
+ for idx > toIdx {
+ if d.wordBuf[idx] != 0 {
+ doInc = true
+ break
+ }
+ idx--
+ }
+ case ModeHalfEven:
+ digAfterScale := d.wordBuf[toIdx+1] / digMask // the first digit after scale.
+ // If first digit after scale is 5 and round even, do increment if digit at scale is odd.
+ doInc = (digAfterScale > 5) || (digAfterScale == 5)
+ case ModeTruncate:
+ // Never round, just truncate.
+ doInc = false
+ }
+ if doInc {
+ if toIdx >= 0 {
+ to.wordBuf[toIdx]++
+ } else {
+ toIdx++
+ to.wordBuf[toIdx] = wordBase
+ }
+ } else if wordsInt+wordsFracTo == 0 {
+ *to = zeroMyDecimal
+ return nil
+ }
+ } else {
+ /* TODO - fix this code as it won't work for CEILING mode */
+ pos := wordsFracTo*digitsPerWord - frac - 1
+ shiftedNumber := to.wordBuf[toIdx] / powers10[pos]
+ digAfterScale := shiftedNumber % 10
+ if digAfterScale > roundDigit || (roundDigit == 5 && digAfterScale == 5) {
+ shiftedNumber += 10
+ }
+ to.wordBuf[toIdx] = powers10[pos] * (shiftedNumber - digAfterScale)
+ }
+ /*
+ In case we're rounding e.g. 1.5e9 to 2.0e9, the decimal words inside
+ the buffer are as follows.
+
+ Before <1, 5e8>
+ After <2, 5e8>
+
+ Hence we need to set the 2nd field to 0.
+ The same holds if we round 1.5e-9 to 2e-9.
+ */
+ if wordsFracTo < wordsFrac {
+ idx := wordsInt + wordsFracTo
+ if frac == 0 && wordsInt == 0 {
+ idx = 1
+ }
+ for idx < wordBufLen {
+ to.wordBuf[idx] = 0
+ idx++
+ }
+ }
+
+ // Handle carry.
+ var carry int32
+ if to.wordBuf[toIdx] >= wordBase {
+ carry = 1
+ to.wordBuf[toIdx] -= wordBase
+ for carry == 1 && toIdx > 0 {
+ toIdx--
+ to.wordBuf[toIdx], carry = add(to.wordBuf[toIdx], 0, carry)
+ }
+ if carry > 0 {
+ if wordsInt+wordsFracTo >= wordBufLen {
+ wordsFracTo--
+ frac = wordsFracTo * digitsPerWord
+ err = ErrTruncated
+ }
+ for toIdx = wordsInt + myMax(wordsFracTo, 0); toIdx > 0; toIdx-- {
+ if toIdx < wordBufLen {
+ to.wordBuf[toIdx] = to.wordBuf[toIdx-1]
+ } else {
+ err = ErrOverflow
+ }
+ }
+ to.wordBuf[toIdx] = 1
+ /* We cannot have more than 9 * 9 = 81 digits. */
+ if int(to.digitsInt) < digitsPerWord*wordBufLen {
+ to.digitsInt++
+ } else {
+ err = ErrOverflow
+ }
+ }
+ } else {
+ for {
+ if to.wordBuf[toIdx] != 0 {
+ break
+ }
+ if toIdx == 0 {
+ /* making 'zero' with the proper scale */
+ idx := wordsFracTo + 1
+ to.digitsInt = 1
+ to.digitsFrac = int8(myMax(frac, 0))
+ to.negative = false
+ for toIdx < idx {
+ to.wordBuf[toIdx] = 0
+ toIdx++
+ }
+ to.resultFrac = to.digitsFrac
+ return nil
+ }
+ toIdx--
+ }
+ }
+ /* Here we check 999.9 -> 1000 case when we need to increase intDigCnt */
+ firstDig := mod9[to.digitsInt]
+ if firstDig > 0 && to.wordBuf[toIdx] >= powers10[firstDig] {
+ to.digitsInt++
+ }
+ if frac < 0 {
+ frac = 0
+ }
+ to.digitsFrac = int8(frac)
+ to.resultFrac = to.digitsFrac
+ return
+}
+
+// FromInt sets the decimal value from int64.
+func (d *MyDecimal) FromInt(val int64) *MyDecimal {
+ var uVal uint64
+ if val < 0 {
+ d.negative = true
+ uVal = uint64(-val)
+ } else {
+ uVal = uint64(val)
+ }
+ return d.FromUint(uVal)
+}
+
+// FromUint sets the decimal value from uint64.
+func (d *MyDecimal) FromUint(val uint64) *MyDecimal {
+ x := val
+ wordIdx := 1
+ for x >= wordBase {
+ wordIdx++
+ x /= wordBase
+ }
+ d.digitsFrac = 0
+ d.digitsInt = int8(wordIdx * digitsPerWord)
+ x = val
+ for wordIdx > 0 {
+ wordIdx--
+ y := x / wordBase
+ d.wordBuf[wordIdx] = int32(x - y*wordBase)
+ x = y
+ }
+ return d
+}
+
+// ToInt returns int part of the decimal, returns the result and errcode.
+func (d *MyDecimal) ToInt() (int64, error) {
+ var x int64
+ wordIdx := 0
+ for i := d.digitsInt; i > 0; i -= digitsPerWord {
+ y := x
+ /*
+ Attention: trick!
+ we're calculating -|from| instead of |from| here
+ because |LONGLONG_MIN| > LONGLONG_MAX
+ so we can convert -9223372036854775808 correctly
+ */
+ x = x*wordBase - int64(d.wordBuf[wordIdx])
+ wordIdx++
+ if y < math.MinInt64/wordBase || x > y {
+ /*
+ the decimal is bigger than any possible integer
+ return border integer depending on the sign
+ */
+ if d.negative {
+ return math.MinInt64, ErrOverflow
+ }
+ return math.MaxInt64, ErrOverflow
+ }
+ }
+ /* boundary case: 9223372036854775808 */
+ if !d.negative && x == math.MinInt64 {
+ return math.MaxInt64, ErrOverflow
+ }
+ if !d.negative {
+ x = -x
+ }
+ for i := d.digitsFrac; i > 0; i -= digitsPerWord {
+ if d.wordBuf[wordIdx] != 0 {
+ return x, ErrTruncated
+ }
+ wordIdx++
+ }
+ return x, nil
+}
+
+// ToUint returns int part of the decimal, returns the result and errcode.
+func (d *MyDecimal) ToUint() (uint64, error) {
+ if d.negative {
+ return 0, ErrOverflow
+ }
+ var x uint64
+ wordIdx := 0
+ for i := d.digitsInt; i > 0; i -= digitsPerWord {
+ y := x
+ x = x*wordBase + uint64(d.wordBuf[wordIdx])
+ wordIdx++
+ if y > math.MaxUint64/wordBase || x < y {
+ return math.MaxUint64, ErrOverflow
+ }
+ }
+ for i := d.digitsFrac; i > 0; i -= digitsPerWord {
+ if d.wordBuf[wordIdx] != 0 {
+ return x, ErrTruncated
+ }
+ wordIdx++
+ }
+ return x, nil
+}
+
+// FromFloat64 creates a decimal from float64 value.
+func (d *MyDecimal) FromFloat64(f float64) error {
+ s := strconv.FormatFloat(f, 'g', -1, 64)
+ return d.FromString([]byte(s))
+}
+
+// ToFloat64 converts decimal to float64 value.
+func (d *MyDecimal) ToFloat64() (float64, error) {
+ f, err := strconv.ParseFloat(d.String(), 64)
+ if err != nil {
+ err = ErrOverflow
+ }
+ return f, err
+}
+
+/*
+ToBin converts decimal to its binary fixed-length representation
+two representations of the same length can be compared with memcmp
+with the correct -1/0/+1 result
+
+ PARAMS
+ precision/frac - if precision is 0, internal value of the decimal will be used,
+ then the encoded value is not memory comparable.
+
+ NOTE
+ the buffer is assumed to be of the size DecimalBinSize(precision, frac)
+
+ RETURN VALUE
+ bin - binary value
+ errCode - eDecOK/eDecTruncate/eDecOverflow
+
+ DESCRIPTION
+ for storage decimal numbers are converted to the "binary" format.
+
+ This format has the following properties:
+ 1. length of the binary representation depends on the {precision, frac}
+ as provided by the caller and NOT on the digitsInt/digitsFrac of the decimal to
+ convert.
+ 2. binary representations of the same {precision, frac} can be compared
+ with memcmp - with the same result as DecimalCompare() of the original
+ decimals (not taking into account possible precision loss during
+ conversion).
+
+ This binary format is as follows:
+ 1. First the number is converted to have a requested precision and frac.
+ 2. Every full digitsPerWord digits of digitsInt part are stored in 4 bytes
+ as is
+ 3. The first digitsInt % digitesPerWord digits are stored in the reduced
+ number of bytes (enough bytes to store this number of digits -
+ see dig2bytes)
+ 4. same for frac - full word are stored as is,
+ the last frac % digitsPerWord digits - in the reduced number of bytes.
+ 5. If the number is negative - every byte is inversed.
+ 5. The very first bit of the resulting byte array is inverted (because
+ memcmp compares unsigned bytes, see property 2 above)
+
+ Example:
+
+ 1234567890.1234
+
+ internally is represented as 3 words
+
+ 1 234567890 123400000
+
+ (assuming we want a binary representation with precision=14, frac=4)
+ in hex it's
+
+ 00-00-00-01 0D-FB-38-D2 07-5A-EF-40
+
+ now, middle word is full - it stores 9 decimal digits. It goes
+ into binary representation as is:
+
+
+ ........... 0D-FB-38-D2 ............
+
+ First word has only one decimal digit. We can store one digit in
+ one byte, no need to waste four:
+
+ 01 0D-FB-38-D2 ............
+
+ now, last word. It's 123400000. We can store 1234 in two bytes:
+
+ 01 0D-FB-38-D2 04-D2
+
+ So, we've packed 12 bytes number in 7 bytes.
+ And now we invert the highest bit to get the final result:
+
+ 81 0D FB 38 D2 04 D2
+
+ And for -1234567890.1234 it would be
+
+ 7E F2 04 C7 2D FB 2D
+*/
+func (d *MyDecimal) ToBin(precision, frac int) ([]byte, error) {
+ return d.WriteBin(precision, frac, []byte{})
+}
+
+// WriteBin encode and write the binary encoded to target buffer
+func (d *MyDecimal) WriteBin(precision, frac int, buf []byte) ([]byte, error) {
+ if precision > digitsPerWord*maxWordBufLen || precision < 0 || frac > mysql.MaxDecimalScale || frac < 0 {
+ return buf, ErrBadNumber
+ }
+ var err error
+ var mask int32
+ if d.negative {
+ mask = -1
+ }
+ digitsInt := precision - frac
+ wordsInt := digitsInt / digitsPerWord
+ leadingDigits := digitsInt - wordsInt*digitsPerWord
+ wordsFrac := frac / digitsPerWord
+ trailingDigits := frac - wordsFrac*digitsPerWord
+
+ wordsFracFrom := int(d.digitsFrac) / digitsPerWord
+ trailingDigitsFrom := int(d.digitsFrac) - wordsFracFrom*digitsPerWord
+ intSize := wordsInt*wordSize + dig2bytes[leadingDigits]
+ fracSize := wordsFrac*wordSize + dig2bytes[trailingDigits]
+ fracSizeFrom := wordsFracFrom*wordSize + dig2bytes[trailingDigitsFrom]
+ originIntSize := intSize
+ originFracSize := fracSize
+ bufLen := len(buf)
+ if bufLen+intSize+fracSize <= cap(buf) {
+ buf = buf[:bufLen+intSize+fracSize]
+ } else {
+ buf = append(buf, make([]byte, intSize+fracSize)...)
+ }
+ bin := buf[bufLen:]
+ binIdx := 0
+ wordIdxFrom, digitsIntFrom := d.removeLeadingZeros()
+ if digitsIntFrom+fracSizeFrom == 0 {
+ mask = 0
+ digitsInt = 1
+ }
+
+ wordsIntFrom := digitsIntFrom / digitsPerWord
+ leadingDigitsFrom := digitsIntFrom - wordsIntFrom*digitsPerWord
+ iSizeFrom := wordsIntFrom*wordSize + dig2bytes[leadingDigitsFrom]
+
+ if digitsInt < digitsIntFrom {
+ wordIdxFrom += wordsIntFrom - wordsInt
+ if leadingDigitsFrom > 0 {
+ wordIdxFrom++
+ }
+ if leadingDigits > 0 {
+ wordIdxFrom--
+ }
+ wordsIntFrom = wordsInt
+ leadingDigitsFrom = leadingDigits
+ err = ErrOverflow
+ } else if intSize > iSizeFrom {
+ for intSize > iSizeFrom {
+ intSize--
+ bin[binIdx] = byte(mask)
+ binIdx++
+ }
+ }
+
+ if fracSize < fracSizeFrom ||
+ (fracSize == fracSizeFrom && (trailingDigits <= trailingDigitsFrom || wordsFrac <= wordsFracFrom)) {
+ if fracSize < fracSizeFrom || (fracSize == fracSizeFrom && trailingDigits < trailingDigitsFrom) || (fracSize == fracSizeFrom && wordsFrac < wordsFracFrom) {
+ err = ErrTruncated
+ }
+ wordsFracFrom = wordsFrac
+ trailingDigitsFrom = trailingDigits
+ } else if fracSize > fracSizeFrom && trailingDigitsFrom > 0 {
+ if wordsFrac == wordsFracFrom {
+ trailingDigitsFrom = trailingDigits
+ fracSize = fracSizeFrom
+ } else {
+ wordsFracFrom++
+ trailingDigitsFrom = 0
+ }
+ }
+ // xIntFrom part
+ if leadingDigitsFrom > 0 {
+ i := dig2bytes[leadingDigitsFrom]
+ x := (d.wordBuf[wordIdxFrom] % powers10[leadingDigitsFrom]) ^ mask
+ wordIdxFrom++
+ writeWord(bin[binIdx:], x, i)
+ binIdx += i
+ }
+
+ // wordsInt + wordsFrac part.
+ for stop := wordIdxFrom + wordsIntFrom + wordsFracFrom; wordIdxFrom < stop; binIdx += wordSize {
+ x := d.wordBuf[wordIdxFrom] ^ mask
+ wordIdxFrom++
+ writeWord(bin[binIdx:], x, 4)
+ }
+
+ // xFracFrom part
+ if trailingDigitsFrom > 0 {
+ var x int32
+ i := dig2bytes[trailingDigitsFrom]
+ lim := trailingDigits
+ if wordsFracFrom < wordsFrac {
+ lim = digitsPerWord
+ }
+
+ for trailingDigitsFrom < lim && dig2bytes[trailingDigitsFrom] == i {
+ trailingDigitsFrom++
+ }
+ x = (d.wordBuf[wordIdxFrom] / powers10[digitsPerWord-trailingDigitsFrom]) ^ mask
+ writeWord(bin[binIdx:], x, i)
+ binIdx += i
+ }
+ if fracSize > fracSizeFrom {
+ binIdxEnd := originIntSize + originFracSize
+ for fracSize > fracSizeFrom && binIdx < binIdxEnd {
+ fracSize--
+ bin[binIdx] = byte(mask)
+ binIdx++
+ }
+ }
+ bin[0] ^= 0x80
+ return buf, err
+}
+
+// ToHashKey removes the leading and trailing zeros and generates a hash key.
+// Two Decimals dec0 and dec1 with different fraction will generate the same hash keys if dec0.Compare(dec1) == 0.
+func (d *MyDecimal) ToHashKey() ([]byte, error) {
+ _, digitsInt := d.removeLeadingZeros()
+ _, digitsFrac := d.removeTrailingZeros()
+ prec := digitsInt + digitsFrac
+ if prec == 0 { // zeroDecimal
+ prec = 1
+ }
+ buf, err := d.ToBin(prec, digitsFrac)
+ if err == ErrTruncated {
+ // This err is caused by shorter digitsFrac;
+ // After removing the trailing zeros from a Decimal,
+ // so digitsFrac may be less than the real digitsFrac of the Decimal,
+ // thus ErrTruncated may be raised, we can ignore it here.
+ err = nil
+ }
+ buf = append(buf, byte(digitsFrac))
+ return buf, err
+}
+
+// PrecisionAndFrac returns the internal precision and frac number.
+func (d *MyDecimal) PrecisionAndFrac() (precision, frac int) {
+ frac = int(d.digitsFrac)
+ _, digitsInt := d.removeLeadingZeros()
+ precision = digitsInt + frac
+ if precision == 0 {
+ precision = 1
+ }
+ return
+}
+
+// IsZero checks whether it's a zero decimal.
+func (d *MyDecimal) IsZero() bool {
+ isZero := true
+ for _, val := range d.wordBuf {
+ if val != 0 {
+ isZero = false
+ break
+ }
+ }
+ return isZero
+}
+
+// FromBin Restores decimal from its binary fixed-length representation.
+func (d *MyDecimal) FromBin(bin []byte, precision, frac int) (binSize int, err error) {
+ if len(bin) == 0 {
+ *d = zeroMyDecimal
+ return 0, ErrBadNumber
+ }
+ digitsInt := precision - frac
+ wordsInt := digitsInt / digitsPerWord
+ leadingDigits := digitsInt - wordsInt*digitsPerWord
+ wordsFrac := frac / digitsPerWord
+ trailingDigits := frac - wordsFrac*digitsPerWord
+ wordsIntTo := wordsInt
+ if leadingDigits > 0 {
+ wordsIntTo++
+ }
+ wordsFracTo := wordsFrac
+ if trailingDigits > 0 {
+ wordsFracTo++
+ }
+
+ binIdx := 0
+ mask := int32(-1)
+ if bin[binIdx]&0x80 > 0 {
+ mask = 0
+ }
+ binSize = DecimalBinSize(precision, frac)
+ dCopy := make([]byte, 40)
+ dCopy = dCopy[:binSize]
+ copy(dCopy, bin)
+ dCopy[0] ^= 0x80
+ bin = dCopy
+ oldWordsIntTo := wordsIntTo
+ wordsIntTo, wordsFracTo, err = fixWordCntError(wordsIntTo, wordsFracTo)
+ if err != nil {
+ if wordsIntTo < oldWordsIntTo {
+ binIdx += dig2bytes[leadingDigits] + (wordsInt-wordsIntTo)*wordSize
+ } else {
+ trailingDigits = 0
+ wordsFrac = wordsFracTo
+ }
+ }
+ d.negative = mask != 0
+ d.digitsInt = int8(wordsInt*digitsPerWord + leadingDigits)
+ d.digitsFrac = int8(wordsFrac*digitsPerWord + trailingDigits)
+
+ wordIdx := 0
+ if leadingDigits > 0 {
+ i := dig2bytes[leadingDigits]
+ x := readWord(bin[binIdx:], i)
+ binIdx += i
+ d.wordBuf[wordIdx] = x ^ mask
+ if uint64(d.wordBuf[wordIdx]) >= uint64(powers10[leadingDigits+1]) {
+ *d = zeroMyDecimal
+ return binSize, ErrBadNumber
+ }
+ if wordIdx > 0 || d.wordBuf[wordIdx] != 0 {
+ wordIdx++
+ } else {
+ d.digitsInt -= int8(leadingDigits)
+ }
+ }
+ for stop := binIdx + wordsInt*wordSize; binIdx < stop; binIdx += wordSize {
+ d.wordBuf[wordIdx] = readWord(bin[binIdx:], 4) ^ mask
+ if uint32(d.wordBuf[wordIdx]) > wordMax {
+ *d = zeroMyDecimal
+ return binSize, ErrBadNumber
+ }
+ if wordIdx > 0 || d.wordBuf[wordIdx] != 0 {
+ wordIdx++
+ } else {
+ d.digitsInt -= digitsPerWord
+ }
+ }
+
+ for stop := binIdx + wordsFrac*wordSize; binIdx < stop; binIdx += wordSize {
+ d.wordBuf[wordIdx] = readWord(bin[binIdx:], 4) ^ mask
+ if uint32(d.wordBuf[wordIdx]) > wordMax {
+ *d = zeroMyDecimal
+ return binSize, ErrBadNumber
+ }
+ wordIdx++
+ }
+
+ if trailingDigits > 0 {
+ i := dig2bytes[trailingDigits]
+ x := readWord(bin[binIdx:], i)
+ d.wordBuf[wordIdx] = (x ^ mask) * powers10[digitsPerWord-trailingDigits]
+ if uint32(d.wordBuf[wordIdx]) > wordMax {
+ *d = zeroMyDecimal
+ return binSize, ErrBadNumber
+ }
+ }
+
+ if d.digitsInt == 0 && d.digitsFrac == 0 {
+ *d = zeroMyDecimal
+ }
+ d.resultFrac = int8(frac)
+ return binSize, err
+}
+
+// DecimalBinSize returns the size of array to hold a binary representation of a decimal.
+func DecimalBinSize(precision, frac int) int {
+ digitsInt := precision - frac
+ wordsInt := digitsInt / digitsPerWord
+ wordsFrac := frac / digitsPerWord
+ xInt := digitsInt - wordsInt*digitsPerWord
+ xFrac := frac - wordsFrac*digitsPerWord
+ return wordsInt*wordSize + dig2bytes[xInt] + wordsFrac*wordSize + dig2bytes[xFrac]
+}
+
+func readWord(b []byte, size int) int32 {
+ var x int32
+ switch size {
+ case 1:
+ x = int32(int8(b[0]))
+ case 2:
+ x = int32(int8(b[0]))<<8 + int32(b[1])
+ case 3:
+ if b[0]&128 > 0 {
+ x = int32(uint32(255)<<24 | uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]))
+ } else {
+ x = int32(uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]))
+ }
+ case 4:
+ x = int32(b[3]) + int32(b[2])<<8 + int32(b[1])<<16 + int32(int8(b[0]))<<24
+ }
+ return x
+}
+
+func writeWord(b []byte, word int32, size int) {
+ v := uint32(word)
+ switch size {
+ case 1:
+ b[0] = byte(word)
+ case 2:
+ b[0] = byte(v >> 8)
+ b[1] = byte(v)
+ case 3:
+ b[0] = byte(v >> 16)
+ b[1] = byte(v >> 8)
+ b[2] = byte(v)
+ case 4:
+ b[0] = byte(v >> 24)
+ b[1] = byte(v >> 16)
+ b[2] = byte(v >> 8)
+ b[3] = byte(v)
+ }
+}
+
+// Compare compares one decimal to another, returns -1/0/1.
+func (d *MyDecimal) Compare(to *MyDecimal) int {
+ if d.negative == to.negative {
+ cmp, err := doSub(d, to, nil)
+ terror.Log(errors.Trace(err))
+ return cmp
+ }
+ if d.negative {
+ return -1
+ }
+ return 1
+}
+
+// DecimalNeg reverses decimal's sign.
+func DecimalNeg(from *MyDecimal) *MyDecimal {
+ to := *from
+ if from.IsZero() {
+ return &to
+ }
+ to.negative = !from.negative
+ return &to
+}
+
+// DecimalAdd adds two decimals, sets the result to 'to'.
+// Note: DO NOT use `from1` or `from2` as `to` since the metadata
+// of `to` may be changed during evaluating.
+func DecimalAdd(from1, from2, to *MyDecimal) error {
+ from1, from2, to = validateArgs(from1, from2, to)
+ to.resultFrac = myMaxInt8(from1.resultFrac, from2.resultFrac)
+ if from1.negative == from2.negative {
+ return doAdd(from1, from2, to)
+ }
+ _, err := doSub(from1, from2, to)
+ return err
+}
+
+// DecimalSub subs one decimal from another, sets the result to 'to'.
+func DecimalSub(from1, from2, to *MyDecimal) error {
+ from1, from2, to = validateArgs(from1, from2, to)
+ to.resultFrac = myMaxInt8(from1.resultFrac, from2.resultFrac)
+ if from1.negative == from2.negative {
+ _, err := doSub(from1, from2, to)
+ return err
+ }
+ return doAdd(from1, from2, to)
+}
+
+func validateArgs(f1, f2, to *MyDecimal) (*MyDecimal, *MyDecimal, *MyDecimal) {
+ if to == nil {
+ return f1, f2, to
+ }
+ if f1 == to {
+ tmp := *f1
+ f1 = &tmp
+ }
+ if f2 == to {
+ tmp := *f2
+ f2 = &tmp
+ }
+ to.digitsFrac = 0
+ to.digitsInt = 0
+ to.resultFrac = 0
+ to.negative = false
+ for i := range to.wordBuf {
+ to.wordBuf[i] = 0
+ }
+ return f1, f2, to
+}
+
+func doSub(from1, from2, to *MyDecimal) (cmp int, err error) {
+ var (
+ wordsInt1 = digitsToWords(int(from1.digitsInt))
+ wordsFrac1 = digitsToWords(int(from1.digitsFrac))
+ wordsInt2 = digitsToWords(int(from2.digitsInt))
+ wordsFrac2 = digitsToWords(int(from2.digitsFrac))
+ wordsFracTo = myMax(wordsFrac1, wordsFrac2)
+
+ start1 = 0
+ stop1 = wordsInt1
+ idx1 = 0
+ start2 = 0
+ stop2 = wordsInt2
+ idx2 = 0
+ )
+ if from1.wordBuf[idx1] == 0 {
+ for idx1 < stop1 && from1.wordBuf[idx1] == 0 {
+ idx1++
+ }
+ start1 = idx1
+ wordsInt1 = stop1 - idx1
+ }
+ if from2.wordBuf[idx2] == 0 {
+ for idx2 < stop2 && from2.wordBuf[idx2] == 0 {
+ idx2++
+ }
+ start2 = idx2
+ wordsInt2 = stop2 - idx2
+ }
+
+ var carry int32
+ if wordsInt2 > wordsInt1 {
+ carry = 1
+ } else if wordsInt2 == wordsInt1 {
+ end1 := stop1 + wordsFrac1 - 1
+ end2 := stop2 + wordsFrac2 - 1
+ for idx1 <= end1 && from1.wordBuf[end1] == 0 {
+ end1--
+ }
+ for idx2 <= end2 && from2.wordBuf[end2] == 0 {
+ end2--
+ }
+ wordsFrac1 = end1 - stop1 + 1
+ wordsFrac2 = end2 - stop2 + 1
+ for idx1 <= end1 && idx2 <= end2 && from1.wordBuf[idx1] == from2.wordBuf[idx2] {
+ idx1++
+ idx2++
+ }
+ if idx1 <= end1 {
+ if idx2 <= end2 && from2.wordBuf[idx2] > from1.wordBuf[idx1] {
+ carry = 1
+ } else {
+ carry = 0
+ }
+ } else {
+ if idx2 <= end2 {
+ carry = 1
+ } else {
+ if to == nil {
+ return 0, nil
+ }
+ *to = zeroMyDecimalWithFrac(to.resultFrac)
+ return 0, nil
+ }
+ }
+ }
+
+ if to == nil {
+ if carry > 0 == from1.negative { // from2 is negative too.
+ return 1, nil
+ }
+ return -1, nil
+ }
+
+ to.negative = from1.negative
+
+ /* ensure that always idx1 > idx2 (and wordsInt1 >= wordsInt2) */
+ if carry > 0 {
+ from1, from2 = from2, from1
+ start1, start2 = start2, start1
+ wordsInt1, wordsInt2 = wordsInt2, wordsInt1
+ wordsFrac1, wordsFrac2 = wordsFrac2, wordsFrac1
+ to.negative = !to.negative
+ }
+
+ wordsInt1, wordsFracTo, err = fixWordCntError(wordsInt1, wordsFracTo)
+ idxTo := wordsInt1 + wordsFracTo
+ to.digitsFrac = from1.digitsFrac
+ if to.digitsFrac < from2.digitsFrac {
+ to.digitsFrac = from2.digitsFrac
+ }
+ to.digitsInt = int8(wordsInt1 * digitsPerWord)
+ if err != nil {
+ if to.digitsFrac > int8(wordsFracTo*digitsPerWord) {
+ to.digitsFrac = int8(wordsFracTo * digitsPerWord)
+ }
+ if wordsFrac1 > wordsFracTo {
+ wordsFrac1 = wordsFracTo
+ }
+ if wordsFrac2 > wordsFracTo {
+ wordsFrac2 = wordsFracTo
+ }
+ if wordsInt2 > wordsInt1 {
+ wordsInt2 = wordsInt1
+ }
+ }
+ carry = 0
+
+ /* part 1 - max(frac) ... min (frac) */
+ if wordsFrac1 > wordsFrac2 {
+ idx1 = start1 + wordsInt1 + wordsFrac1
+ stop1 = start1 + wordsInt1 + wordsFrac2
+ idx2 = start2 + wordsInt2 + wordsFrac2
+ for wordsFracTo > wordsFrac1 {
+ wordsFracTo--
+ idxTo--
+ to.wordBuf[idxTo] = 0
+ }
+ for idx1 > stop1 {
+ idxTo--
+ idx1--
+ to.wordBuf[idxTo] = from1.wordBuf[idx1]
+ }
+ } else {
+ idx1 = start1 + wordsInt1 + wordsFrac1
+ idx2 = start2 + wordsInt2 + wordsFrac2
+ stop2 = start2 + wordsInt2 + wordsFrac1
+ for wordsFracTo > wordsFrac2 {
+ wordsFracTo--
+ idxTo--
+ to.wordBuf[idxTo] = 0
+ }
+ for idx2 > stop2 {
+ idxTo--
+ idx2--
+ to.wordBuf[idxTo], carry = sub(0, from2.wordBuf[idx2], carry)
+ }
+ }
+
+ /* part 2 - min(frac) ... wordsInt2 */
+ for idx2 > start2 {
+ idxTo--
+ idx1--
+ idx2--
+ to.wordBuf[idxTo], carry = sub(from1.wordBuf[idx1], from2.wordBuf[idx2], carry)
+ }
+
+ /* part 3 - wordsInt2 ... wordsInt1 */
+ for carry > 0 && idx1 > start1 {
+ idxTo--
+ idx1--
+ to.wordBuf[idxTo], carry = sub(from1.wordBuf[idx1], 0, carry)
+ }
+ for idx1 > start1 {
+ idxTo--
+ idx1--
+ to.wordBuf[idxTo] = from1.wordBuf[idx1]
+ }
+ for idxTo > 0 {
+ idxTo--
+ to.wordBuf[idxTo] = 0
+ }
+ return 0, err
+}
+
+func doAdd(from1, from2, to *MyDecimal) error {
+ var (
+ err error
+ wordsInt1 = digitsToWords(int(from1.digitsInt))
+ wordsFrac1 = digitsToWords(int(from1.digitsFrac))
+ wordsInt2 = digitsToWords(int(from2.digitsInt))
+ wordsFrac2 = digitsToWords(int(from2.digitsFrac))
+ wordsIntTo = myMax(wordsInt1, wordsInt2)
+ wordsFracTo = myMax(wordsFrac1, wordsFrac2)
+ )
+
+ var x int32
+ if wordsInt1 > wordsInt2 {
+ x = from1.wordBuf[0]
+ } else if wordsInt2 > wordsInt1 {
+ x = from2.wordBuf[0]
+ } else {
+ x = from1.wordBuf[0] + from2.wordBuf[0]
+ }
+ if x > wordMax-1 { /* yes, there is */
+ wordsIntTo++
+ to.wordBuf[0] = 0 /* safety */
+ }
+
+ wordsIntTo, wordsFracTo, err = fixWordCntError(wordsIntTo, wordsFracTo)
+ if err == ErrOverflow {
+ maxDecimal(wordBufLen*digitsPerWord, 0, to)
+ return err
+ }
+ idxTo := wordsIntTo + wordsFracTo
+ to.negative = from1.negative
+ to.digitsInt = int8(wordsIntTo * digitsPerWord)
+ to.digitsFrac = myMaxInt8(from1.digitsFrac, from2.digitsFrac)
+
+ if err != nil {
+ if to.digitsFrac > int8(wordsFracTo*digitsPerWord) {
+ to.digitsFrac = int8(wordsFracTo * digitsPerWord)
+ }
+ if wordsFrac1 > wordsFracTo {
+ wordsFrac1 = wordsFracTo
+ }
+ if wordsFrac2 > wordsFracTo {
+ wordsFrac2 = wordsFracTo
+ }
+ if wordsInt1 > wordsIntTo {
+ wordsInt1 = wordsIntTo
+ }
+ if wordsInt2 > wordsIntTo {
+ wordsInt2 = wordsIntTo
+ }
+ }
+ var dec1, dec2 = from1, from2
+ var idx1, idx2, stop, stop2 int
+ /* part 1 - max(frac) ... min (frac) */
+ if wordsFrac1 > wordsFrac2 {
+ idx1 = wordsInt1 + wordsFrac1
+ stop = wordsInt1 + wordsFrac2
+ idx2 = wordsInt2 + wordsFrac2
+ if wordsInt1 > wordsInt2 {
+ stop2 = wordsInt1 - wordsInt2
+ }
+ } else {
+ idx1 = wordsInt2 + wordsFrac2
+ stop = wordsInt2 + wordsFrac1
+ idx2 = wordsInt1 + wordsFrac1
+ if wordsInt2 > wordsInt1 {
+ stop2 = wordsInt2 - wordsInt1
+ }
+ dec1, dec2 = from2, from1
+ }
+ for idx1 > stop {
+ idxTo--
+ idx1--
+ to.wordBuf[idxTo] = dec1.wordBuf[idx1]
+ }
+
+ /* part 2 - min(frac) ... min(digitsInt) */
+ carry := int32(0)
+ for idx1 > stop2 {
+ idx1--
+ idx2--
+ idxTo--
+ to.wordBuf[idxTo], carry = add(dec1.wordBuf[idx1], dec2.wordBuf[idx2], carry)
+ }
+
+ /* part 3 - min(digitsInt) ... max(digitsInt) */
+ stop = 0
+ if wordsInt1 > wordsInt2 {
+ idx1 = wordsInt1 - wordsInt2
+ dec1 = from1
+ } else {
+ idx1 = wordsInt2 - wordsInt1
+ dec1 = from2
+ }
+ for idx1 > stop {
+ idxTo--
+ idx1--
+ to.wordBuf[idxTo], carry = add(dec1.wordBuf[idx1], 0, carry)
+ }
+ if carry > 0 {
+ idxTo--
+ to.wordBuf[idxTo] = 1
+ }
+ return err
+}
+
+func maxDecimal(precision, frac int, to *MyDecimal) {
+ digitsInt := precision - frac
+ to.negative = false
+ to.digitsInt = int8(digitsInt)
+ idx := 0
+ if digitsInt > 0 {
+ firstWordDigits := digitsInt % digitsPerWord
+ if firstWordDigits > 0 {
+ to.wordBuf[idx] = powers10[firstWordDigits] - 1 /* get 9 99 999 ... */
+ idx++
+ }
+ for digitsInt /= digitsPerWord; digitsInt > 0; digitsInt-- {
+ to.wordBuf[idx] = wordMax
+ idx++
+ }
+ }
+ to.digitsFrac = int8(frac)
+ if frac > 0 {
+ lastDigits := frac % digitsPerWord
+ for frac /= digitsPerWord; frac > 0; frac-- {
+ to.wordBuf[idx] = wordMax
+ idx++
+ }
+ if lastDigits > 0 {
+ to.wordBuf[idx] = fracMax[lastDigits-1]
+ }
+ }
+}
+
+/*
+DecimalMul multiplies two decimals.
+
+ from1, from2 - factors
+ to - product
+
+ RETURN VALUE
+ E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW;
+
+ NOTES
+ in this implementation, with wordSize=4 we have digitsPerWord=9,
+ and 63-digit number will take only 7 words (basically a 7-digit
+ "base 999999999" number). Thus there's no need in fast multiplication
+ algorithms, 7-digit numbers can be multiplied with a naive O(n*n)
+ method.
+
+ XXX if this library is to be used with huge numbers of thousands of
+ digits, fast multiplication must be implemented.
+*/
+func DecimalMul(from1, from2, to *MyDecimal) error {
+ from1, from2, to = validateArgs(from1, from2, to)
+ var (
+ err error
+ wordsInt1 = digitsToWords(int(from1.digitsInt))
+ wordsFrac1 = digitsToWords(int(from1.digitsFrac))
+ wordsInt2 = digitsToWords(int(from2.digitsInt))
+ wordsFrac2 = digitsToWords(int(from2.digitsFrac))
+ wordsIntTo = digitsToWords(int(from1.digitsInt) + int(from2.digitsInt))
+ wordsFracTo = wordsFrac1 + wordsFrac2
+ idx1 = wordsInt1
+ idx2 = wordsInt2
+ idxTo int
+ tmp1 = wordsIntTo
+ tmp2 = wordsFracTo
+ )
+ to.resultFrac = myMinInt8(from1.resultFrac+from2.resultFrac, mysql.MaxDecimalScale)
+ wordsIntTo, wordsFracTo, err = fixWordCntError(wordsIntTo, wordsFracTo)
+ to.negative = from1.negative != from2.negative
+ to.digitsFrac = from1.digitsFrac + from2.digitsFrac
+ if to.digitsFrac > notFixedDec {
+ to.digitsFrac = notFixedDec
+ }
+ to.digitsInt = int8(wordsIntTo * digitsPerWord)
+ if err == ErrOverflow {
+ return err
+ }
+ if err != nil {
+ if to.digitsFrac > int8(wordsFracTo*digitsPerWord) {
+ to.digitsFrac = int8(wordsFracTo * digitsPerWord)
+ }
+ if to.digitsInt > int8(wordsIntTo*digitsPerWord) {
+ to.digitsInt = int8(wordsIntTo * digitsPerWord)
+ }
+ if tmp1 > wordsIntTo {
+ tmp1 -= wordsIntTo
+ tmp2 = tmp1 >> 1
+ wordsInt2 -= tmp1 - tmp2
+ wordsFrac1 = 0
+ wordsFrac2 = 0
+ } else {
+ tmp2 -= wordsFracTo
+ tmp1 = tmp2 >> 1
+ if wordsFrac1 <= wordsFrac2 {
+ wordsFrac1 -= tmp1
+ wordsFrac2 -= tmp2 - tmp1
+ } else {
+ wordsFrac2 -= tmp1
+ wordsFrac1 -= tmp2 - tmp1
+ }
+ }
+ }
+ startTo := wordsIntTo + wordsFracTo - 1
+ start2 := idx2 + wordsFrac2 - 1
+ stop1 := idx1 - wordsInt1
+ stop2 := idx2 - wordsInt2
+ to.wordBuf = zeroMyDecimal.wordBuf
+
+ for idx1 += wordsFrac1 - 1; idx1 >= stop1; idx1-- {
+ carry := int32(0)
+ idxTo = startTo
+ idx2 = start2
+ for idx2 >= stop2 {
+ var hi, lo int32
+ p := int64(from1.wordBuf[idx1]) * int64(from2.wordBuf[idx2])
+ hi = int32(p / wordBase)
+ lo = int32(p - int64(hi)*wordBase)
+ to.wordBuf[idxTo], carry = add2(to.wordBuf[idxTo], lo, carry)
+ carry += hi
+ idx2--
+ idxTo--
+ }
+ if carry > 0 {
+ if idxTo < 0 {
+ return ErrOverflow
+ }
+ to.wordBuf[idxTo], carry = add2(to.wordBuf[idxTo], 0, carry)
+ }
+ for idxTo--; carry > 0; idxTo-- {
+ if idxTo < 0 {
+ return ErrOverflow
+ }
+ to.wordBuf[idxTo], carry = add(to.wordBuf[idxTo], 0, carry)
+ }
+ startTo--
+ }
+
+ /* Now we have to check for -0.000 case */
+ if to.negative {
+ idx := 0
+ end := wordsIntTo + wordsFracTo
+ for {
+ if to.wordBuf[idx] != 0 {
+ break
+ }
+ idx++
+ /* We got decimal zero */
+ if idx == end {
+ *to = zeroMyDecimalWithFrac(to.resultFrac)
+ break
+ }
+ }
+ }
+
+ idxTo = 0
+ dToMove := wordsIntTo + digitsToWords(int(to.digitsFrac))
+ for to.wordBuf[idxTo] == 0 && to.digitsInt > digitsPerWord {
+ idxTo++
+ to.digitsInt -= digitsPerWord
+ dToMove--
+ }
+ if idxTo > 0 {
+ curIdx := 0
+ for dToMove > 0 {
+ to.wordBuf[curIdx] = to.wordBuf[idxTo]
+ curIdx++
+ idxTo++
+ dToMove--
+ }
+ }
+ return err
+}
+
+// DecimalDiv does division of two decimals.
+//
+// from1 - dividend
+// from2 - divisor
+// to - quotient
+// fracIncr - increment of fraction
+func DecimalDiv(from1, from2, to *MyDecimal, fracIncr int) error {
+ from1, from2, to = validateArgs(from1, from2, to)
+ to.resultFrac = myMinInt8(from1.resultFrac+int8(fracIncr), mysql.MaxDecimalScale)
+ return doDivMod(from1, from2, to, nil, fracIncr)
+}
+
+/*
+DecimalMod does modulus of two decimals.
+
+ from1 - dividend
+ from2 - divisor
+ to - modulus
+
+ RETURN VALUE
+ E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW/E_DEC_DIV_ZERO;
+
+ NOTES
+ see do_div_mod()
+
+ DESCRIPTION
+ the modulus R in R = M mod N
+
+ is defined as
+
+ 0 <= |R| < |M|
+ sign R == sign M
+ R = M - k*N, where k is integer
+
+ thus, there's no requirement for M or N to be integers
+*/
+func DecimalMod(from1, from2, to *MyDecimal) error {
+ from1, from2, to = validateArgs(from1, from2, to)
+ to.resultFrac = myMaxInt8(from1.resultFrac, from2.resultFrac)
+ return doDivMod(from1, from2, nil, to, 0)
+}
+
+func doDivMod(from1, from2, to, mod *MyDecimal, fracIncr int) error {
+ var (
+ frac1 = digitsToWords(int(from1.digitsFrac)) * digitsPerWord
+ prec1 = int(from1.digitsInt) + frac1
+ frac2 = digitsToWords(int(from2.digitsFrac)) * digitsPerWord
+ prec2 = int(from2.digitsInt) + frac2
+ )
+ if mod != nil {
+ to = mod
+ }
+
+ /* removing all the leading zeros */
+ i := ((prec2 - 1) % digitsPerWord) + 1
+ idx2 := 0
+ for prec2 > 0 && from2.wordBuf[idx2] == 0 {
+ prec2 -= i
+ i = digitsPerWord
+ idx2++
+ }
+ if prec2 <= 0 {
+ /* short-circuit everything: from2 == 0 */
+ return ErrDivByZero
+ }
+
+ prec2 -= countLeadingZeroes((prec2-1)%digitsPerWord, from2.wordBuf[idx2])
+ i = ((prec1 - 1) % digitsPerWord) + 1
+ idx1 := 0
+ for prec1 > 0 && from1.wordBuf[idx1] == 0 {
+ prec1 -= i
+ i = digitsPerWord
+ idx1++
+ }
+ if prec1 <= 0 {
+ /* short-circuit everything: from1 == 0 */
+ *to = zeroMyDecimalWithFrac(to.resultFrac)
+ return nil
+ }
+ prec1 -= countLeadingZeroes((prec1-1)%digitsPerWord, from1.wordBuf[idx1])
+
+ /* let's fix fracIncr, taking into account frac1,frac2 increase */
+ fracIncr -= frac1 - int(from1.digitsFrac) + frac2 - int(from2.digitsFrac)
+ if fracIncr < 0 {
+ fracIncr = 0
+ }
+
+ digitsIntTo := (prec1 - frac1) - (prec2 - frac2)
+ if from1.wordBuf[idx1] >= from2.wordBuf[idx2] {
+ digitsIntTo++
+ }
+ var wordsIntTo int
+ if digitsIntTo < 0 {
+ digitsIntTo /= digitsPerWord
+ wordsIntTo = 0
+ } else {
+ wordsIntTo = digitsToWords(digitsIntTo)
+ }
+ var wordsFracTo int
+ var err error
+ if mod != nil {
+ // we're calculating N1 % N2.
+ // The result will have
+ // digitsFrac=max(frac1, frac2), as for subtraction
+ // digitsInt=from2.digitsInt
+ to.negative = from1.negative
+ to.digitsFrac = myMaxInt8(from1.digitsFrac, from2.digitsFrac)
+ } else {
+ wordsFracTo = digitsToWords(frac1 + frac2 + fracIncr)
+ wordsIntTo, wordsFracTo, err = fixWordCntError(wordsIntTo, wordsFracTo)
+ to.negative = from1.negative != from2.negative
+ to.digitsInt = int8(wordsIntTo * digitsPerWord)
+ to.digitsFrac = int8(wordsFracTo * digitsPerWord)
+ }
+ idxTo := 0
+ stopTo := wordsIntTo + wordsFracTo
+ if mod == nil {
+ for digitsIntTo < 0 && idxTo < wordBufLen {
+ to.wordBuf[idxTo] = 0
+ idxTo++
+ digitsIntTo++
+ }
+ }
+ i = digitsToWords(prec1)
+ len1 := i + digitsToWords(2*frac2+fracIncr+1) + 1
+ if len1 < 3 {
+ len1 = 3
+ }
+
+ tmp1 := make([]int32, len1)
+ copy(tmp1, from1.wordBuf[idx1:idx1+i])
+
+ start1 := 0
+ var stop1 int
+ start2 := idx2
+ stop2 := idx2 + digitsToWords(prec2) - 1
+
+ /* removing end zeroes */
+ for from2.wordBuf[stop2] == 0 && stop2 >= start2 {
+ stop2--
+ }
+ len2 := stop2 - start2
+ stop2++
+
+ /*
+ calculating norm2 (normalized from2.wordBuf[start2]) - we need from2.wordBuf[start2] to be large
+ (at least > DIG_BASE/2), but unlike Knuth's Alg. D we don't want to
+ normalize input numbers (as we don't make a copy of the divisor).
+ Thus we normalize first dec1 of buf2 only, and we'll normalize tmp1[start1]
+ on the fly for the purpose of guesstimation only.
+ It's also faster, as we're saving on normalization of from2.
+ */
+ normFactor := wordBase / int64(from2.wordBuf[start2]+1)
+ norm2 := int32(normFactor * int64(from2.wordBuf[start2]))
+ if len2 > 0 {
+ norm2 += int32(normFactor * int64(from2.wordBuf[start2+1]) / wordBase)
+ }
+ dcarry := int32(0)
+ if tmp1[start1] < from2.wordBuf[start2] {
+ dcarry = tmp1[start1]
+ start1++
+ }
+
+ // main loop
+ var guess int64
+ for ; idxTo < stopTo; idxTo++ {
+ /* short-circuit, if possible */
+ if dcarry == 0 && tmp1[start1] < from2.wordBuf[start2] {
+ guess = 0
+ } else {
+ /* D3: make a guess */
+ x := int64(tmp1[start1]) + int64(dcarry)*wordBase
+ y := int64(tmp1[start1+1])
+ guess = (normFactor*x + normFactor*y/wordBase) / int64(norm2)
+ if guess >= wordBase {
+ guess = wordBase - 1
+ }
+
+ if len2 > 0 {
+ /* remove normalization */
+ if int64(from2.wordBuf[start2+1])*guess > (x-guess*int64(from2.wordBuf[start2]))*wordBase+y {
+ guess--
+ }
+ if int64(from2.wordBuf[start2+1])*guess > (x-guess*int64(from2.wordBuf[start2]))*wordBase+y {
+ guess--
+ }
+ }
+
+ /* D4: multiply and subtract */
+ idx2 = stop2
+ idx1 = start1 + len2
+ var carry int32
+ for carry = 0; idx2 > start2; idx1-- {
+ var hi, lo int32
+ idx2--
+ x = guess * int64(from2.wordBuf[idx2])
+ hi = int32(x / wordBase)
+ lo = int32(x - int64(hi)*wordBase)
+ tmp1[idx1], carry = sub2(tmp1[idx1], lo, carry)
+ carry += hi
+ }
+ if dcarry < carry {
+ carry = 1
+ } else {
+ carry = 0
+ }
+
+ /* D5: check the remainder */
+ if carry > 0 {
+ /* D6: correct the guess */
+ guess--
+ idx2 = stop2
+ idx1 = start1 + len2
+ for carry = 0; idx2 > start2; idx1-- {
+ idx2--
+ tmp1[idx1], carry = add(tmp1[idx1], from2.wordBuf[idx2], carry)
+ }
+ }
+ }
+ if mod == nil {
+ to.wordBuf[idxTo] = int32(guess)
+ }
+ dcarry = tmp1[start1]
+ start1++
+ }
+ if mod != nil {
+ /*
+ now the result is in tmp1, it has
+ digitsInt=prec1-frac1
+ digitsFrac=max(frac1, frac2)
+ */
+ if dcarry != 0 {
+ start1--
+ tmp1[start1] = dcarry
+ }
+ idxTo = 0
+
+ digitsIntTo = prec1 - frac1 - start1*digitsPerWord
+ if digitsIntTo < 0 {
+ /* If leading zeroes in the fractional part were earlier stripped */
+ wordsIntTo = digitsIntTo / digitsPerWord
+ } else {
+ wordsIntTo = digitsToWords(digitsIntTo)
+ }
+
+ wordsFracTo = digitsToWords(int(to.digitsFrac))
+ err = nil
+ if wordsIntTo == 0 && wordsFracTo == 0 {
+ *to = zeroMyDecimal
+ return err
+ }
+ if wordsIntTo <= 0 {
+ if -wordsIntTo >= wordBufLen {
+ *to = zeroMyDecimal
+ return ErrTruncated
+ }
+ stop1 = start1 + wordsIntTo + wordsFracTo
+ wordsFracTo += wordsIntTo
+ to.digitsInt = 0
+ for wordsIntTo < 0 {
+ to.wordBuf[idxTo] = 0
+ idxTo++
+ wordsIntTo++
+ }
+ } else {
+ if wordsIntTo > wordBufLen {
+ to.digitsInt = int8(digitsPerWord * wordBufLen)
+ to.digitsFrac = 0
+ return ErrOverflow
+ }
+ stop1 = start1 + wordsIntTo + wordsFracTo
+ to.digitsInt = int8(myMin(wordsIntTo*digitsPerWord, int(from2.digitsInt)))
+ }
+ if wordsIntTo+wordsFracTo > wordBufLen {
+ stop1 -= wordsIntTo + wordsFracTo - wordBufLen
+ wordsFracTo = wordBufLen - wordsIntTo
+ to.digitsFrac = int8(wordsFracTo * digitsPerWord)
+ err = ErrTruncated
+ }
+ for start1 < stop1 {
+ to.wordBuf[idxTo] = tmp1[start1]
+ idxTo++
+ start1++
+ }
+ }
+ idxTo, digitsIntTo = to.removeLeadingZeros()
+ to.digitsInt = int8(digitsIntTo)
+ if idxTo != 0 {
+ copy(to.wordBuf[:], to.wordBuf[idxTo:])
+ }
+
+ if to.IsZero() {
+ to.negative = false
+ }
+ return err
+}
+
+// DecimalPeak returns the length of the encoded decimal.
+func DecimalPeak(b []byte) (int, error) {
+ if len(b) < 3 {
+ return 0, ErrBadNumber
+ }
+ precision := int(b[0])
+ frac := int(b[1])
+ return DecimalBinSize(precision, frac) + 2, nil
+}
+
+// NewDecFromInt creates a MyDecimal from int.
+func NewDecFromInt(i int64) *MyDecimal {
+ return new(MyDecimal).FromInt(i)
+}
+
+// NewDecFromUint creates a MyDecimal from uint.
+func NewDecFromUint(i uint64) *MyDecimal {
+ return new(MyDecimal).FromUint(i)
+}
+
+// NewDecFromFloatForTest creates a MyDecimal from float, as it returns no error, it should only be used in test.
+func NewDecFromFloatForTest(f float64) *MyDecimal {
+ dec := new(MyDecimal)
+ err := dec.FromFloat64(f)
+ if err != nil {
+ log.Panic("encountered error", zap.Error(err), zap.String("DecimalStr", strconv.FormatFloat(f, 'g', -1, 64)))
+ }
+ return dec
+}
+
+// NewDecFromStringForTest creates a MyDecimal from string, as it returns no error, it should only be used in test.
+func NewDecFromStringForTest(s string) *MyDecimal {
+ dec := new(MyDecimal)
+ err := dec.FromString([]byte(s))
+ if err != nil {
+ log.Panic("encountered error", zap.Error(err), zap.String("DecimalStr", s))
+ }
+ return dec
+}
+
+// NewMaxOrMinDec returns the max or min value decimal for given precision and fraction.
+func NewMaxOrMinDec(negative bool, prec, frac int) *MyDecimal {
+ str := make([]byte, prec+2)
+ for i := 0; i < len(str); i++ {
+ str[i] = '9'
+ }
+ if negative {
+ str[0] = '-'
+ } else {
+ str[0] = '+'
+ }
+ str[1+prec-frac] = '.'
+ dec := new(MyDecimal)
+ err := dec.FromString(str)
+ terror.Log(errors.Trace(err))
+ return dec
+}
diff --git a/pkg/types/overflow.go b/pkg/types/overflow.go
new file mode 100644
index 0000000000000000000000000000000000000000..c1533d4a4451c22d3dfd4d1f6b832de773c78849
--- /dev/null
+++ b/pkg/types/overflow.go
@@ -0,0 +1,210 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "fmt"
+ "math"
+ "time"
+
+ "github.com/pingcap/errors"
+)
+
+// AddUint64 adds uint64 a and b if no overflow, else returns error.
+func AddUint64(a uint64, b uint64) (uint64, error) {
+ if math.MaxUint64-a < b {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT UNSIGNED", fmt.Sprintf("(%d, %d)", a, b))
+ }
+ return a + b, nil
+}
+
+// AddInt64 adds int64 a and b if no overflow, otherwise returns error.
+func AddInt64(a int64, b int64) (int64, error) {
+ if (a > 0 && b > 0 && math.MaxInt64-a < b) ||
+ (a < 0 && b < 0 && math.MinInt64-a > b) {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT", fmt.Sprintf("(%d, %d)", a, b))
+ }
+
+ return a + b, nil
+}
+
+// AddDuration adds time.Duration a and b if no overflow, otherwise returns error.
+func AddDuration(a time.Duration, b time.Duration) (time.Duration, error) {
+ if (a > 0 && b > 0 && math.MaxInt64-a < b) ||
+ (a < 0 && b < 0 && math.MinInt64-a > b) {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT", fmt.Sprintf("(%d, %d)", int64(a), int64(b)))
+ }
+
+ return a + b, nil
+}
+
+// SubDuration subtracts time.Duration a with b and returns time.Duration if no overflow error.
+func SubDuration(a time.Duration, b time.Duration) (time.Duration, error) {
+ if (a > 0 && b < 0 && math.MaxInt64-a < -b) ||
+ (a < 0 && b > 0 && math.MinInt64-a > -b) ||
+ (a == 0 && b == math.MinInt64) {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT", fmt.Sprintf("(%d, %d)", a, b))
+ }
+ return a - b, nil
+}
+
+// AddInteger adds uint64 a and int64 b and returns uint64 if no overflow error.
+func AddInteger(a uint64, b int64) (uint64, error) {
+ if b >= 0 {
+ return AddUint64(a, uint64(b))
+ }
+
+ if uint64(-b) > a {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT UNSIGNED", fmt.Sprintf("(%d, %d)", a, b))
+ }
+ return a - uint64(-b), nil
+}
+
+// SubUint64 subtracts uint64 a with b and returns uint64 if no overflow error.
+func SubUint64(a uint64, b uint64) (uint64, error) {
+ if a < b {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT UNSIGNED", fmt.Sprintf("(%d, %d)", a, b))
+ }
+ return a - b, nil
+}
+
+// SubInt64 subtracts int64 a with b and returns int64 if no overflow error.
+func SubInt64(a int64, b int64) (int64, error) {
+ if (a > 0 && b < 0 && math.MaxInt64-a < -b) ||
+ (a < 0 && b > 0 && math.MinInt64-a > -b) ||
+ (a == 0 && b == math.MinInt64) {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT", fmt.Sprintf("(%d, %d)", a, b))
+ }
+ return a - b, nil
+}
+
+// SubUintWithInt subtracts uint64 a with int64 b and returns uint64 if no overflow error.
+func SubUintWithInt(a uint64, b int64) (uint64, error) {
+ if b < 0 {
+ return AddUint64(a, uint64(-b))
+ }
+ return SubUint64(a, uint64(b))
+}
+
+// SubIntWithUint subtracts int64 a with uint64 b and returns uint64 if no overflow error.
+func SubIntWithUint(a int64, b uint64) (uint64, error) {
+ if a < 0 || uint64(a) < b {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT UNSIGNED", fmt.Sprintf("(%d, %d)", a, b))
+ }
+ return uint64(a) - b, nil
+}
+
+// MulUint64 multiplies uint64 a and b and returns uint64 if no overflow error.
+func MulUint64(a uint64, b uint64) (uint64, error) {
+ if b > 0 && a > math.MaxUint64/b {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT UNSIGNED", fmt.Sprintf("(%d, %d)", a, b))
+ }
+ return a * b, nil
+}
+
+// MulInt64 multiplies int64 a and b and returns int64 if no overflow error.
+func MulInt64(a int64, b int64) (int64, error) {
+ if a == 0 || b == 0 {
+ return 0, nil
+ }
+
+ var (
+ res uint64
+ err error
+ negative = false
+ )
+
+ if a > 0 && b > 0 {
+ res, err = MulUint64(uint64(a), uint64(b))
+ } else if a < 0 && b < 0 {
+ res, err = MulUint64(uint64(-a), uint64(-b))
+ } else if a < 0 && b > 0 {
+ negative = true
+ res, err = MulUint64(uint64(-a), uint64(b))
+ } else {
+ negative = true
+ res, err = MulUint64(uint64(a), uint64(-b))
+ }
+
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+
+ if negative {
+ // negative result
+ if res > math.MaxInt64+1 {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT", fmt.Sprintf("(%d, %d)", a, b))
+ }
+
+ return -int64(res), nil
+ }
+
+ // positive result
+ if res > math.MaxInt64 {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT", fmt.Sprintf("(%d, %d)", a, b))
+ }
+
+ return int64(res), nil
+}
+
+// MulInteger multiplies uint64 a and int64 b, and returns uint64 if no overflow error.
+func MulInteger(a uint64, b int64) (uint64, error) {
+ if a == 0 || b == 0 {
+ return 0, nil
+ }
+
+ if b < 0 {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT UNSIGNED", fmt.Sprintf("(%d, %d)", a, b))
+ }
+
+ return MulUint64(a, uint64(b))
+}
+
+// DivInt64 divides int64 a with b, returns int64 if no overflow error.
+// It just checks overflow, if b is zero, a "divide by zero" panic throws.
+func DivInt64(a int64, b int64) (int64, error) {
+ if a == math.MinInt64 && b == -1 {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT", fmt.Sprintf("(%d, %d)", a, b))
+ }
+
+ return a / b, nil
+}
+
+// DivUintWithInt divides uint64 a with int64 b, returns uint64 if no overflow error.
+// It just checks overflow, if b is zero, a "divide by zero" panic throws.
+func DivUintWithInt(a uint64, b int64) (uint64, error) {
+ if b < 0 {
+ if a != 0 && uint64(-b) <= a {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT UNSIGNED", fmt.Sprintf("(%d, %d)", a, b))
+ }
+
+ return 0, nil
+ }
+
+ return a / uint64(b), nil
+}
+
+// DivIntWithUint divides int64 a with uint64 b, returns uint64 if no overflow error.
+// It just checks overflow, if b is zero, a "divide by zero" panic throws.
+func DivIntWithUint(a int64, b uint64) (uint64, error) {
+ if a < 0 {
+ if uint64(-a) >= b {
+ return 0, ErrOverflow.GenWithStackByArgs("BIGINT UNSIGNED", fmt.Sprintf("(%d, %d)", a, b))
+ }
+
+ return 0, nil
+ }
+
+ return uint64(a) / b, nil
+}
diff --git a/pkg/types/parser_driver/special_cmt_ctrl.go b/pkg/types/parser_driver/special_cmt_ctrl.go
new file mode 100644
index 0000000000000000000000000000000000000000..f7ff6ec2c2d6d1ee2c91f935e425c128a3a41191
--- /dev/null
+++ b/pkg/types/parser_driver/special_cmt_ctrl.go
@@ -0,0 +1,59 @@
+package driver
+
+import (
+ "fmt"
+ "regexp"
+
+ "github.com/pingcap/parser"
+)
+
+// To add new features that needs to be downgrade-compatible,
+// 1. Define a featureID below and make sure it is unique.
+// For example, `const FeatureIDMyFea = "my_fea"`.
+// 2. Register the new featureID in init().
+// Only the registered parser can parse the comment annotated with `my_fea`.
+// Now, the parser treats `/*T![my_fea] what_ever */` and `what_ever` equivalent.
+// In other word, the parser in old-version TiDB will ignores these comments.
+// 3. [optional] Add a pattern into FeatureIDPatterns.
+// This is only required if the new feature is contained in DDL,
+// and we want to comment out this part of SQL in binlog.
+func init() {
+ parser.SpecialCommentsController.Register(string(FeatureIDAutoRandom))
+ parser.SpecialCommentsController.Register(string(FeatureIDAutoIDCache))
+ parser.SpecialCommentsController.Register(string(FeatureIDAutoRandomBase))
+ parser.SpecialCommentsController.Register(string(FeatureClusteredIndex))
+}
+
+// SpecialCommentVersionPrefix is the prefix of TiDB executable comments.
+const SpecialCommentVersionPrefix = `/*T!`
+
+// BuildSpecialCommentPrefix returns the prefix of `featureID` special comment.
+// For some special feature in TiDB, we will refine ddl query with special comment,
+// which may be useful when
+// A: the downstream is directly MySQL instance (treat it as comment for compatibility).
+// B: the downstream is lower version TiDB (ignore the unknown feature comment).
+// C: the downstream is same/higher version TiDB (parse the feature syntax out).
+func BuildSpecialCommentPrefix(featureID featureID) string {
+ return fmt.Sprintf("%s[%s]", SpecialCommentVersionPrefix, featureID)
+}
+
+type featureID string
+
+const (
+ // FeatureIDAutoRandom is the `auto_random` feature.
+ FeatureIDAutoRandom featureID = "auto_rand"
+ // FeatureIDAutoIDCache is the `auto_id_cache` feature.
+ FeatureIDAutoIDCache featureID = "auto_id_cache"
+ // FeatureIDAutoRandomBase is the `auto_random_base` feature.
+ FeatureIDAutoRandomBase featureID = "auto_rand_base"
+ // FeatureClusteredIndex is the `clustered_index` feature.
+ FeatureClusteredIndex featureID = "clustered_index"
+)
+
+// FeatureIDPatterns is used to record special comments patterns.
+var FeatureIDPatterns = map[featureID]*regexp.Regexp{
+ FeatureIDAutoRandom: regexp.MustCompile(`(?P<REPLACE>(?i)AUTO_RANDOM\b\s*(\s*\(\s*\d+\s*\)\s*)?)`),
+ FeatureIDAutoIDCache: regexp.MustCompile(`(?P<REPLACE>(?i)AUTO_ID_CACHE\s*=?\s*\d+\s*)`),
+ FeatureIDAutoRandomBase: regexp.MustCompile(`(?P<REPLACE>(?i)AUTO_RANDOM_BASE\s*=?\s*\d+\s*)`),
+ FeatureClusteredIndex: regexp.MustCompile(`(?i)(PRIMARY)?\s+KEY(\s*\(.*\))?\s+(?P<REPLACE>(NON)?CLUSTERED\b)`),
+}
diff --git a/pkg/types/parser_driver/value_expr.go b/pkg/types/parser_driver/value_expr.go
new file mode 100644
index 0000000000000000000000000000000000000000..812769dd5271f4314be4b295598067888c0e4355
--- /dev/null
+++ b/pkg/types/parser_driver/value_expr.go
@@ -0,0 +1,254 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package driver
+
+import (
+ "fmt"
+ "io"
+ "strconv"
+ "strings"
+
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser/ast"
+ "github.com/pingcap/parser/format"
+ "github.com/pingcap/parser/mysql"
+ "matrixbase/pkg/types"
+ "matrixbase/pkg/util/hack"
+)
+
+// The purpose of driver package is to decompose the dependency of the parser and
+// types package.
+// It provides the NewValueExpr function for the ast package, so the ast package
+// do not depends on the concrete definition of `types.Datum`, thus get rid of
+// the dependency of the types package.
+// The parser package depends on the ast package, but not the types package.
+// The whole relationship:
+// ast imports []
+// tidb/types imports [parser/types]
+// parser imports [ast, parser/types]
+// driver imports [ast, tidb/types]
+// tidb imports [parser, driver]
+
+func init() {
+ ast.NewValueExpr = newValueExpr
+ ast.NewParamMarkerExpr = newParamMarkerExpr
+ ast.NewDecimal = func(str string) (interface{}, error) {
+ dec := new(types.MyDecimal)
+ err := dec.FromString(hack.Slice(str))
+ if err == types.ErrTruncated {
+ err = nil
+ }
+ return dec, err
+ }
+ ast.NewHexLiteral = func(str string) (interface{}, error) {
+ h, err := types.NewHexLiteral(str)
+ return h, err
+ }
+ ast.NewBitLiteral = func(str string) (interface{}, error) {
+ b, err := types.NewBitLiteral(str)
+ return b, err
+ }
+}
+
+var (
+ _ ast.ParamMarkerExpr = &ParamMarkerExpr{}
+ _ ast.ValueExpr = &ValueExpr{}
+)
+
+// ValueExpr is the simple value expression.
+type ValueExpr struct {
+ ast.TexprNode
+ types.Datum
+ projectionOffset int
+}
+
+// SetValue implements interface of ast.ValueExpr.
+func (n *ValueExpr) SetValue(res interface{}) {
+ n.Datum.SetValueWithDefaultCollation(res)
+}
+
+// Restore implements Node interface.
+func (n *ValueExpr) Restore(ctx *format.RestoreCtx) error {
+ switch n.Kind() {
+ case types.KindNull:
+ ctx.WriteKeyWord("NULL")
+ case types.KindInt64:
+ if n.Type.Flag&mysql.IsBooleanFlag != 0 {
+ if n.GetInt64() > 0 {
+ ctx.WriteKeyWord("TRUE")
+ } else {
+ ctx.WriteKeyWord("FALSE")
+ }
+ } else {
+ ctx.WritePlain(strconv.FormatInt(n.GetInt64(), 10))
+ }
+ case types.KindUint64:
+ ctx.WritePlain(strconv.FormatUint(n.GetUint64(), 10))
+ case types.KindFloat32:
+ ctx.WritePlain(strconv.FormatFloat(n.GetFloat64(), 'e', -1, 32))
+ case types.KindFloat64:
+ ctx.WritePlain(strconv.FormatFloat(n.GetFloat64(), 'e', -1, 64))
+ case types.KindString:
+ // This part is used to process flag HasStringWithoutDefaultCharset, which means if we have this flag and the
+ // charset is mysql.DefaultCharset, we don't need to write the default.
+ if n.Type.Charset != "" &&
+ !ctx.Flags.HasStringWithoutCharset() &&
+ (!ctx.Flags.HasStringWithoutDefaultCharset() || n.Type.Charset != mysql.DefaultCharset) {
+ ctx.WritePlain("_")
+ ctx.WriteKeyWord(n.Type.Charset)
+ }
+ // Replace '\' to '\\' regardless of sql_mode "NO_BACKSLASH_ESCAPES", which is the same as MySQL.
+ ctx.WriteString(strings.ReplaceAll(n.GetString(), "\\", "\\\\"))
+ case types.KindBytes:
+ ctx.WriteString(n.GetString())
+ case types.KindMysqlDecimal:
+ ctx.WritePlain(n.GetMysqlDecimal().String())
+ case types.KindBinaryLiteral:
+ if n.Type.Flag&mysql.UnsignedFlag != 0 {
+ ctx.WritePlainf("x'%x'", n.GetBytes())
+ } else {
+ ctx.WritePlain(n.GetBinaryLiteral().ToBitLiteralString(true))
+ }
+ case types.KindMysqlDuration:
+ ctx.WritePlainf("'%s'", n.GetMysqlDuration())
+ case types.KindMysqlTime:
+ ctx.WritePlainf("'%s'", n.GetMysqlTime())
+ case types.KindMysqlEnum,
+ types.KindMysqlBit, types.KindMysqlSet,
+ types.KindInterface, types.KindMinNotNull, types.KindMaxValue,
+ types.KindRaw, types.KindMysqlJSON:
+ // TODO implement Restore function
+ return errors.New("Not implemented")
+ default:
+ return errors.New("can't format to string")
+ }
+ return nil
+}
+
+// GetDatumString implements the ast.ValueExpr interface.
+func (n *ValueExpr) GetDatumString() string {
+ return n.GetString()
+}
+
+// Format the ExprNode into a Writer.
+func (n *ValueExpr) Format(w io.Writer) {
+ var s string
+ switch n.Kind() {
+ case types.KindNull:
+ s = "NULL"
+ case types.KindInt64:
+ if n.Type.Flag&mysql.IsBooleanFlag != 0 {
+ if n.GetInt64() > 0 {
+ s = "TRUE"
+ } else {
+ s = "FALSE"
+ }
+ } else {
+ s = strconv.FormatInt(n.GetInt64(), 10)
+ }
+ case types.KindUint64:
+ s = strconv.FormatUint(n.GetUint64(), 10)
+ case types.KindFloat32:
+ s = strconv.FormatFloat(n.GetFloat64(), 'e', -1, 32)
+ case types.KindFloat64:
+ s = strconv.FormatFloat(n.GetFloat64(), 'e', -1, 64)
+ case types.KindString, types.KindBytes:
+ s = strconv.Quote(n.GetString())
+ case types.KindMysqlDecimal:
+ s = n.GetMysqlDecimal().String()
+ case types.KindBinaryLiteral:
+ if n.Type.Flag&mysql.UnsignedFlag != 0 {
+ s = fmt.Sprintf("x'%x'", n.GetBytes())
+ } else {
+ s = n.GetBinaryLiteral().ToBitLiteralString(true)
+ }
+ default:
+ panic("Can't format to string")
+ }
+ fmt.Fprint(w, s)
+}
+
+// newValueExpr creates a ValueExpr with value, and sets default field type.
+func newValueExpr(value interface{}, charset string, collate string) ast.ValueExpr {
+ if ve, ok := value.(*ValueExpr); ok {
+ return ve
+ }
+ ve := &ValueExpr{}
+ // We need to keep the ve.Type.Collate equals to ve.Datum.collation.
+ types.DefaultTypeForValue(value, &ve.Type, charset, collate)
+ ve.Datum.SetValue(value, &ve.Type)
+ ve.projectionOffset = -1
+ return ve
+}
+
+// SetProjectionOffset sets ValueExpr.projectionOffset for logical plan builder.
+func (n *ValueExpr) SetProjectionOffset(offset int) {
+ n.projectionOffset = offset
+}
+
+// GetProjectionOffset returns ValueExpr.projectionOffset.
+func (n *ValueExpr) GetProjectionOffset() int {
+ return n.projectionOffset
+}
+
+// Accept implements Node interface.
+func (n *ValueExpr) Accept(v ast.Visitor) (ast.Node, bool) {
+ newNode, skipChildren := v.Enter(n)
+ if skipChildren {
+ return v.Leave(newNode)
+ }
+ n = newNode.(*ValueExpr)
+ return v.Leave(n)
+}
+
+// ParamMarkerExpr expression holds a place for another expression.
+// Used in parsing prepare statement.
+type ParamMarkerExpr struct {
+ ValueExpr
+ Offset int
+ Order int
+ InExecute bool
+}
+
+// Restore implements Node interface.
+func (n *ParamMarkerExpr) Restore(ctx *format.RestoreCtx) error {
+ ctx.WritePlain("?")
+ return nil
+}
+
+func newParamMarkerExpr(offset int) ast.ParamMarkerExpr {
+ return &ParamMarkerExpr{
+ Offset: offset,
+ }
+}
+
+// Format the ExprNode into a Writer.
+func (n *ParamMarkerExpr) Format(w io.Writer) {
+ panic("Not implemented")
+}
+
+// Accept implements Node Accept interface.
+func (n *ParamMarkerExpr) Accept(v ast.Visitor) (ast.Node, bool) {
+ newNode, skipChildren := v.Enter(n)
+ if skipChildren {
+ return v.Leave(newNode)
+ }
+ n = newNode.(*ParamMarkerExpr)
+ return v.Leave(n)
+}
+
+// SetOrder implements the ast.ParamMarkerExpr interface.
+func (n *ParamMarkerExpr) SetOrder(order int) {
+ n.Order = order
+}
diff --git a/pkg/types/set.go b/pkg/types/set.go
new file mode 100644
index 0000000000000000000000000000000000000000..48f4f0ae50db1a7f81e22ccff2dc9823e4a5e5cb
--- /dev/null
+++ b/pkg/types/set.go
@@ -0,0 +1,131 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "strconv"
+ "strings"
+
+ "github.com/pingcap/errors"
+ "matrixbase/pkg/util/collate"
+ "matrixbase/pkg/util/stringutil"
+)
+
+var zeroSet = Set{Name: "", Value: 0}
+
+// Set is for MySQL Set type.
+type Set struct {
+ Name string
+ Value uint64
+}
+
+// String implements fmt.Stringer interface.
+func (e Set) String() string {
+ return e.Name
+}
+
+// ToNumber changes Set to float64 for numeric operation.
+func (e Set) ToNumber() float64 {
+ return float64(e.Value)
+}
+
+// Copy deep copy a Set.
+func (e Set) Copy() Set {
+ return Set{
+ Name: stringutil.Copy(e.Name),
+ Value: e.Value,
+ }
+}
+
+// ParseSet creates a Set with name or value.
+func ParseSet(elems []string, name string, collation string) (Set, error) {
+ if setName, err := ParseSetName(elems, name, collation); err == nil {
+ return setName, nil
+ }
+ // name doesn't exist, maybe an integer?
+ if num, err := strconv.ParseUint(name, 0, 64); err == nil {
+ return ParseSetValue(elems, num)
+ }
+
+ return Set{}, errors.Errorf("item %s is not in Set %v", name, elems)
+}
+
+// ParseSetName creates a Set with name.
+func ParseSetName(elems []string, name string, collation string) (Set, error) {
+ if len(name) == 0 {
+ return zeroSet, nil
+ }
+
+ ctor := collate.GetCollator(collation)
+
+ seps := strings.Split(name, ",")
+ marked := make(map[string]struct{}, len(seps))
+ for _, s := range seps {
+ marked[string(ctor.Key(s))] = struct{}{}
+ }
+ items := make([]string, 0, len(seps))
+
+ value := uint64(0)
+ for i, n := range elems {
+ key := string(ctor.Key(n))
+ if _, ok := marked[key]; ok {
+ value |= 1 << uint64(i)
+ delete(marked, key)
+ items = append(items, n)
+ }
+ }
+
+ if len(marked) == 0 {
+ return Set{Name: strings.Join(items, ","), Value: value}, nil
+ }
+
+ return Set{}, errors.Errorf("item %s is not in Set %v", name, elems)
+}
+
+var (
+ setIndexValue []uint64
+ setIndexInvertValue []uint64
+)
+
+func init() {
+ setIndexValue = make([]uint64, 64)
+ setIndexInvertValue = make([]uint64, 64)
+
+ for i := 0; i < 64; i++ {
+ setIndexValue[i] = 1 << uint64(i)
+ setIndexInvertValue[i] = ^setIndexValue[i]
+ }
+}
+
+// ParseSetValue creates a Set with special number.
+func ParseSetValue(elems []string, number uint64) (Set, error) {
+ if number == 0 {
+ return zeroSet, nil
+ }
+
+ value := number
+ var items []string
+ for i := 0; i < len(elems); i++ {
+ if number&setIndexValue[i] > 0 {
+ items = append(items, elems[i])
+ number &= setIndexInvertValue[i]
+ }
+ }
+
+ if number != 0 {
+ return Set{}, errors.Errorf("invalid number %d for Set %v", number, elems)
+ }
+
+ return Set{Name: strings.Join(items, ","), Value: value}, nil
+}
diff --git a/pkg/types/time.go b/pkg/types/time.go
new file mode 100644
index 0000000000000000000000000000000000000000..00da078ba9d1347bdb9f3d770426fe178cf08229
--- /dev/null
+++ b/pkg/types/time.go
@@ -0,0 +1,3317 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+ "bytes"
+ "fmt"
+ "math"
+ "regexp"
+ "strconv"
+ "strings"
+ gotime "time"
+ "unicode"
+
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser/mysql"
+ "github.com/pingcap/parser/terror"
+ // "github.com/pingcap/tidb/util/logutil"
+ "matrixbase/pkg/sessionctx/stmtctx"
+ tidbMath "matrixbase/pkg/util/math"
+ "matrixbase/pkg/util/parser"
+)
+
+// Time format without fractional seconds precision.
+const (
+ DateFormat = "2006-01-02"
+ TimeFormat = "2006-01-02 15:04:05"
+ // TimeFSPFormat is time format with fractional seconds precision.
+ TimeFSPFormat = "2006-01-02 15:04:05.000000"
+)
+
+const (
+ // MinYear is the minimum for mysql year type.
+ MinYear int16 = 1901
+ // MaxYear is the maximum for mysql year type.
+ MaxYear int16 = 2155
+ // MaxDuration is the maximum for duration.
+ MaxDuration int64 = 838*10000 + 59*100 + 59
+ // MinTime is the minimum for mysql time type.
+ MinTime = -gotime.Duration(838*3600+59*60+59) * gotime.Second
+ // MaxTime is the maximum for mysql time type.
+ MaxTime = gotime.Duration(838*3600+59*60+59) * gotime.Second
+ // ZeroDatetimeStr is the string representation of a zero datetime.
+ ZeroDatetimeStr = "0000-00-00 00:00:00"
+ // ZeroDateStr is the string representation of a zero date.
+ ZeroDateStr = "0000-00-00"
+
+ // TimeMaxHour is the max hour for mysql time type.
+ TimeMaxHour = 838
+ // TimeMaxMinute is the max minute for mysql time type.
+ TimeMaxMinute = 59
+ // TimeMaxSecond is the max second for mysql time type.
+ TimeMaxSecond = 59
+ // TimeMaxValue is the maximum value for mysql time type.
+ TimeMaxValue = TimeMaxHour*10000 + TimeMaxMinute*100 + TimeMaxSecond
+ // TimeMaxValueSeconds is the maximum second value for mysql time type.
+ TimeMaxValueSeconds = TimeMaxHour*3600 + TimeMaxMinute*60 + TimeMaxSecond
+)
+
+const (
+ // YearIndex is index of 'YEARS-MONTHS DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format
+ YearIndex = 0 + iota
+ // MonthIndex is index of 'YEARS-MONTHS DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format
+ MonthIndex
+ // DayIndex is index of 'YEARS-MONTHS DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format
+ DayIndex
+ // HourIndex is index of 'YEARS-MONTHS DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format
+ HourIndex
+ // MinuteIndex is index of 'YEARS-MONTHS DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format
+ MinuteIndex
+ // SecondIndex is index of 'YEARS-MONTHS DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format
+ SecondIndex
+ // MicrosecondIndex is index of 'YEARS-MONTHS DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format
+ MicrosecondIndex
+)
+
+const (
+ // YearMonthMaxCnt is max parameters count 'YEARS-MONTHS' expr Format allowed
+ YearMonthMaxCnt = 2
+ // DayHourMaxCnt is max parameters count 'DAYS HOURS' expr Format allowed
+ DayHourMaxCnt = 2
+ // DayMinuteMaxCnt is max parameters count 'DAYS HOURS:MINUTES' expr Format allowed
+ DayMinuteMaxCnt = 3
+ // DaySecondMaxCnt is max parameters count 'DAYS HOURS:MINUTES:SECONDS' expr Format allowed
+ DaySecondMaxCnt = 4
+ // DayMicrosecondMaxCnt is max parameters count 'DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format allowed
+ DayMicrosecondMaxCnt = 5
+ // HourMinuteMaxCnt is max parameters count 'HOURS:MINUTES' expr Format allowed
+ HourMinuteMaxCnt = 2
+ // HourSecondMaxCnt is max parameters count 'HOURS:MINUTES:SECONDS' expr Format allowed
+ HourSecondMaxCnt = 3
+ // HourMicrosecondMaxCnt is max parameters count 'HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format allowed
+ HourMicrosecondMaxCnt = 4
+ // MinuteSecondMaxCnt is max parameters count 'MINUTES:SECONDS' expr Format allowed
+ MinuteSecondMaxCnt = 2
+ // MinuteMicrosecondMaxCnt is max parameters count 'MINUTES:SECONDS.MICROSECONDS' expr Format allowed
+ MinuteMicrosecondMaxCnt = 3
+ // SecondMicrosecondMaxCnt is max parameters count 'SECONDS.MICROSECONDS' expr Format allowed
+ SecondMicrosecondMaxCnt = 2
+ // TimeValueCnt is parameters count 'YEARS-MONTHS DAYS HOURS:MINUTES:SECONDS.MICROSECONDS' expr Format
+ TimeValueCnt = 7
+)
+
+// Zero values for different types.
+var (
+ // ZeroDuration is the zero value for Duration type.
+ ZeroDuration = Duration{Duration: gotime.Duration(0), Fsp: DefaultFsp}
+
+ // ZeroCoreTime is the zero value for Time type.
+ ZeroTime = Time{}
+
+ // ZeroDatetime is the zero value for datetime Time.
+ ZeroDatetime = NewTime(ZeroCoreTime, mysql.TypeDatetime, DefaultFsp)
+
+ // ZeroTimestamp is the zero value for timestamp Time.
+ ZeroTimestamp = NewTime(ZeroCoreTime, mysql.TypeTimestamp, DefaultFsp)
+
+ // ZeroDate is the zero value for date Time.
+ ZeroDate = NewTime(ZeroCoreTime, mysql.TypeDate, DefaultFsp)
+)
+
+var (
+ // MinDatetime is the minimum for Golang Time type.
+ MinDatetime = FromDate(1, 1, 1, 0, 0, 0, 0)
+ // MaxDatetime is the maximum for mysql datetime type.
+ MaxDatetime = FromDate(9999, 12, 31, 23, 59, 59, 999999)
+
+ // BoundTimezone is the timezone for min and max timestamp.
+ BoundTimezone = gotime.UTC
+ // MinTimestamp is the minimum for mysql timestamp type.
+ MinTimestamp = NewTime(FromDate(1970, 1, 1, 0, 0, 1, 0), mysql.TypeTimestamp, DefaultFsp)
+ // MaxTimestamp is the maximum for mysql timestamp type.
+ MaxTimestamp = NewTime(FromDate(2038, 1, 19, 3, 14, 7, 999999), mysql.TypeTimestamp, DefaultFsp)
+
+ // WeekdayNames lists names of weekdays, which are used in builtin time function `dayname`.
+ WeekdayNames = []string{
+ "Monday",
+ "Tuesday",
+ "Wednesday",
+ "Thursday",
+ "Friday",
+ "Saturday",
+ "Sunday",
+ }
+
+ // MonthNames lists names of months, which are used in builtin time function `monthname`.
+ MonthNames = []string{
+ "January", "February",
+ "March", "April",
+ "May", "June",
+ "July", "August",
+ "September", "October",
+ "November", "December",
+ }
+)
+
+const (
+ // GoDurationDay is the gotime.Duration which equals to a Day.
+ GoDurationDay = gotime.Hour * 24
+ // GoDurationWeek is the gotime.Duration which equals to a Week.
+ GoDurationWeek = GoDurationDay * 7
+)
+
+// FromGoTime translates time.Time to mysql time internal representation.
+func FromGoTime(t gotime.Time) CoreTime {
+ // Plus 500 nanosecond for rounding of the millisecond part.
+ t = t.Add(500 * gotime.Nanosecond)
+
+ year, month, day := t.Date()
+ hour, minute, second := t.Clock()
+ microsecond := t.Nanosecond() / 1000
+ return FromDate(year, int(month), day, hour, minute, second, microsecond)
+}
+
+// FromDate makes a internal time representation from the given date.
+func FromDate(year int, month int, day int, hour int, minute int, second int, microsecond int) CoreTime {
+ v := uint64(ZeroCoreTime)
+ v |= (uint64(microsecond) << microsecondBitFieldOffset) & microsecondBitFieldMask
+ v |= (uint64(second) << secondBitFieldOffset) & secondBitFieldMask
+ v |= (uint64(minute) << minuteBitFieldOffset) & minuteBitFieldMask
+ v |= (uint64(hour) << hourBitFieldOffset) & hourBitFieldMask
+ v |= (uint64(day) << dayBitFieldOffset) & dayBitFieldMask
+ v |= (uint64(month) << monthBitFieldOffset) & monthBitFieldMask
+ v |= (uint64(year) << yearBitFieldOffset) & yearBitFieldMask
+ return CoreTime(v)
+}
+
+// FromDateChecked makes a internal time representation from the given date with field overflow check.
+func FromDateChecked(year, month, day, hour, minute, second, microsecond int) (CoreTime, bool) {
+ if uint64(year) >= (1<<yearBitFieldWidth) ||
+ uint64(month) >= (1<<monthBitFieldWidth) ||
+ uint64(day) >= (1<<dayBitFieldWidth) ||
+ uint64(hour) >= (1<<hourBitFieldWidth) ||
+ uint64(minute) >= (1<<minuteBitFieldWidth) ||
+ uint64(second) >= (1<<secondBitFieldWidth) ||
+ uint64(microsecond) >= (1<<microsecondBitFieldWidth) {
+ return ZeroCoreTime, false
+ }
+ return FromDate(year, month, day, hour, minute, second, microsecond), true
+}
+
+// coreTime is an alias to CoreTime, embedd in Time.
+type coreTime = CoreTime
+
+// Time is the struct for handling datetime, timestamp and date.
+type Time struct {
+ coreTime
+}
+
+// Clock returns the hour, minute, and second within the day specified by t.
+func (t Time) Clock() (hour int, minute int, second int) {
+ return t.Hour(), t.Minute(), t.Second()
+}
+
+const (
+ // Core time bit fields.
+ yearBitFieldOffset, yearBitFieldWidth uint64 = 50, 14
+ monthBitFieldOffset, monthBitFieldWidth uint64 = 46, 4
+ dayBitFieldOffset, dayBitFieldWidth uint64 = 41, 5
+ hourBitFieldOffset, hourBitFieldWidth uint64 = 36, 5
+ minuteBitFieldOffset, minuteBitFieldWidth uint64 = 30, 6
+ secondBitFieldOffset, secondBitFieldWidth uint64 = 24, 6
+ microsecondBitFieldOffset, microsecondBitFieldWidth uint64 = 4, 20
+
+ // fspTt bit field.
+ // `fspTt` format:
+ // | fsp: 3 bits | type: 1 bit |
+ // When `fsp` is valid (in range [0, 6]):
+ // 1. `type` bit 0 represent `DateTime`
+ // 2. `type` bit 1 represent `Timestamp`
+ //
+ // Since s`Date` does not require `fsp`, we could use `fspTt` == 0b1110 to represent it.
+ fspTtBitFieldOffset, fspTtBitFieldWidth uint64 = 0, 4
+
+ yearBitFieldMask uint64 = ((1 << yearBitFieldWidth) - 1) << yearBitFieldOffset
+ monthBitFieldMask uint64 = ((1 << monthBitFieldWidth) - 1) << monthBitFieldOffset
+ dayBitFieldMask uint64 = ((1 << dayBitFieldWidth) - 1) << dayBitFieldOffset
+ hourBitFieldMask uint64 = ((1 << hourBitFieldWidth) - 1) << hourBitFieldOffset
+ minuteBitFieldMask uint64 = ((1 << minuteBitFieldWidth) - 1) << minuteBitFieldOffset
+ secondBitFieldMask uint64 = ((1 << secondBitFieldWidth) - 1) << secondBitFieldOffset
+ microsecondBitFieldMask uint64 = ((1 << microsecondBitFieldWidth) - 1) << microsecondBitFieldOffset
+ fspTtBitFieldMask uint64 = ((1 << fspTtBitFieldWidth) - 1) << fspTtBitFieldOffset
+
+ fspTtForDate uint8 = 0b1110
+ fspBitFieldMask uint64 = 0b1110
+ coreTimeBitFieldMask = ^fspTtBitFieldMask
+)
+
+// NewTime constructs time from core time, type and fsp.
+func NewTime(coreTime CoreTime, tp uint8, fsp int8) Time {
+ t := ZeroTime
+ p := (*uint64)(&t.coreTime)
+ *p |= (uint64(coreTime) & coreTimeBitFieldMask)
+ if tp == mysql.TypeDate {
+ *p |= uint64(fspTtForDate)
+ return t
+ }
+ if fsp == UnspecifiedFsp {
+ fsp = DefaultFsp
+ }
+ *p |= uint64(fsp) << 1
+ if tp == mysql.TypeTimestamp {
+ *p |= 1
+ }
+ return t
+}
+
+func (t Time) getFspTt() uint8 {
+ return uint8(uint64(t.coreTime) & fspTtBitFieldMask)
+}
+
+func (t *Time) setFspTt(fspTt uint8) {
+ *(*uint64)(&t.coreTime) &= ^(fspTtBitFieldMask)
+ *(*uint64)(&t.coreTime) |= uint64(fspTt)
+}
+
+// Type returns type value.
+func (t Time) Type() uint8 {
+ if t.getFspTt() == fspTtForDate {
+ return mysql.TypeDate
+ }
+ if uint64(t.coreTime)&1 == 1 {
+ return mysql.TypeTimestamp
+ }
+ return mysql.TypeDatetime
+}
+
+// Fsp returns fsp value.
+func (t Time) Fsp() int8 {
+ fspTt := t.getFspTt()
+ if fspTt == fspTtForDate {
+ return 0
+ }
+ return int8(fspTt >> 1)
+}
+
+// SetType updates the type in Time.
+// Only DateTime/Date/Timestamp is valid.
+func (t *Time) SetType(tp uint8) {
+ fspTt := t.getFspTt()
+ if fspTt == fspTtForDate && tp != mysql.TypeDate {
+ fspTt = 0
+ }
+ switch tp {
+ case mysql.TypeDate:
+ fspTt = fspTtForDate
+ case mysql.TypeTimestamp:
+ fspTt |= 1
+ case mysql.TypeDatetime:
+ fspTt &= ^(uint8(1))
+ }
+ t.setFspTt(fspTt)
+}
+
+// SetFsp updates the fsp in Time.
+func (t *Time) SetFsp(fsp int8) {
+ if t.getFspTt() == fspTtForDate {
+ return
+ }
+ if fsp == UnspecifiedFsp {
+ fsp = DefaultFsp
+ }
+ *(*uint64)(&t.coreTime) &= ^(fspBitFieldMask)
+ *(*uint64)(&t.coreTime) |= (uint64(fsp) << 1)
+}
+
+// CoreTime returns core time.
+func (t Time) CoreTime() CoreTime {
+ return CoreTime(uint64(t.coreTime) & coreTimeBitFieldMask)
+}
+
+// SetCoreTime updates core time.
+func (t *Time) SetCoreTime(ct CoreTime) {
+ *(*uint64)(&t.coreTime) &= ^coreTimeBitFieldMask
+ *(*uint64)(&t.coreTime) |= (uint64(ct) & coreTimeBitFieldMask)
+}
+
+// CurrentTime returns current time with type tp.
+func CurrentTime(tp uint8) Time {
+ return NewTime(FromGoTime(gotime.Now()), tp, 0)
+}
+
+// ConvertTimeZone converts the time value from one timezone to another.
+// The input time should be a valid timestamp.
+func (t *Time) ConvertTimeZone(from, to *gotime.Location) error {
+ if !t.IsZero() {
+ raw, err := t.GoTime(from)
+ if err != nil {
+ return errors.Trace(err)
+ }
+ converted := raw.In(to)
+ t.SetCoreTime(FromGoTime(converted))
+ }
+ return nil
+}
+
+func (t Time) String() string {
+ if t.Type() == mysql.TypeDate {
+ // We control the format, so no error would occur.
+ str, err := t.DateFormat("%Y-%m-%d")
+ terror.Log(errors.Trace(err))
+ return str
+ }
+
+ str, err := t.DateFormat("%Y-%m-%d %H:%i:%s")
+ terror.Log(errors.Trace(err))
+ fsp := t.Fsp()
+ if fsp > 0 {
+ tmp := fmt.Sprintf(".%06d", t.Microsecond())
+ str = str + tmp[:1+fsp]
+ }
+
+ return str
+}
+
+// IsZero returns a boolean indicating whether the time is equal to ZeroCoreTime.
+func (t Time) IsZero() bool {
+ return compareTime(t.coreTime, ZeroCoreTime) == 0
+}
+
+// InvalidZero returns a boolean indicating whether the month or day is zero.
+func (t Time) InvalidZero() bool {
+ return t.Month() == 0 || t.Day() == 0
+}
+
+const numberFormat = "%Y%m%d%H%i%s"
+const dateFormat = "%Y%m%d"
+
+// ToNumber returns a formatted number.
+// e.g,
+// 2012-12-12 -> 20121212
+// 2012-12-12T10:10:10 -> 20121212101010
+// 2012-12-12T10:10:10.123456 -> 20121212101010.123456
+func (t Time) ToNumber() *MyDecimal {
+ dec := new(MyDecimal)
+ t.FillNumber(dec)
+ return dec
+}
+
+// FillNumber is the same as ToNumber,
+// but reuses input decimal instead of allocating one.
+func (t Time) FillNumber(dec *MyDecimal) {
+ if t.IsZero() {
+ dec.FromInt(0)
+ return
+ }
+
+ // Fix issue #1046
+ // Prevents from converting 2012-12-12 to 20121212000000
+ var tfStr string
+ if t.Type() == mysql.TypeDate {
+ tfStr = dateFormat
+ } else {
+ tfStr = numberFormat
+ }
+
+ s, err := t.DateFormat(tfStr)
+ if err != nil {
+ // logutil.BgLogger().Error("[fatal] never happen because we've control the format!")
+ }
+
+ fsp := t.Fsp()
+ if fsp > 0 {
+ s1 := fmt.Sprintf("%s.%06d", s, t.Microsecond())
+ s = s1[:len(s)+int(fsp)+1]
+ }
+ // We skip checking error here because time formatted string can be parsed certainly.
+ err = dec.FromString([]byte(s))
+ terror.Log(errors.Trace(err))
+}
+
+// Convert converts t with type tp.
+func (t Time) Convert(sc *stmtctx.StatementContext, tp uint8) (Time, error) {
+ t1 := t
+ if t.Type() == tp || t.IsZero() {
+ t1.SetType(tp)
+ return t1, nil
+ }
+
+ t1.SetType(tp)
+ err := t1.check(sc)
+ return t1, errors.Trace(err)
+}
+
+// ConvertToDuration converts mysql datetime, timestamp and date to mysql time type.
+// e.g,
+// 2012-12-12T10:10:10 -> 10:10:10
+// 2012-12-12 -> 0
+func (t Time) ConvertToDuration() (Duration, error) {
+ if t.IsZero() {
+ return ZeroDuration, nil
+ }
+
+ hour, minute, second := t.Clock()
+ frac := t.Microsecond() * 1000
+
+ d := gotime.Duration(hour*3600+minute*60+second)*gotime.Second + gotime.Duration(frac)
+ // TODO: check convert validation
+ return Duration{Duration: d, Fsp: t.Fsp()}, nil
+}
+
+// Compare returns an integer comparing the time instant t to o.
+// If t is after o, returns 1, equal o, returns 0, before o, returns -1.
+func (t Time) Compare(o Time) int {
+ return compareTime(t.coreTime, o.coreTime)
+}
+
+// CompareString is like Compare,
+// but parses string to Time then compares.
+func (t Time) CompareString(sc *stmtctx.StatementContext, str string) (int, error) {
+ // use MaxFsp to parse the string
+ o, err := ParseTime(sc, str, t.Type(), MaxFsp)
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+
+ return t.Compare(o), nil
+}
+
+// roundTime rounds the time value according to digits count specified by fsp.
+func roundTime(t gotime.Time, fsp int8) gotime.Time {
+ d := gotime.Duration(math.Pow10(9 - int(fsp)))
+ return t.Round(d)
+}
+
+// RoundFrac rounds the fraction part of a time-type value according to `fsp`.
+func (t Time) RoundFrac(sc *stmtctx.StatementContext, fsp int8) (Time, error) {
+ if t.Type() == mysql.TypeDate || t.IsZero() {
+ // date type has no fsp
+ return t, nil
+ }
+
+ fsp, err := CheckFsp(int(fsp))
+ if err != nil {
+ return t, errors.Trace(err)
+ }
+
+ if fsp == t.Fsp() {
+ // have same fsp
+ return t, nil
+ }
+
+ var nt CoreTime
+ if t1, err := t.GoTime(sc.TimeZone); err == nil {
+ t1 = roundTime(t1, fsp)
+ nt = FromGoTime(t1)
+ } else {
+ // Take the hh:mm:ss part out to avoid handle month or day = 0.
+ hour, minute, second, microsecond := t.Hour(), t.Minute(), t.Second(), t.Microsecond()
+ t1 := gotime.Date(1, 1, 1, hour, minute, second, microsecond*1000, sc.TimeZone)
+ t2 := roundTime(t1, fsp)
+ hour, minute, second = t2.Clock()
+ microsecond = t2.Nanosecond() / 1000
+
+ // TODO: when hh:mm:ss overflow one day after rounding, it should be add to yy:mm:dd part,
+ // but mm:dd may contain 0, it makes the code complex, so we ignore it here.
+ if t2.Day()-1 > 0 {
+ return t, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, t.String()))
+ }
+ var ok bool
+ nt, ok = FromDateChecked(t.Year(), t.Month(), t.Day(), hour, minute, second, microsecond)
+ if !ok {
+ return t, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, t.String()))
+ }
+ }
+
+ return NewTime(nt, t.Type(), fsp), nil
+}
+
+// GetFsp gets the fsp of a string.
+func GetFsp(s string) int8 {
+ index := GetFracIndex(s)
+ var fsp int
+ if index < 0 {
+ fsp = 0
+ } else {
+ fsp = len(s) - index - 1
+ }
+
+ if fsp == len(s) {
+ fsp = 0
+ } else if fsp > 6 {
+ fsp = 6
+ }
+ return int8(fsp)
+}
+
+// GetFracIndex finds the last '.' for get fracStr, index = -1 means fracStr not found.
+// but for format like '2019.01.01 00:00:00', the index should be -1.
+func GetFracIndex(s string) (index int) {
+ index = -1
+ for i := len(s) - 1; i >= 0; i-- {
+ if unicode.IsPunct(rune(s[i])) {
+ if s[i] == '.' {
+ index = i
+ }
+ break
+ }
+ }
+
+ return index
+}
+
+// RoundFrac rounds fractional seconds precision with new fsp and returns a new one.
+// We will use the “round half up” rule, e.g, >= 0.5 -> 1, < 0.5 -> 0,
+// so 2011:11:11 10:10:10.888888 round 0 -> 2011:11:11 10:10:11
+// and 2011:11:11 10:10:10.111111 round 0 -> 2011:11:11 10:10:10
+func RoundFrac(t gotime.Time, fsp int8) (gotime.Time, error) {
+ _, err := CheckFsp(int(fsp))
+ if err != nil {
+ return t, errors.Trace(err)
+ }
+ return t.Round(gotime.Duration(math.Pow10(9-int(fsp))) * gotime.Nanosecond), nil
+}
+
+// TruncateFrac truncates fractional seconds precision with new fsp and returns a new one.
+// 2011:11:11 10:10:10.888888 round 0 -> 2011:11:11 10:10:10
+// 2011:11:11 10:10:10.111111 round 0 -> 2011:11:11 10:10:10
+func TruncateFrac(t gotime.Time, fsp int8) (gotime.Time, error) {
+ if _, err := CheckFsp(int(fsp)); err != nil {
+ return t, err
+ }
+ return t.Truncate(gotime.Duration(math.Pow10(9-int(fsp))) * gotime.Nanosecond), nil
+}
+
+// ToPackedUint encodes Time to a packed uint64 value.
+//
+// 1 bit 0
+// 17 bits year*13+month (year 0-9999, month 0-12)
+// 5 bits day (0-31)
+// 5 bits hour (0-23)
+// 6 bits minute (0-59)
+// 6 bits second (0-59)
+// 24 bits microseconds (0-999999)
+//
+// Total: 64 bits = 8 bytes
+//
+// 0YYYYYYY.YYYYYYYY.YYdddddh.hhhhmmmm.mmssssss.ffffffff.ffffffff.ffffffff
+//
+func (t Time) ToPackedUint() (uint64, error) {
+ tm := t
+ if t.IsZero() {
+ return 0, nil
+ }
+ year, month, day := tm.Year(), tm.Month(), tm.Day()
+ hour, minute, sec := tm.Hour(), tm.Minute(), tm.Second()
+ ymd := uint64(((year*13 + month) << 5) | day)
+ hms := uint64(hour<<12 | minute<<6 | sec)
+ micro := uint64(tm.Microsecond())
+ return ((ymd<<17 | hms) << 24) | micro, nil
+}
+
+// FromPackedUint decodes Time from a packed uint64 value.
+func (t *Time) FromPackedUint(packed uint64) error {
+ if packed == 0 {
+ t.SetCoreTime(ZeroCoreTime)
+ return nil
+ }
+ ymdhms := packed >> 24
+ ymd := ymdhms >> 17
+ day := int(ymd & (1<<5 - 1))
+ ym := ymd >> 5
+ month := int(ym % 13)
+ year := int(ym / 13)
+
+ hms := ymdhms & (1<<17 - 1)
+ second := int(hms & (1<<6 - 1))
+ minute := int((hms >> 6) & (1<<6 - 1))
+ hour := int(hms >> 12)
+ microsec := int(packed % (1 << 24))
+
+ t.SetCoreTime(FromDate(year, month, day, hour, minute, second, microsec))
+
+ return nil
+}
+
+// check whether t matches valid Time format.
+// If allowZeroInDate is false, it returns ErrZeroDate when month or day is zero.
+// FIXME: See https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_no_zero_in_date
+func (t Time) check(sc *stmtctx.StatementContext) error {
+ allowZeroInDate := false
+ allowInvalidDate := false
+ // We should avoid passing sc as nil here as far as possible.
+ if sc != nil {
+ allowZeroInDate = sc.IgnoreZeroInDate
+ allowInvalidDate = sc.AllowInvalidDate
+ }
+ var err error
+ switch t.Type() {
+ case mysql.TypeTimestamp:
+ err = checkTimestampType(sc, t.coreTime)
+ case mysql.TypeDatetime, mysql.TypeDate:
+ err = checkDatetimeType(t.coreTime, allowZeroInDate, allowInvalidDate)
+ }
+ return errors.Trace(err)
+}
+
+// Check if 't' is valid
+func (t *Time) Check(sc *stmtctx.StatementContext) error {
+ return t.check(sc)
+}
+
+// Sub subtracts t1 from t, returns a duration value.
+// Note that sub should not be done on different time types.
+func (t *Time) Sub(sc *stmtctx.StatementContext, t1 *Time) Duration {
+ var duration gotime.Duration
+ if t.Type() == mysql.TypeTimestamp && t1.Type() == mysql.TypeTimestamp {
+ a, err := t.GoTime(sc.TimeZone)
+ terror.Log(errors.Trace(err))
+ b, err := t1.GoTime(sc.TimeZone)
+ terror.Log(errors.Trace(err))
+ duration = a.Sub(b)
+ } else {
+ seconds, microseconds, neg := calcTimeTimeDiff(t.coreTime, t1.coreTime, 1)
+ duration = gotime.Duration(seconds*1e9 + microseconds*1e3)
+ if neg {
+ duration = -duration
+ }
+ }
+
+ fsp := t.Fsp()
+ fsp1 := t1.Fsp()
+ if fsp < fsp1 {
+ fsp = fsp1
+ }
+ return Duration{
+ Duration: duration,
+ Fsp: fsp,
+ }
+}
+
+// Add adds d to t, returns the result time value.
+func (t *Time) Add(sc *stmtctx.StatementContext, d Duration) (Time, error) {
+ seconds, microseconds, _ := calcTimeDurationDiff(t.coreTime, d)
+ days := seconds / secondsIn24Hour
+ year, month, day := getDateFromDaynr(uint(days))
+ var tm Time
+ tm.setYear(uint16(year))
+ tm.setMonth(uint8(month))
+ tm.setDay(uint8(day))
+ calcTimeFromSec(&tm.coreTime, seconds%secondsIn24Hour, microseconds)
+ if t.Type() == mysql.TypeDate {
+ tm.setHour(0)
+ tm.setMinute(0)
+ tm.setSecond(0)
+ tm.setMicrosecond(0)
+ }
+ fsp := t.Fsp()
+ if d.Fsp > fsp {
+ fsp = d.Fsp
+ }
+ ret := NewTime(tm.coreTime, t.Type(), fsp)
+ return ret, ret.Check(sc)
+}
+
+// TimestampDiff returns t2 - t1 where t1 and t2 are date or datetime expressions.
+// The unit for the result (an integer) is given by the unit argument.
+// The legal values for unit are "YEAR" "QUARTER" "MONTH" "DAY" "HOUR" "SECOND" and so on.
+func TimestampDiff(unit string, t1 Time, t2 Time) int64 {
+ return timestampDiff(unit, t1.coreTime, t2.coreTime)
+}
+
+// ParseDateFormat parses a formatted date string and returns separated components.
+func ParseDateFormat(format string) []string {
+ format = strings.TrimSpace(format)
+
+ if len(format) == 0 {
+ return nil
+ }
+
+ // Date format must start with number.
+ if !isDigit(format[0]) {
+ return nil
+ }
+
+ start := 0
+ // Initialize `seps` with capacity of 6. The input `format` is typically
+ // a date time of the form "2006-01-02 15:04:05", which has 6 numeric parts
+ // (the fractional second part is usually removed by `splitDateTime`).
+ // Setting `seps`'s capacity to 6 avoids reallocation in this common case.
+ seps := make([]string, 0, 6)
+
+ for i := 1; i < len(format)-1; i++ {
+ if isValidSeparator(format[i], len(seps)) {
+ prevParts := len(seps)
+ seps = append(seps, format[start:i])
+ start = i + 1
+
+ // consume further consecutive separators
+ for j := i + 1; j < len(format); j++ {
+ if !isValidSeparator(format[j], prevParts) {
+ break
+ }
+
+ start++
+ i++
+ }
+
+ continue
+ }
+
+ if !isDigit(format[i]) {
+ return nil
+ }
+ }
+
+ seps = append(seps, format[start:])
+ return seps
+}
+
+// helper for date part splitting, punctuation characters are valid separators anywhere,
+// while space and 'T' are valid separators only between date and time.
+func isValidSeparator(c byte, prevParts int) bool {
+ if isPunctuation(c) {
+ return true
+ }
+
+ if prevParts == 2 && (c == ' ' || c == 'T') {
+ return true
+ }
+
+ if prevParts > 4 && !isDigit(c) {
+ return true
+ }
+ return false
+}
+
+var validIdxCombinations = map[int]struct {
+ h int
+ m int
+}{
+ 100: {0, 0}, // 23:59:59Z
+ 30: {2, 0}, // 23:59:59+08
+ 50: {4, 2}, // 23:59:59+0800
+ 63: {5, 2}, // 23:59:59+08:00
+ // postgres supports the following additional syntax that deviates from ISO8601, although we won't support it
+ // currently, it will be fairly easy to add in the current parsing framework
+ // 23:59:59Z+08
+ // 23:59:59Z+08:00
+}
+
+// GetTimezone parses the trailing timezone information of a given time string literal. If idx = -1 is returned, it
+// means timezone information not found, otherwise it indicates the index of the starting index of the timezone
+// information. If the timezone contains sign, hour part and/or minute part, it will be returned as is, otherwise an
+// empty string will be returned.
+//
+// Supported syntax:
+// MySQL compatible: ((?P<tz_sign>[-+])(?P<tz_hour>[0-9]{2}):(?P<tz_minute>[0-9]{2})){0,1}$, see
+// https://dev.mysql.com/doc/refman/8.0/en/time-zone-support.html and https://dev.mysql.com/doc/refman/8.0/en/datetime.html
+// the first link specified that timezone information should be in "[H]H:MM, prefixed with a + or -" while the
+// second link specified that for string literal, "hour values less than than 10, a leading zero is required.".
+// ISO-8601: Z|((((?P<tz_sign>[-+])(?P<tz_hour>[0-9]{2})(:(?P<tz_minute>[0-9]{2}){0,1}){0,1})|((?P<tz_minute>[0-9]{2}){0,1}){0,1}))$
+// see https://www.cl.cam.ac.uk/~mgk25/iso-time.html
+func GetTimezone(lit string) (idx int, tzSign, tzHour, tzSep, tzMinute string) {
+ idx, zidx, sidx, spidx := -1, -1, -1, -1
+ // idx is for the position of the starting of the timezone information
+ // zidx is for the z symbol
+ // sidx is for the sign
+ // spidx is for the separator
+ l := len(lit)
+ // the following loop finds the first index of Z, sign, and separator from backwards.
+ for i := l - 1; 0 <= i; i-- {
+ if lit[i] == 'Z' {
+ zidx = i
+ break
+ }
+ if sidx == -1 && (lit[i] == '-' || lit[i] == '+') {
+ sidx = i
+ }
+ if spidx == -1 && lit[i] == ':' {
+ spidx = i
+ }
+ }
+ // we could enumerate all valid combinations of these values and look it up in a table, see validIdxCombinations
+ // zidx can be -1 (23:59:59+08:00), l-1 (23:59:59Z)
+ // sidx can be -1, l-3, l-5, l-6
+ // spidx can be -1, l-3
+ k := 0
+ if l-zidx == 1 {
+ k += 100
+ }
+ if t := l - sidx; t == 3 || t == 5 || t == 6 {
+ k += t * 10
+ }
+ if l-spidx == 3 {
+ k += 3
+ }
+ if v, ok := validIdxCombinations[k]; ok {
+ hidx, midx := l-v.h, l-v.m
+ valid := func(v string) bool {
+ return '0' <= v[0] && v[0] <= '9' && '0' <= v[1] && v[1] <= '9'
+ }
+ if sidx != -1 {
+ tzSign = lit[sidx : sidx+1]
+ idx = sidx
+ }
+ if zidx != -1 {
+ idx = zidx
+ }
+ if (l - spidx) == 3 {
+ tzSep = lit[spidx : spidx+1]
+ }
+ if v.h != 0 {
+ tzHour = lit[hidx : hidx+2]
+ if !valid(tzHour) {
+ return -1, "", "", "", ""
+ }
+ }
+ if v.m != 0 {
+ tzMinute = lit[midx : midx+2]
+ if !valid(tzMinute) {
+ return -1, "", "", "", ""
+ }
+ }
+ return
+ }
+ return -1, "", "", "", ""
+}
+
+// See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-literals.html.
+// splitDateTime splits the string literal into 3 parts, date & time, FSP and time zone.
+// For FSP, The only delimiter recognized between a date & time part and a fractional seconds part is the decimal point,
+// therefore we could look from backwards at the literal to find the index of the decimal point.
+// For time zone, the possible delimiter could be +/- (w.r.t. MySQL 8.0, see
+// https://dev.mysql.com/doc/refman/8.0/en/datetime.html) and Z/z (w.r.t. ISO 8601, see section Time zone in
+// https://www.cl.cam.ac.uk/~mgk25/iso-time.html). We also look from backwards for the delimiter, see GetTimezone.
+func splitDateTime(format string) (seps []string, fracStr string, hasTZ bool, tzSign, tzHour, tzSep, tzMinute string) {
+ tzIndex, tzSign, tzHour, tzSep, tzMinute := GetTimezone(format)
+ if tzIndex > 0 {
+ hasTZ = true
+ for ; tzIndex > 0 && isPunctuation(format[tzIndex-1]); tzIndex-- {
+ // in case of multiple separators, e.g. 2020-10--10
+ }
+ format = format[:tzIndex]
+ }
+ fracIndex := GetFracIndex(format)
+ if fracIndex > 0 {
+ fracStr = format[fracIndex+1:]
+ for ; fracIndex > 0 && isPunctuation(format[fracIndex-1]); fracIndex-- {
+ // in case of multiple separators, e.g. 2020-10..10
+ }
+ format = format[:fracIndex]
+ }
+ seps = ParseDateFormat(format)
+ return
+}
+
+// See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-literals.html.
+func parseDatetime(sc *stmtctx.StatementContext, str string, fsp int8, isFloat bool) (Time, error) {
+ var (
+ year, month, day, hour, minute, second, deltaHour, deltaMinute int
+ fracStr string
+ tzSign, tzHour, tzSep, tzMinute string
+ hasTZ, hhmmss bool
+ err error
+ )
+
+ seps, fracStr, hasTZ, tzSign, tzHour, tzSep, tzMinute := splitDateTime(str)
+
+ var truncatedOrIncorrect bool
+ /*
+ if we have timezone parsed, there are the following cases to be considered, however some of them are wrongly parsed, and we should consider absorb them back to seps.
+
+ 1. Z, then it must be time zone information, and we should not tamper with it
+ 2. -HH, it might be from
+ 1. no fracStr
+ 1. YYYY-MM-DD
+ 2. YYYY-MM-DD-HH
+ 3. YYYY-MM-DD HH-MM
+ 4. YYYY-MM-DD HH:MM-SS
+ 5. YYYY-MM-DD HH:MM:SS-HH (correct, no need absorb)
+ 2. with fracStr
+ 1. YYYY.MM-DD
+ 2. YYYY-MM.DD-HH
+ 3. YYYY-MM-DD.HH-MM
+ 4. YYYY-MM-DD HH.MM-SS
+ 5. YYYY-MM-DD HH:MM.SS-HH (correct, no need absorb)
+ 3. -HH:MM, similarly it might be from
+ 1. no fracStr
+ 1. YYYY-MM:DD
+ 2. YYYY-MM-DD:HH
+ 3. YYYY-MM-DD-HH:MM
+ 4. YYYY-MM-DD HH-MM:SS
+ 5. YYYY-MM-DD HH:MM-SS:HH (invalid)
+ 6. YYYY-MM-DD HH:MM:SS-HH:MM (correct, no need absorb)
+ 2. with fracStr
+ 1. YYYY.MM-DD:HH
+ 2. YYYY-MM.DD-HH:MM
+ 3. YYYY-MM-DD.HH-MM:SS
+ 4. YYYY-MM-DD HH.MM-SS:HH (invalid)
+ 5. YYYY-MM-DD HH:MM.SS-HH:MM (correct, no need absorb)
+ 4. -HHMM, there should only be one case, that is both the date and time part have existed, only then could we have fracStr or time zone
+ 1. YYYY-MM-DD HH:MM:SS.FSP-HHMM (correct, no need absorb)
+
+ to summarize, FSP and timezone is only valid if we have date and time presented, otherwise we should consider absorbing
+ FSP or timezone into seps. additionally, if we want to absorb timezone, we either absorb them all, or not, meaning
+ we won't only absorb tzHour but not tzMinute.
+
+ additional case to consider is that when the time literal is presented in float string (e.g. `YYYYMMDD.HHMMSS`), in
+ this case, FSP should not be absorbed and only `+HH:MM` would be allowed (i.e. Z, +HHMM, +HH that comes from ISO8601
+ should be banned), because it only conforms to MySQL's timezone parsing logic, but it is not valid in ISO8601.
+ However, I think it is generally acceptable to allow a wider spectrum of timezone format in string literal.
+ */
+
+ // noAbsorb tests if can absorb FSP or TZ
+ noAbsorb := func(seps []string) bool {
+ // if we have more than 5 parts (i.e. 6), the tailing part can't be absorbed
+ // or if we only have 1 part, but its length is longer than 4, then it is at least YYMMD, in this case, FSP can
+ // not be absorbed, and it will be handled later, and the leading sign prevents TZ from being absorbed, because
+ // if date part has no separators, we can't use -/+ as separators between date & time.
+ return len(seps) > 5 || (len(seps) == 1 && len(seps[0]) > 4)
+ }
+ if len(fracStr) != 0 && !isFloat {
+ if !noAbsorb(seps) {
+ seps = append(seps, fracStr)
+ fracStr = ""
+ }
+ }
+ if hasTZ && tzSign != "" {
+ // if tzSign is empty, we can be sure that the string literal contains timezone (such as 2010-10-10T10:10:10Z),
+ // therefore we could safely skip this branch.
+ if !noAbsorb(seps) && !(tzMinute != "" && tzSep == "") {
+ // we can't absorb timezone if there is no separate between tzHour and tzMinute
+ if len(tzHour) != 0 {
+ seps = append(seps, tzHour)
+ }
+ if len(tzMinute) != 0 {
+ seps = append(seps, tzMinute)
+ }
+ hasTZ = false
+ }
+ }
+ switch len(seps) {
+ case 0:
+ return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStackByArgs(DateTimeStr, str))
+ case 1:
+ l := len(seps[0])
+ // Values specified as numbers
+ if isFloat {
+ numOfTime, err := StrToInt(sc, seps[0], false)
+ if err != nil {
+ return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStackByArgs(DateTimeStr, str))
+ }
+
+ dateTime, err := ParseDatetimeFromNum(sc, numOfTime)
+ if err != nil {
+ return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStackByArgs(DateTimeStr, str))
+ }
+
+ year, month, day, hour, minute, second =
+ dateTime.Year(), dateTime.Month(), dateTime.Day(), dateTime.Hour(), dateTime.Minute(), dateTime.Second()
+ if l >= 9 && l <= 14 {
+ hhmmss = true
+ }
+
+ break
+ }
+
+ // Values specified as strings
+ switch l {
+ case 14: // No delimiter.
+ // YYYYMMDDHHMMSS
+ _, err = fmt.Sscanf(seps[0], "%4d%2d%2d%2d%2d%2d", &year, &month, &day, &hour, &minute, &second)
+ hhmmss = true
+ case 12: // YYMMDDHHMMSS
+ _, err = fmt.Sscanf(seps[0], "%2d%2d%2d%2d%2d%2d", &year, &month, &day, &hour, &minute, &second)
+ year = adjustYear(year)
+ hhmmss = true
+ case 11: // YYMMDDHHMMS
+ _, err = fmt.Sscanf(seps[0], "%2d%2d%2d%2d%2d%1d", &year, &month, &day, &hour, &minute, &second)
+ year = adjustYear(year)
+ hhmmss = true
+ case 10: // YYMMDDHHMM
+ _, err = fmt.Sscanf(seps[0], "%2d%2d%2d%2d%2d", &year, &month, &day, &hour, &minute)
+ year = adjustYear(year)
+ case 9: // YYMMDDHHM
+ _, err = fmt.Sscanf(seps[0], "%2d%2d%2d%2d%1d", &year, &month, &day, &hour, &minute)
+ year = adjustYear(year)
+ case 8: // YYYYMMDD
+ _, err = fmt.Sscanf(seps[0], "%4d%2d%2d", &year, &month, &day)
+ case 7: // YYMMDDH
+ _, err = fmt.Sscanf(seps[0], "%2d%2d%2d%1d", &year, &month, &day, &hour)
+ year = adjustYear(year)
+ case 6, 5:
+ // YYMMDD && YYMMD
+ _, err = fmt.Sscanf(seps[0], "%2d%2d%2d", &year, &month, &day)
+ year = adjustYear(year)
+ default:
+ return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, str))
+ }
+ if l == 5 || l == 6 || l == 8 {
+ // YYMMDD or YYYYMMDD
+ // We must handle float => string => datetime, the difference is that fractional
+ // part of float type is discarded directly, while fractional part of string type
+ // is parsed to HH:MM:SS.
+ if isFloat {
+ // 20170118.123423 => 2017-01-18 00:00:00
+ } else {
+ // '20170118.123423' => 2017-01-18 12:34:23.234
+ switch len(fracStr) {
+ case 0:
+ case 1, 2:
+ _, err = fmt.Sscanf(fracStr, "%2d ", &hour)
+ case 3, 4:
+ _, err = fmt.Sscanf(fracStr, "%2d%2d ", &hour, &minute)
+ default:
+ _, err = fmt.Sscanf(fracStr, "%2d%2d%2d ", &hour, &minute, &second)
+ }
+ truncatedOrIncorrect = err != nil
+ }
+ }
+ if l == 9 || l == 10 {
+ if len(fracStr) == 0 {
+ second = 0
+ } else {
+ _, err = fmt.Sscanf(fracStr, "%2d ", &second)
+ }
+ truncatedOrIncorrect = err != nil
+ }
+ if truncatedOrIncorrect && sc != nil {
+ sc.AppendWarning(ErrTruncatedWrongVal.GenWithStackByArgs("datetime", str))
+ err = nil
+ }
+ case 2:
+ return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStackByArgs(DateTimeStr, str))
+ case 3:
+ // YYYY-MM-DD
+ err = scanTimeArgs(seps, &year, &month, &day)
+ case 4:
+ // YYYY-MM-DD HH
+ err = scanTimeArgs(seps, &year, &month, &day, &hour)
+ case 5:
+ // YYYY-MM-DD HH-MM
+ err = scanTimeArgs(seps, &year, &month, &day, &hour, &minute)
+ case 6:
+ // We don't have fractional seconds part.
+ // YYYY-MM-DD HH-MM-SS
+ err = scanTimeArgs(seps, &year, &month, &day, &hour, &minute, &second)
+ hhmmss = true
+ default:
+ // For case like `2020-05-28 23:59:59 00:00:00`, the seps should be > 6, the reluctant parts should be truncated.
+ seps = seps[:6]
+ // YYYY-MM-DD HH-MM-SS
+ if sc != nil {
+ sc.AppendWarning(ErrTruncatedWrongVal.GenWithStackByArgs("datetime", str))
+ }
+ err = scanTimeArgs(seps, &year, &month, &day, &hour, &minute, &second)
+ hhmmss = true
+ }
+ if err != nil {
+ return ZeroDatetime, errors.Trace(err)
+ }
+
+ // If str is sepereated by delimiters, the first one is year, and if the year is 2 digit,
+ // we should adjust it.
+ // TODO: adjust year is very complex, now we only consider the simplest way.
+ if len(seps[0]) == 2 {
+ if year == 0 && month == 0 && day == 0 && hour == 0 && minute == 0 && second == 0 && fracStr == "" {
+ // Skip a special case "00-00-00".
+ } else {
+ year = adjustYear(year)
+ }
+ }
+
+ var microsecond int
+ var overflow bool
+ if hhmmss {
+ // If input string is "20170118.999", without hhmmss, fsp is meaningless.
+ // TODO: this case is not only meaningless, but erroneous, please confirm.
+ microsecond, overflow, err = ParseFrac(fracStr, fsp)
+ if err != nil {
+ return ZeroDatetime, errors.Trace(err)
+ }
+ }
+
+ tmp, ok := FromDateChecked(year, month, day, hour, minute, second, microsecond)
+ if !ok {
+ return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStackByArgs(DateTimeStr, str))
+ }
+ if overflow {
+ // Convert to Go time and add 1 second, to handle input like 2017-01-05 08:40:59.575601
+ t1, err := tmp.GoTime(sc.TimeZone)
+ if err != nil {
+ return ZeroDatetime, errors.Trace(err)
+ }
+ tmp = FromGoTime(t1.Add(gotime.Second))
+ }
+ if hasTZ {
+ // without hhmmss, timezone is also meaningless
+ if !hhmmss {
+ return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStack(DateTimeStr, str))
+ }
+ if len(tzHour) != 0 {
+ deltaHour = int((tzHour[0]-'0')*10 + (tzHour[1] - '0'))
+ }
+ if len(tzMinute) != 0 {
+ deltaMinute = int((tzMinute[0]-'0')*10 + (tzMinute[1] - '0'))
+ }
+ // allowed delta range is [-14:00, 14:00], and we will intentionally reject -00:00
+ if deltaHour > 14 || deltaMinute > 59 || (deltaHour == 14 && deltaMinute != 0) || (tzSign == "-" && deltaHour == 0 && deltaMinute == 0) {
+ return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStackByArgs(DateTimeStr, str))
+ }
+ // by default, if the temporal string literal does not contain timezone information, it will be in the timezone
+ // specified by the time_zone system variable. However, if the timezone is specified in the string literal, we
+ // will use the specified timezone to interpret the string literal and convert it into the system timezone.
+ offset := deltaHour*60*60 + deltaMinute*60
+ if tzSign == "-" {
+ offset = -offset
+ }
+ loc := gotime.FixedZone(fmt.Sprintf("UTC%s%s:%s", tzSign, tzHour, tzMinute), offset)
+ t1, err := tmp.GoTime(loc)
+ if err != nil {
+ return ZeroDatetime, errors.Trace(err)
+ }
+ t1 = t1.In(sc.TimeZone)
+ tmp = FromGoTime(t1)
+ }
+
+ nt := NewTime(tmp, mysql.TypeDatetime, fsp)
+
+ return nt, nil
+}
+
+func scanTimeArgs(seps []string, args ...*int) error {
+ if len(seps) != len(args) {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, seps))
+ }
+
+ var err error
+ for i, s := range seps {
+ *args[i], err = strconv.Atoi(s)
+ if err != nil {
+ return errors.Trace(err)
+ }
+ }
+ return nil
+}
+
+// ParseYear parses a formatted string and returns a year number.
+func ParseYear(str string) (int16, error) {
+ v, err := strconv.ParseInt(str, 10, 16)
+ if err != nil {
+ return 0, errors.Trace(err)
+ }
+ y := int16(v)
+
+ if len(str) == 4 {
+ // Nothing to do.
+ } else if len(str) == 2 || len(str) == 1 {
+ y = int16(adjustYear(int(y)))
+ } else {
+ return 0, errors.Trace(ErrInvalidYearFormat)
+ }
+
+ if y < MinYear || y > MaxYear {
+ return 0, errors.Trace(ErrInvalidYearFormat)
+ }
+
+ return y, nil
+}
+
+// adjustYear adjusts year according to y.
+// See https://dev.mysql.com/doc/refman/5.7/en/two-digit-years.html
+func adjustYear(y int) int {
+ if y >= 0 && y <= 69 {
+ y = 2000 + y
+ } else if y >= 70 && y <= 99 {
+ y = 1900 + y
+ }
+ return y
+}
+
+// AdjustYear is used for adjusting year and checking its validation.
+func AdjustYear(y int64, adjustZero bool) (int64, error) {
+ if y == 0 && !adjustZero {
+ return y, nil
+ }
+ y = int64(adjustYear(int(y)))
+ if y < 0 {
+ return 0, errors.Trace(ErrInvalidYear)
+ }
+ if y < int64(MinYear) {
+ return int64(MinYear), errors.Trace(ErrInvalidYear)
+ }
+ if y > int64(MaxYear) {
+ return int64(MaxYear), errors.Trace(ErrInvalidYear)
+ }
+
+ return y, nil
+}
+
+func adjustYearForFloat(y float64, shouldAdjust bool) float64 {
+ if y == 0 && !shouldAdjust {
+ return y
+ }
+ if y >= 0 && y <= 69 {
+ y = 2000 + y
+ } else if y >= 70 && y <= 99 {
+ y = 1900 + y
+ }
+ return y
+}
+
+// NewDuration construct duration with time.
+func NewDuration(hour, minute, second, microsecond int, fsp int8) Duration {
+ return Duration{
+ Duration: gotime.Duration(hour)*gotime.Hour + gotime.Duration(minute)*gotime.Minute + gotime.Duration(second)*gotime.Second + gotime.Duration(microsecond)*gotime.Microsecond,
+ Fsp: fsp,
+ }
+}
+
+// Duration is the type for MySQL TIME type.
+type Duration struct {
+ gotime.Duration
+ // Fsp is short for Fractional Seconds Precision.
+ // See http://dev.mysql.com/doc/refman/5.7/en/fractional-seconds.html
+ Fsp int8
+}
+
+// MaxMySQLDuration returns Duration with maximum mysql time.
+func MaxMySQLDuration(fsp int8) Duration {
+ return NewDuration(TimeMaxHour, TimeMaxMinute, TimeMaxSecond, 0, fsp)
+}
+
+// Neg negative d, returns a duration value.
+func (d Duration) Neg() Duration {
+ return Duration{
+ Duration: -d.Duration,
+ Fsp: d.Fsp,
+ }
+}
+
+// Add adds d to d, returns a duration value.
+func (d Duration) Add(v Duration) (Duration, error) {
+ if v == (Duration{}) {
+ return d, nil
+ }
+ dsum, err := AddInt64(int64(d.Duration), int64(v.Duration))
+ if err != nil {
+ return Duration{}, errors.Trace(err)
+ }
+ if d.Fsp >= v.Fsp {
+ return Duration{Duration: gotime.Duration(dsum), Fsp: d.Fsp}, nil
+ }
+ return Duration{Duration: gotime.Duration(dsum), Fsp: v.Fsp}, nil
+}
+
+// Sub subtracts d to d, returns a duration value.
+func (d Duration) Sub(v Duration) (Duration, error) {
+ if v == (Duration{}) {
+ return d, nil
+ }
+ dsum, err := SubInt64(int64(d.Duration), int64(v.Duration))
+ if err != nil {
+ return Duration{}, errors.Trace(err)
+ }
+ if d.Fsp >= v.Fsp {
+ return Duration{Duration: gotime.Duration(dsum), Fsp: d.Fsp}, nil
+ }
+ return Duration{Duration: gotime.Duration(dsum), Fsp: v.Fsp}, nil
+}
+
+// DurationFormat returns a textual representation of the duration value formatted
+// according to layout.
+// See http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_date-format
+func (d Duration) DurationFormat(layout string) (string, error) {
+ var buf bytes.Buffer
+ inPatternMatch := false
+ for _, b := range layout {
+ if inPatternMatch {
+ if err := d.convertDateFormat(b, &buf); err != nil {
+ return "", errors.Trace(err)
+ }
+ inPatternMatch = false
+ continue
+ }
+
+ // It's not in pattern match now.
+ if b == '%' {
+ inPatternMatch = true
+ } else {
+ buf.WriteRune(b)
+ }
+ }
+ return buf.String(), nil
+}
+
+func (d Duration) convertDateFormat(b rune, buf *bytes.Buffer) error {
+ switch b {
+ case 'H':
+ buf.WriteString(FormatIntWidthN(d.Hour(), 2))
+ case 'k':
+ buf.WriteString(strconv.FormatInt(int64(d.Hour()), 10))
+ case 'h', 'I':
+ t := d.Hour()
+ if t%12 == 0 {
+ buf.WriteString("12")
+ } else {
+ buf.WriteString(FormatIntWidthN(t%12, 2))
+ }
+ case 'l':
+ t := d.Hour()
+ if t%12 == 0 {
+ buf.WriteString("12")
+ } else {
+ buf.WriteString(strconv.FormatInt(int64(t%12), 10))
+ }
+ case 'i':
+ buf.WriteString(FormatIntWidthN(d.Minute(), 2))
+ case 'p':
+ hour := d.Hour()
+ if hour/12%2 == 0 {
+ buf.WriteString("AM")
+ } else {
+ buf.WriteString("PM")
+ }
+ case 'r':
+ h := d.Hour()
+ h %= 24
+ switch {
+ case h == 0:
+ fmt.Fprintf(buf, "%02d:%02d:%02d AM", 12, d.Minute(), d.Second())
+ case h == 12:
+ fmt.Fprintf(buf, "%02d:%02d:%02d PM", 12, d.Minute(), d.Second())
+ case h < 12:
+ fmt.Fprintf(buf, "%02d:%02d:%02d AM", h, d.Minute(), d.Second())
+ default:
+ fmt.Fprintf(buf, "%02d:%02d:%02d PM", h-12, d.Minute(), d.Second())
+ }
+ case 'T':
+ fmt.Fprintf(buf, "%02d:%02d:%02d", d.Hour(), d.Minute(), d.Second())
+ case 'S', 's':
+ buf.WriteString(FormatIntWidthN(d.Second(), 2))
+ case 'f':
+ fmt.Fprintf(buf, "%06d", d.MicroSecond())
+ default:
+ buf.WriteRune(b)
+ }
+
+ return nil
+}
+
+// String returns the time formatted using default TimeFormat and fsp.
+func (d Duration) String() string {
+ var buf bytes.Buffer
+
+ sign, hours, minutes, seconds, fraction := splitDuration(d.Duration)
+ if sign < 0 {
+ buf.WriteByte('-')
+ }
+
+ fmt.Fprintf(&buf, "%02d:%02d:%02d", hours, minutes, seconds)
+ if d.Fsp > 0 {
+ buf.WriteString(".")
+ buf.WriteString(d.formatFrac(fraction))
+ }
+
+ p := buf.String()
+
+ return p
+}
+
+func (d Duration) formatFrac(frac int) string {
+ s := fmt.Sprintf("%06d", frac)
+ return s[0:d.Fsp]
+}
+
+// ToNumber changes duration to number format.
+// e.g,
+// 10:10:10 -> 101010
+func (d Duration) ToNumber() *MyDecimal {
+ sign, hours, minutes, seconds, fraction := splitDuration(d.Duration)
+ var (
+ s string
+ signStr string
+ )
+
+ if sign < 0 {
+ signStr = "-"
+ }
+
+ if d.Fsp == 0 {
+ s = fmt.Sprintf("%s%02d%02d%02d", signStr, hours, minutes, seconds)
+ } else {
+ s = fmt.Sprintf("%s%02d%02d%02d.%s", signStr, hours, minutes, seconds, d.formatFrac(fraction))
+ }
+
+ // We skip checking error here because time formatted string can be parsed certainly.
+ dec := new(MyDecimal)
+ err := dec.FromString([]byte(s))
+ terror.Log(errors.Trace(err))
+ return dec
+}
+
+// ConvertToTime converts duration to Time.
+// Tp is TypeDatetime, TypeTimestamp and TypeDate.
+func (d Duration) ConvertToTime(sc *stmtctx.StatementContext, tp uint8) (Time, error) {
+ year, month, day := gotime.Now().In(sc.TimeZone).Date()
+ datePart := FromDate(year, int(month), day, 0, 0, 0, 0)
+ mixDateAndDuration(&datePart, d)
+
+ t := NewTime(datePart, mysql.TypeDatetime, d.Fsp)
+ return t.Convert(sc, tp)
+}
+
+// RoundFrac rounds fractional seconds precision with new fsp and returns a new one.
+// We will use the “round half up” rule, e.g, >= 0.5 -> 1, < 0.5 -> 0,
+// so 10:10:10.999999 round 0 -> 10:10:11
+// and 10:10:10.000000 round 0 -> 10:10:10
+func (d Duration) RoundFrac(fsp int8) (Duration, error) {
+ fsp, err := CheckFsp(int(fsp))
+ if err != nil {
+ return d, errors.Trace(err)
+ }
+
+ if fsp == d.Fsp {
+ return d, nil
+ }
+
+ n := gotime.Date(0, 0, 0, 0, 0, 0, 0, gotime.Local)
+ nd := n.Add(d.Duration).Round(gotime.Duration(math.Pow10(9-int(fsp))) * gotime.Nanosecond).Sub(n)
+ return Duration{Duration: nd, Fsp: fsp}, nil
+}
+
+// Compare returns an integer comparing the Duration instant t to o.
+// If d is after o, returns 1, equal o, returns 0, before o, returns -1.
+func (d Duration) Compare(o Duration) int {
+ if d.Duration > o.Duration {
+ return 1
+ } else if d.Duration == o.Duration {
+ return 0
+ } else {
+ return -1
+ }
+}
+
+// CompareString is like Compare,
+// but parses str to Duration then compares.
+func (d Duration) CompareString(sc *stmtctx.StatementContext, str string) (int, error) {
+ // use MaxFsp to parse the string
+ o, err := ParseDuration(sc, str, MaxFsp)
+ if err != nil {
+ return 0, err
+ }
+
+ return d.Compare(o), nil
+}
+
+// Hour returns current hour.
+// e.g, hour("11:11:11") -> 11
+func (d Duration) Hour() int {
+ _, hour, _, _, _ := splitDuration(d.Duration)
+ return hour
+}
+
+// Minute returns current minute.
+// e.g, hour("11:11:11") -> 11
+func (d Duration) Minute() int {
+ _, _, minute, _, _ := splitDuration(d.Duration)
+ return minute
+}
+
+// Second returns current second.
+// e.g, hour("11:11:11") -> 11
+func (d Duration) Second() int {
+ _, _, _, second, _ := splitDuration(d.Duration)
+ return second
+}
+
+// MicroSecond returns current microsecond.
+// e.g, hour("11:11:11.11") -> 110000
+func (d Duration) MicroSecond() int {
+ _, _, _, _, frac := splitDuration(d.Duration)
+ return frac
+}
+
+func isNegativeDuration(str string) (bool, string) {
+ rest, err := parser.Char(str, '-')
+
+ if err != nil {
+ return false, str
+ }
+
+ return true, rest
+}
+
+func matchColon(str string) (string, error) {
+ rest := parser.Space0(str)
+ rest, err := parser.Char(rest, ':')
+ if err != nil {
+ return str, err
+ }
+ rest = parser.Space0(rest)
+ return rest, nil
+}
+
+func matchDayHHMMSS(str string) (int, [3]int, string, error) {
+ day, rest, err := parser.Number(str)
+ if err != nil {
+ return 0, [3]int{}, str, err
+ }
+
+ rest, err = parser.Space(rest, 1)
+ if err != nil {
+ return 0, [3]int{}, str, err
+ }
+
+ hhmmss, rest, err := matchHHMMSSDelimited(rest, false)
+ if err != nil {
+ return 0, [3]int{}, str, err
+ }
+
+ return day, hhmmss, rest, nil
+}
+
+func matchHHMMSSDelimited(str string, requireColon bool) ([3]int, string, error) {
+ hhmmss := [3]int{}
+
+ hour, rest, err := parser.Number(str)
+ if err != nil {
+ return [3]int{}, str, err
+ }
+ hhmmss[0] = hour
+
+ for i := 1; i < 3; i++ {
+ if remain, err := matchColon(rest); err == nil {
+ num, remain, err := parser.Number(remain)
+ if err != nil {
+ return [3]int{}, str, err
+ }
+ hhmmss[i] = num
+ rest = remain
+ } else {
+ if i == 1 && requireColon {
+ return [3]int{}, str, err
+ }
+ break
+ }
+ }
+
+ return hhmmss, rest, nil
+}
+
+func matchHHMMSSCompact(str string) ([3]int, string, error) {
+ num, rest, err := parser.Number(str)
+ if err != nil {
+ return [3]int{}, str, err
+ }
+ hhmmss := [3]int{num / 10000, (num / 100) % 100, num % 100}
+ return hhmmss, rest, nil
+}
+
+func hhmmssAddOverflow(hms []int, overflow bool) {
+ mod := []int{-1, 60, 60}
+ for i := 2; i >= 0 && overflow; i-- {
+ hms[i]++
+ if hms[i] == mod[i] {
+ overflow = true
+ hms[i] = 0
+ } else {
+ overflow = false
+ }
+ }
+}
+
+func checkHHMMSS(hms [3]int) bool {
+ m, s := hms[1], hms[2]
+ return m < 60 && s < 60
+}
+
+// matchFrac returns overflow, fraction, rest, error
+func matchFrac(str string, fsp int8) (bool, int, string, error) {
+ rest, err := parser.Char(str, '.')
+ if err != nil {
+ return false, 0, str, nil
+ }
+
+ digits, rest, err := parser.Digit(rest, 0)
+ if err != nil {
+ return false, 0, str, err
+ }
+
+ frac, overflow, err := ParseFrac(digits, fsp)
+ if err != nil {
+ return false, 0, str, err
+ }
+
+ return overflow, frac, rest, nil
+}
+
+func matchDuration(str string, fsp int8) (Duration, error) {
+ fsp, err := CheckFsp(int(fsp))
+ if err != nil {
+ return ZeroDuration, errors.Trace(err)
+ }
+
+ if len(str) == 0 {
+ return ZeroDuration, ErrTruncatedWrongVal.GenWithStackByArgs("time", str)
+ }
+
+ negative, rest := isNegativeDuration(str)
+ rest = parser.Space0(rest)
+
+ hhmmss := [3]int{}
+
+ if day, hms, remain, err := matchDayHHMMSS(rest); err == nil {
+ hms[0] += 24 * day
+ rest, hhmmss = remain, hms
+ } else if hms, remain, err := matchHHMMSSDelimited(rest, true); err == nil {
+ rest, hhmmss = remain, hms
+ } else if hms, remain, err := matchHHMMSSCompact(rest); err == nil {
+ rest, hhmmss = remain, hms
+ } else {
+ return ZeroDuration, ErrTruncatedWrongVal.GenWithStackByArgs("time", str)
+ }
+
+ rest = parser.Space0(rest)
+ overflow, frac, rest, err := matchFrac(rest, fsp)
+ if err != nil || len(rest) > 0 {
+ return ZeroDuration, ErrTruncatedWrongVal.GenWithStackByArgs("time", str)
+ }
+
+ if overflow {
+ hhmmssAddOverflow(hhmmss[:], overflow)
+ frac = 0
+ }
+
+ if !checkHHMMSS(hhmmss) {
+ return ZeroDuration, ErrTruncatedWrongVal.GenWithStackByArgs("time", str)
+ }
+
+ if hhmmss[0] > TimeMaxHour {
+ var t gotime.Duration
+ if negative {
+ t = MinTime
+ } else {
+ t = MaxTime
+ }
+ return Duration{t, fsp}, ErrTruncatedWrongVal.GenWithStackByArgs("time", str)
+ }
+
+ d := gotime.Duration(hhmmss[0]*3600+hhmmss[1]*60+hhmmss[2])*gotime.Second + gotime.Duration(frac)*gotime.Microsecond
+ if negative {
+ d = -d
+ }
+ d, err = TruncateOverflowMySQLTime(d)
+ return Duration{d, fsp}, errors.Trace(err)
+}
+
+// canFallbackToDateTime return true
+// 1. the string is failed to be parsed by `matchDuration`
+// 2. the string is start with a series of digits whose length match the full format of DateTime literal (12, 14)
+// or the string start with a date literal.
+func canFallbackToDateTime(str string) bool {
+ digits, rest, err := parser.Digit(str, 1)
+ if err != nil {
+ return false
+ }
+ if len(digits) == 12 || len(digits) == 14 {
+ return true
+ }
+
+ rest, err = parser.AnyPunct(rest)
+ if err != nil {
+ return false
+ }
+
+ _, rest, err = parser.Digit(rest, 1)
+ if err != nil {
+ return false
+ }
+
+ rest, err = parser.AnyPunct(rest)
+ if err != nil {
+ return false
+ }
+
+ _, rest, err = parser.Digit(rest, 1)
+ if err != nil {
+ return false
+ }
+
+ return len(rest) > 0 && (rest[0] == ' ' || rest[0] == 'T')
+}
+
+// ParseDuration parses the time form a formatted string with a fractional seconds part,
+// returns the duration type Time value.
+// See http://dev.mysql.com/doc/refman/5.7/en/fractional-seconds.html
+func ParseDuration(sc *stmtctx.StatementContext, str string, fsp int8) (Duration, error) {
+ rest := strings.TrimSpace(str)
+ d, err := matchDuration(rest, fsp)
+ if err == nil {
+ return d, nil
+ }
+ if !canFallbackToDateTime(rest) {
+ return d, ErrTruncatedWrongVal.GenWithStackByArgs("time", str)
+ }
+
+ datetime, err := ParseDatetime(sc, rest)
+ if err != nil {
+ return ZeroDuration, ErrTruncatedWrongVal.GenWithStackByArgs("time", str)
+ }
+
+ d, err = datetime.ConvertToDuration()
+ if err != nil {
+ return ZeroDuration, ErrTruncatedWrongVal.GenWithStackByArgs("time", str)
+ }
+
+ return d.RoundFrac(fsp)
+}
+
+// TruncateOverflowMySQLTime truncates d when it overflows, and returns ErrTruncatedWrongVal.
+func TruncateOverflowMySQLTime(d gotime.Duration) (gotime.Duration, error) {
+ if d > MaxTime {
+ return MaxTime, ErrTruncatedWrongVal.GenWithStackByArgs("time", d)
+ } else if d < MinTime {
+ return MinTime, ErrTruncatedWrongVal.GenWithStackByArgs("time", d)
+ }
+
+ return d, nil
+}
+
+func splitDuration(t gotime.Duration) (int, int, int, int, int) {
+ sign := 1
+ if t < 0 {
+ t = -t
+ sign = -1
+ }
+
+ hours := t / gotime.Hour
+ t -= hours * gotime.Hour
+ minutes := t / gotime.Minute
+ t -= minutes * gotime.Minute
+ seconds := t / gotime.Second
+ t -= seconds * gotime.Second
+ fraction := t / gotime.Microsecond
+
+ return sign, int(hours), int(minutes), int(seconds), int(fraction)
+}
+
+var maxDaysInMonth = []int{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
+
+func getTime(sc *stmtctx.StatementContext, num int64, tp byte) (Time, error) {
+ s1 := num / 1000000
+ s2 := num - s1*1000000
+
+ year := int(s1 / 10000)
+ s1 %= 10000
+ month := int(s1 / 100)
+ day := int(s1 % 100)
+
+ hour := int(s2 / 10000)
+ s2 %= 10000
+ minute := int(s2 / 100)
+ second := int(s2 % 100)
+
+ ct, ok := FromDateChecked(year, month, day, hour, minute, second, 0)
+ if !ok {
+ return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, ""))
+ }
+ t := NewTime(ct, tp, DefaultFsp)
+ err := t.check(sc)
+ return t, errors.Trace(err)
+}
+
+// parseDateTimeFromNum parses date time from num.
+// See number_to_datetime function.
+// https://github.com/mysql/mysql-server/blob/5.7/sql-common/my_time.c
+func parseDateTimeFromNum(sc *stmtctx.StatementContext, num int64) (Time, error) {
+ t := ZeroDate
+ // Check zero.
+ if num == 0 {
+ return t, nil
+ }
+
+ // Check datetime type.
+ if num >= 10000101000000 {
+ t.SetType(mysql.TypeDatetime)
+ return getTime(sc, num, t.Type())
+ }
+
+ // Check MMDD.
+ if num < 101 {
+ return t, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, strconv.FormatInt(num, 10)))
+ }
+
+ // Adjust year
+ // YYMMDD, year: 2000-2069
+ if num <= (70-1)*10000+1231 {
+ num = (num + 20000000) * 1000000
+ return getTime(sc, num, t.Type())
+ }
+
+ // Check YYMMDD.
+ if num < 70*10000+101 {
+ return t, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, strconv.FormatInt(num, 10)))
+ }
+
+ // Adjust year
+ // YYMMDD, year: 1970-1999
+ if num <= 991231 {
+ num = (num + 19000000) * 1000000
+ return getTime(sc, num, t.Type())
+ }
+
+ // Adjust hour/min/second.
+ if num <= 99991231 {
+ num = num * 1000000
+ return getTime(sc, num, t.Type())
+ }
+
+ // Check MMDDHHMMSS.
+ if num < 101000000 {
+ return t, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, strconv.FormatInt(num, 10)))
+ }
+
+ // Set TypeDatetime type.
+ t.SetType(mysql.TypeDatetime)
+
+ // Adjust year
+ // YYMMDDHHMMSS, 2000-2069
+ if num <= 69*10000000000+1231235959 {
+ num = num + 20000000000000
+ return getTime(sc, num, t.Type())
+ }
+
+ // Check YYYYMMDDHHMMSS.
+ if num < 70*10000000000+101000000 {
+ return t, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, strconv.FormatInt(num, 10)))
+ }
+
+ // Adjust year
+ // YYMMDDHHMMSS, 1970-1999
+ if num <= 991231235959 {
+ num = num + 19000000000000
+ return getTime(sc, num, t.Type())
+ }
+
+ return getTime(sc, num, t.Type())
+}
+
+// ParseTime parses a formatted string with type tp and specific fsp.
+// Type is TypeDatetime, TypeTimestamp and TypeDate.
+// Fsp is in range [0, 6].
+// MySQL supports many valid datetime format, but still has some limitation.
+// If delimiter exists, the date part and time part is separated by a space or T,
+// other punctuation character can be used as the delimiter between date parts or time parts.
+// If no delimiter, the format must be YYYYMMDDHHMMSS or YYMMDDHHMMSS
+// If we have fractional seconds part, we must use decimal points as the delimiter.
+// The valid datetime range is from '1000-01-01 00:00:00.000000' to '9999-12-31 23:59:59.999999'.
+// The valid timestamp range is from '1970-01-01 00:00:01.000000' to '2038-01-19 03:14:07.999999'.
+// The valid date range is from '1000-01-01' to '9999-12-31'
+func ParseTime(sc *stmtctx.StatementContext, str string, tp byte, fsp int8) (Time, error) {
+ return parseTime(sc, str, tp, fsp, false)
+}
+
+// ParseTimeFromFloatString is similar to ParseTime, except that it's used to parse a float converted string.
+func ParseTimeFromFloatString(sc *stmtctx.StatementContext, str string, tp byte, fsp int8) (Time, error) {
+ // MySQL compatibility: 0.0 should not be converted to null, see #11203
+ if len(str) >= 3 && str[:3] == "0.0" {
+ return NewTime(ZeroCoreTime, tp, DefaultFsp), nil
+ }
+ return parseTime(sc, str, tp, fsp, true)
+}
+
+func parseTime(sc *stmtctx.StatementContext, str string, tp byte, fsp int8, isFloat bool) (Time, error) {
+ fsp, err := CheckFsp(int(fsp))
+ if err != nil {
+ return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err)
+ }
+
+ t, err := parseDatetime(sc, str, fsp, isFloat)
+ if err != nil {
+ return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err)
+ }
+
+ t.SetType(tp)
+ if err = t.check(sc); err != nil {
+ return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err)
+ }
+ return t, nil
+}
+
+// ParseDatetime is a helper function wrapping ParseTime with datetime type and default fsp.
+func ParseDatetime(sc *stmtctx.StatementContext, str string) (Time, error) {
+ return ParseTime(sc, str, mysql.TypeDatetime, GetFsp(str))
+}
+
+// ParseTimestamp is a helper function wrapping ParseTime with timestamp type and default fsp.
+func ParseTimestamp(sc *stmtctx.StatementContext, str string) (Time, error) {
+ return ParseTime(sc, str, mysql.TypeTimestamp, GetFsp(str))
+}
+
+// ParseDate is a helper function wrapping ParseTime with date type.
+func ParseDate(sc *stmtctx.StatementContext, str string) (Time, error) {
+ // date has no fractional seconds precision
+ return ParseTime(sc, str, mysql.TypeDate, MinFsp)
+}
+
+// ParseTimeFromYear parse a `YYYY` formed year to corresponded Datetime type.
+// Note: the invoker must promise the `year` is in the range [MinYear, MaxYear].
+func ParseTimeFromYear(sc *stmtctx.StatementContext, year int64) (Time, error) {
+ if year == 0 {
+ return NewTime(ZeroCoreTime, mysql.TypeDate, DefaultFsp), nil
+ }
+
+ dt := FromDate(int(year), 0, 0, 0, 0, 0, 0)
+ return NewTime(dt, mysql.TypeDatetime, DefaultFsp), nil
+}
+
+// ParseTimeFromNum parses a formatted int64,
+// returns the value which type is tp.
+func ParseTimeFromNum(sc *stmtctx.StatementContext, num int64, tp byte, fsp int8) (Time, error) {
+ // MySQL compatibility: 0 should not be converted to null, see #11203
+ if num == 0 {
+ return NewTime(ZeroCoreTime, tp, DefaultFsp), nil
+ }
+ fsp, err := CheckFsp(int(fsp))
+ if err != nil {
+ return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err)
+ }
+
+ t, err := parseDateTimeFromNum(sc, num)
+ if err != nil {
+ return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err)
+ }
+
+ t.SetType(tp)
+ t.SetFsp(fsp)
+ if err := t.check(sc); err != nil {
+ return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err)
+ }
+ return t, nil
+}
+
+// ParseDatetimeFromNum is a helper function wrapping ParseTimeFromNum with datetime type and default fsp.
+func ParseDatetimeFromNum(sc *stmtctx.StatementContext, num int64) (Time, error) {
+ return ParseTimeFromNum(sc, num, mysql.TypeDatetime, DefaultFsp)
+}
+
+// ParseTimestampFromNum is a helper function wrapping ParseTimeFromNum with timestamp type and default fsp.
+func ParseTimestampFromNum(sc *stmtctx.StatementContext, num int64) (Time, error) {
+ return ParseTimeFromNum(sc, num, mysql.TypeTimestamp, DefaultFsp)
+}
+
+// ParseDateFromNum is a helper function wrapping ParseTimeFromNum with date type.
+func ParseDateFromNum(sc *stmtctx.StatementContext, num int64) (Time, error) {
+ // date has no fractional seconds precision
+ return ParseTimeFromNum(sc, num, mysql.TypeDate, MinFsp)
+}
+
+// TimeFromDays Converts a day number to a date.
+func TimeFromDays(num int64) Time {
+ if num < 0 {
+ return NewTime(FromDate(0, 0, 0, 0, 0, 0, 0), mysql.TypeDate, 0)
+ }
+ year, month, day := getDateFromDaynr(uint(num))
+ ct, ok := FromDateChecked(int(year), int(month), int(day), 0, 0, 0, 0)
+ if !ok {
+ return NewTime(FromDate(0, 0, 0, 0, 0, 0, 0), mysql.TypeDate, 0)
+ }
+ return NewTime(ct, mysql.TypeDate, 0)
+}
+
+func checkDateType(t CoreTime, allowZeroInDate, allowInvalidDate bool) error {
+ year, month, day := t.Year(), t.Month(), t.Day()
+ if year == 0 && month == 0 && day == 0 {
+ return nil
+ }
+
+ if !allowZeroInDate && (month == 0 || day == 0) {
+ return ErrWrongValue.GenWithStackByArgs(DateTimeStr, fmt.Sprintf("%04d-%02d-%02d", year, month, day))
+ }
+
+ if err := checkDateRange(t); err != nil {
+ return errors.Trace(err)
+ }
+
+ if err := checkMonthDay(year, month, day, allowInvalidDate); err != nil {
+ return errors.Trace(err)
+ }
+
+ return nil
+}
+
+func checkDateRange(t CoreTime) error {
+ // Oddly enough, MySQL document says date range should larger than '1000-01-01',
+ // but we can insert '0001-01-01' actually.
+ if t.Year() < 0 || t.Month() < 0 || t.Day() < 0 {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, t))
+ }
+ if compareTime(t, MaxDatetime) > 0 {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, t))
+ }
+ return nil
+}
+
+func checkMonthDay(year, month, day int, allowInvalidDate bool) error {
+ if month < 0 || month > 12 {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(DateTimeStr, fmt.Sprintf("%d-%d-%d", year, month, day)))
+ }
+
+ maxDay := 31
+ if !allowInvalidDate {
+ if month > 0 {
+ maxDay = maxDaysInMonth[month-1]
+ }
+ if month == 2 && !isLeapYear(uint16(year)) {
+ maxDay = 28
+ }
+ }
+
+ if day < 0 || day > maxDay {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(DateTimeStr, fmt.Sprintf("%d-%d-%d", year, month, day)))
+ }
+ return nil
+}
+
+func checkTimestampType(sc *stmtctx.StatementContext, t CoreTime) error {
+ if compareTime(t, ZeroCoreTime) == 0 {
+ return nil
+ }
+
+ if sc == nil {
+ return errors.New("statementContext is required during checkTimestampType")
+ }
+
+ var checkTime CoreTime
+ if sc.TimeZone != BoundTimezone {
+ convertTime := NewTime(t, mysql.TypeTimestamp, DefaultFsp)
+ err := convertTime.ConvertTimeZone(sc.TimeZone, BoundTimezone)
+ if err != nil {
+ return err
+ }
+ checkTime = convertTime.coreTime
+ } else {
+ checkTime = t
+ }
+ if compareTime(checkTime, MaxTimestamp.coreTime) > 0 || compareTime(checkTime, MinTimestamp.coreTime) < 0 {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, t))
+ }
+
+ if _, err := t.GoTime(sc.TimeZone); err != nil {
+ return errors.Trace(err)
+ }
+
+ return nil
+}
+
+func checkDatetimeType(t CoreTime, allowZeroInDate, allowInvalidDate bool) error {
+ if err := checkDateType(t, allowZeroInDate, allowInvalidDate); err != nil {
+ return errors.Trace(err)
+ }
+
+ hour, minute, second := t.Hour(), t.Minute(), t.Second()
+ if hour < 0 || hour >= 24 {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, strconv.Itoa(hour)))
+ }
+ if minute < 0 || minute >= 60 {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, strconv.Itoa(minute)))
+ }
+ if second < 0 || second >= 60 {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, strconv.Itoa(second)))
+ }
+
+ return nil
+}
+
+// ExtractDatetimeNum extracts time value number from datetime unit and format.
+func ExtractDatetimeNum(t *Time, unit string) (int64, error) {
+ // TODO: Consider time_zone variable.
+ switch strings.ToUpper(unit) {
+ case "DAY":
+ return int64(t.Day()), nil
+ case "WEEK":
+ week := t.Week(0)
+ return int64(week), nil
+ case "MONTH":
+ return int64(t.Month()), nil
+ case "QUARTER":
+ m := int64(t.Month())
+ // 1 - 3 -> 1
+ // 4 - 6 -> 2
+ // 7 - 9 -> 3
+ // 10 - 12 -> 4
+ return (m + 2) / 3, nil
+ case "YEAR":
+ return int64(t.Year()), nil
+ case "DAY_MICROSECOND":
+ h, m, s := t.Clock()
+ d := t.Day()
+ return int64(d*1000000+h*10000+m*100+s)*1000000 + int64(t.Microsecond()), nil
+ case "DAY_SECOND":
+ h, m, s := t.Clock()
+ d := t.Day()
+ return int64(d)*1000000 + int64(h)*10000 + int64(m)*100 + int64(s), nil
+ case "DAY_MINUTE":
+ h, m, _ := t.Clock()
+ d := t.Day()
+ return int64(d)*10000 + int64(h)*100 + int64(m), nil
+ case "DAY_HOUR":
+ h, _, _ := t.Clock()
+ d := t.Day()
+ return int64(d)*100 + int64(h), nil
+ case "YEAR_MONTH":
+ y, m := t.Year(), t.Month()
+ return int64(y)*100 + int64(m), nil
+ default:
+ return 0, errors.Errorf("invalid unit %s", unit)
+ }
+}
+
+// ExtractDurationNum extracts duration value number from duration unit and format.
+func ExtractDurationNum(d *Duration, unit string) (int64, error) {
+ switch strings.ToUpper(unit) {
+ case "MICROSECOND":
+ return int64(d.MicroSecond()), nil
+ case "SECOND":
+ return int64(d.Second()), nil
+ case "MINUTE":
+ return int64(d.Minute()), nil
+ case "HOUR":
+ return int64(d.Hour()), nil
+ case "SECOND_MICROSECOND":
+ return int64(d.Second())*1000000 + int64(d.MicroSecond()), nil
+ case "MINUTE_MICROSECOND":
+ return int64(d.Minute())*100000000 + int64(d.Second())*1000000 + int64(d.MicroSecond()), nil
+ case "MINUTE_SECOND":
+ return int64(d.Minute()*100 + d.Second()), nil
+ case "HOUR_MICROSECOND":
+ return int64(d.Hour())*10000000000 + int64(d.Minute())*100000000 + int64(d.Second())*1000000 + int64(d.MicroSecond()), nil
+ case "HOUR_SECOND":
+ return int64(d.Hour())*10000 + int64(d.Minute())*100 + int64(d.Second()), nil
+ case "HOUR_MINUTE":
+ return int64(d.Hour())*100 + int64(d.Minute()), nil
+ case "DAY_MICROSECOND":
+ return int64(d.Hour()*10000+d.Minute()*100+d.Second())*1000000 + int64(d.MicroSecond()), nil
+ case "DAY_SECOND":
+ return int64(d.Hour())*10000 + int64(d.Minute())*100 + int64(d.Second()), nil
+ case "DAY_MINUTE":
+ return int64(d.Hour())*100 + int64(d.Minute()), nil
+ case "DAY_HOUR":
+ return int64(d.Hour()), nil
+ default:
+ return 0, errors.Errorf("invalid unit %s", unit)
+ }
+}
+
+// parseSingleTimeValue parse the format according the given unit. If we set strictCheck true, we'll check whether
+// the converted value not exceed the range of MySQL's TIME type.
+// The first four returned values are year, month, day and nanosecond.
+func parseSingleTimeValue(unit string, format string, strictCheck bool) (int64, int64, int64, int64, error) {
+ // Format is a preformatted number, it format should be A[.[B]].
+ decimalPointPos := strings.IndexRune(format, '.')
+ if decimalPointPos == -1 {
+ decimalPointPos = len(format)
+ }
+ sign := int64(1)
+ if len(format) > 0 && format[0] == '-' {
+ sign = int64(-1)
+ }
+ iv, err := strconv.ParseInt(format[0:decimalPointPos], 10, 64)
+ if err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, format)
+ }
+ riv := iv // Rounded integer value
+
+ dv := int64(0)
+ lf := len(format) - 1
+ // Has fraction part
+ if decimalPointPos < lf {
+ dvPre := oneToSixDigitRegex.FindString(format[decimalPointPos+1:]) // the numberical prefix of the fraction part
+ dvPreLen := len(dvPre)
+ if dvPreLen >= 6 {
+ // MySQL rounds down to 1e-6.
+ if dv, err = strconv.ParseInt(dvPre[0:6], 10, 64); err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, format)
+ }
+ } else {
+ if dv, err = strconv.ParseInt(dvPre[:]+"000000"[:6-dvPreLen], 10, 64); err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, format)
+ }
+ }
+ if dv >= 500000 { // Round up, and we should keep 6 digits for microsecond, so dv should in [000000, 999999].
+ riv += sign
+ }
+ if unit != "SECOND" {
+ err = ErrTruncatedWrongVal.GenWithStackByArgs(format)
+ }
+ dv *= sign
+ }
+ switch strings.ToUpper(unit) {
+ case "MICROSECOND":
+ if strictCheck && tidbMath.Abs(riv) > TimeMaxValueSeconds*1000 {
+ return 0, 0, 0, 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ dayCount := riv / int64(GoDurationDay/gotime.Microsecond)
+ riv %= int64(GoDurationDay / gotime.Microsecond)
+ return 0, 0, dayCount, riv * int64(gotime.Microsecond), err
+ case "SECOND":
+ if strictCheck && tidbMath.Abs(iv) > TimeMaxValueSeconds {
+ return 0, 0, 0, 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ dayCount := iv / int64(GoDurationDay/gotime.Second)
+ iv %= int64(GoDurationDay / gotime.Second)
+ return 0, 0, dayCount, iv*int64(gotime.Second) + dv*int64(gotime.Microsecond), err
+ case "MINUTE":
+ if strictCheck && tidbMath.Abs(riv) > TimeMaxHour*60+TimeMaxMinute {
+ return 0, 0, 0, 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ dayCount := riv / int64(GoDurationDay/gotime.Minute)
+ riv %= int64(GoDurationDay / gotime.Minute)
+ return 0, 0, dayCount, riv * int64(gotime.Minute), err
+ case "HOUR":
+ if strictCheck && tidbMath.Abs(riv) > TimeMaxHour {
+ return 0, 0, 0, 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ dayCount := riv / 24
+ riv %= 24
+ return 0, 0, dayCount, riv * int64(gotime.Hour), err
+ case "DAY":
+ if strictCheck && tidbMath.Abs(riv) > TimeMaxHour/24 {
+ return 0, 0, 0, 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ return 0, 0, riv, 0, err
+ case "WEEK":
+ if strictCheck && 7*tidbMath.Abs(riv) > TimeMaxHour/24 {
+ return 0, 0, 0, 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ return 0, 0, 7 * riv, 0, err
+ case "MONTH":
+ if strictCheck && tidbMath.Abs(riv) > 1 {
+ return 0, 0, 0, 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ return 0, riv, 0, 0, err
+ case "QUARTER":
+ if strictCheck {
+ return 0, 0, 0, 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ return 0, 3 * riv, 0, 0, err
+ case "YEAR":
+ if strictCheck {
+ return 0, 0, 0, 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ return riv, 0, 0, 0, err
+ }
+
+ return 0, 0, 0, 0, errors.Errorf("invalid singel timeunit - %s", unit)
+}
+
+// parseTimeValue gets years, months, days, nanoseconds from a string
+// nanosecond will not exceed length of single day
+// MySQL permits any punctuation delimiter in the expr format.
+// See https://dev.mysql.com/doc/refman/8.0/en/expressions.html#temporal-intervals
+func parseTimeValue(format string, index, cnt int) (int64, int64, int64, int64, error) {
+ neg := false
+ originalFmt := format
+ format = strings.TrimSpace(format)
+ if len(format) > 0 && format[0] == '-' {
+ neg = true
+ format = format[1:]
+ }
+ fields := make([]string, TimeValueCnt)
+ for i := range fields {
+ fields[i] = "0"
+ }
+ matches := numericRegex.FindAllString(format, -1)
+ if len(matches) > cnt {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, originalFmt)
+ }
+ for i := range matches {
+ if neg {
+ fields[index] = "-" + matches[len(matches)-1-i]
+ } else {
+ fields[index] = matches[len(matches)-1-i]
+ }
+ index--
+ }
+
+ years, err := strconv.ParseInt(fields[YearIndex], 10, 64)
+ if err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, originalFmt)
+ }
+ months, err := strconv.ParseInt(fields[MonthIndex], 10, 64)
+ if err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, originalFmt)
+ }
+ days, err := strconv.ParseInt(fields[DayIndex], 10, 64)
+ if err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, originalFmt)
+ }
+
+ hours, err := strconv.ParseInt(fields[HourIndex], 10, 64)
+ if err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, originalFmt)
+ }
+ minutes, err := strconv.ParseInt(fields[MinuteIndex], 10, 64)
+ if err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, originalFmt)
+ }
+ seconds, err := strconv.ParseInt(fields[SecondIndex], 10, 64)
+ if err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, originalFmt)
+ }
+ microseconds, err := strconv.ParseInt(alignFrac(fields[MicrosecondIndex], int(MaxFsp)), 10, 64)
+ if err != nil {
+ return 0, 0, 0, 0, ErrWrongValue.GenWithStackByArgs(DateTimeStr, originalFmt)
+ }
+ seconds = hours*3600 + minutes*60 + seconds
+ days += seconds / (3600 * 24)
+ seconds %= 3600 * 24
+ return years, months, days, seconds*int64(gotime.Second) + microseconds*int64(gotime.Microsecond), nil
+}
+
+func parseAndValidateDurationValue(format string, index, cnt int) (int64, error) {
+ year, month, day, nano, err := parseTimeValue(format, index, cnt)
+ if err != nil {
+ return 0, err
+ }
+ if year != 0 || month != 0 || tidbMath.Abs(day) > TimeMaxHour/24 {
+ return 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ dur := day*int64(GoDurationDay) + nano
+ if tidbMath.Abs(dur) > int64(MaxTime) {
+ return 0, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ }
+ return dur, nil
+}
+
+// ParseDurationValue parses time value from time unit and format.
+// Returns y years m months d days + n nanoseconds
+// Nanoseconds will no longer than one day.
+func ParseDurationValue(unit string, format string) (y int64, m int64, d int64, n int64, _ error) {
+ switch strings.ToUpper(unit) {
+ case "MICROSECOND", "SECOND", "MINUTE", "HOUR", "DAY", "WEEK", "MONTH", "QUARTER", "YEAR":
+ return parseSingleTimeValue(unit, format, false)
+ case "SECOND_MICROSECOND":
+ return parseTimeValue(format, MicrosecondIndex, SecondMicrosecondMaxCnt)
+ case "MINUTE_MICROSECOND":
+ return parseTimeValue(format, MicrosecondIndex, MinuteMicrosecondMaxCnt)
+ case "MINUTE_SECOND":
+ return parseTimeValue(format, SecondIndex, MinuteSecondMaxCnt)
+ case "HOUR_MICROSECOND":
+ return parseTimeValue(format, MicrosecondIndex, HourMicrosecondMaxCnt)
+ case "HOUR_SECOND":
+ return parseTimeValue(format, SecondIndex, HourSecondMaxCnt)
+ case "HOUR_MINUTE":
+ return parseTimeValue(format, MinuteIndex, HourMinuteMaxCnt)
+ case "DAY_MICROSECOND":
+ return parseTimeValue(format, MicrosecondIndex, DayMicrosecondMaxCnt)
+ case "DAY_SECOND":
+ return parseTimeValue(format, SecondIndex, DaySecondMaxCnt)
+ case "DAY_MINUTE":
+ return parseTimeValue(format, MinuteIndex, DayMinuteMaxCnt)
+ case "DAY_HOUR":
+ return parseTimeValue(format, HourIndex, DayHourMaxCnt)
+ case "YEAR_MONTH":
+ return parseTimeValue(format, MonthIndex, YearMonthMaxCnt)
+ default:
+ return 0, 0, 0, 0, errors.Errorf("invalid single timeunit - %s", unit)
+ }
+}
+
+// ExtractDurationValue extract the value from format to Duration.
+func ExtractDurationValue(unit string, format string) (Duration, error) {
+ unit = strings.ToUpper(unit)
+ switch unit {
+ case "MICROSECOND", "SECOND", "MINUTE", "HOUR", "DAY", "WEEK", "MONTH", "QUARTER", "YEAR":
+ _, month, day, nano, err := parseSingleTimeValue(unit, format, true)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ dur := Duration{Duration: gotime.Duration((month*30+day)*int64(GoDurationDay) + nano)}
+ if unit == "MICROSECOND" {
+ dur.Fsp = MaxFsp
+ }
+ return dur, err
+ case "SECOND_MICROSECOND":
+ d, err := parseAndValidateDurationValue(format, MicrosecondIndex, SecondMicrosecondMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: MaxFsp}, nil
+ case "MINUTE_MICROSECOND":
+ d, err := parseAndValidateDurationValue(format, MicrosecondIndex, MinuteMicrosecondMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: MaxFsp}, nil
+ case "MINUTE_SECOND":
+ d, err := parseAndValidateDurationValue(format, SecondIndex, MinuteSecondMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: MaxFsp}, nil
+ case "HOUR_MICROSECOND":
+ d, err := parseAndValidateDurationValue(format, MicrosecondIndex, HourMicrosecondMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: MaxFsp}, nil
+ case "HOUR_SECOND":
+ d, err := parseAndValidateDurationValue(format, SecondIndex, HourSecondMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: MaxFsp}, nil
+ case "HOUR_MINUTE":
+ d, err := parseAndValidateDurationValue(format, MinuteIndex, HourMinuteMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: 0}, nil
+ case "DAY_MICROSECOND":
+ d, err := parseAndValidateDurationValue(format, MicrosecondIndex, DayMicrosecondMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: MaxFsp}, nil
+ case "DAY_SECOND":
+ d, err := parseAndValidateDurationValue(format, SecondIndex, DaySecondMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: MaxFsp}, nil
+ case "DAY_MINUTE":
+ d, err := parseAndValidateDurationValue(format, MinuteIndex, DayMinuteMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: 0}, nil
+ case "DAY_HOUR":
+ d, err := parseAndValidateDurationValue(format, HourIndex, DayHourMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ return Duration{Duration: gotime.Duration(d), Fsp: 0}, nil
+ case "YEAR_MONTH":
+ _, err := parseAndValidateDurationValue(format, MonthIndex, YearMonthMaxCnt)
+ if err != nil {
+ return ZeroDuration, err
+ }
+ // MONTH must exceed the limit of mysql's duration. So just returns overflow error.
+ return ZeroDuration, ErrDatetimeFunctionOverflow.GenWithStackByArgs("time")
+ default:
+ return ZeroDuration, errors.Errorf("invalid single timeunit - %s", unit)
+ }
+}
+
+// IsClockUnit returns true when unit is interval unit with hour, minute or second.
+func IsClockUnit(unit string) bool {
+ switch strings.ToUpper(unit) {
+ case "MICROSECOND", "SECOND", "MINUTE", "HOUR",
+ "SECOND_MICROSECOND", "MINUTE_MICROSECOND", "MINUTE_SECOND",
+ "HOUR_MICROSECOND", "HOUR_SECOND", "HOUR_MINUTE",
+ "DAY_MICROSECOND", "DAY_SECOND", "DAY_MINUTE", "DAY_HOUR":
+ return true
+ default:
+ return false
+ }
+}
+
+// IsDateFormat returns true when the specified time format could contain only date.
+func IsDateFormat(format string) bool {
+ format = strings.TrimSpace(format)
+ seps := ParseDateFormat(format)
+ length := len(format)
+ switch len(seps) {
+ case 1:
+ if (length == 8) || (length == 6) {
+ return true
+ }
+ case 3:
+ return true
+ }
+ return false
+}
+
+// ParseTimeFromInt64 parses mysql time value from int64.
+func ParseTimeFromInt64(sc *stmtctx.StatementContext, num int64) (Time, error) {
+ return parseDateTimeFromNum(sc, num)
+}
+
+// DateFormat returns a textual representation of the time value formatted
+// according to layout.
+// See http://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_date-format
+func (t Time) DateFormat(layout string) (string, error) {
+ var buf bytes.Buffer
+ inPatternMatch := false
+ for _, b := range layout {
+ if inPatternMatch {
+ if err := t.convertDateFormat(b, &buf); err != nil {
+ return "", errors.Trace(err)
+ }
+ inPatternMatch = false
+ continue
+ }
+
+ // It's not in pattern match now.
+ if b == '%' {
+ inPatternMatch = true
+ } else {
+ buf.WriteRune(b)
+ }
+ }
+ return buf.String(), nil
+}
+
+var abbrevWeekdayName = []string{
+ "Sun", "Mon", "Tue",
+ "Wed", "Thu", "Fri", "Sat",
+}
+
+func (t Time) convertDateFormat(b rune, buf *bytes.Buffer) error {
+ switch b {
+ case 'b':
+ m := t.Month()
+ if m == 0 || m > 12 {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, strconv.Itoa(m)))
+ }
+ buf.WriteString(MonthNames[m-1][:3])
+ case 'M':
+ m := t.Month()
+ if m == 0 || m > 12 {
+ return errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, strconv.Itoa(m)))
+ }
+ buf.WriteString(MonthNames[m-1])
+ case 'm':
+ buf.WriteString(FormatIntWidthN(t.Month(), 2))
+ case 'c':
+ buf.WriteString(strconv.FormatInt(int64(t.Month()), 10))
+ case 'D':
+ buf.WriteString(strconv.FormatInt(int64(t.Day()), 10))
+ buf.WriteString(abbrDayOfMonth(t.Day()))
+ case 'd':
+ buf.WriteString(FormatIntWidthN(t.Day(), 2))
+ case 'e':
+ buf.WriteString(strconv.FormatInt(int64(t.Day()), 10))
+ case 'j':
+ fmt.Fprintf(buf, "%03d", t.YearDay())
+ case 'H':
+ buf.WriteString(FormatIntWidthN(t.Hour(), 2))
+ case 'k':
+ buf.WriteString(strconv.FormatInt(int64(t.Hour()), 10))
+ case 'h', 'I':
+ t := t.Hour()
+ if t%12 == 0 {
+ buf.WriteString("12")
+ } else {
+ buf.WriteString(FormatIntWidthN(t%12, 2))
+ }
+ case 'l':
+ t := t.Hour()
+ if t%12 == 0 {
+ buf.WriteString("12")
+ } else {
+ buf.WriteString(strconv.FormatInt(int64(t%12), 10))
+ }
+ case 'i':
+ buf.WriteString(FormatIntWidthN(t.Minute(), 2))
+ case 'p':
+ hour := t.Hour()
+ if hour/12%2 == 0 {
+ buf.WriteString("AM")
+ } else {
+ buf.WriteString("PM")
+ }
+ case 'r':
+ h := t.Hour()
+ h %= 24
+ switch {
+ case h == 0:
+ fmt.Fprintf(buf, "%02d:%02d:%02d AM", 12, t.Minute(), t.Second())
+ case h == 12:
+ fmt.Fprintf(buf, "%02d:%02d:%02d PM", 12, t.Minute(), t.Second())
+ case h < 12:
+ fmt.Fprintf(buf, "%02d:%02d:%02d AM", h, t.Minute(), t.Second())
+ default:
+ fmt.Fprintf(buf, "%02d:%02d:%02d PM", h-12, t.Minute(), t.Second())
+ }
+ case 'T':
+ fmt.Fprintf(buf, "%02d:%02d:%02d", t.Hour(), t.Minute(), t.Second())
+ case 'S', 's':
+ buf.WriteString(FormatIntWidthN(t.Second(), 2))
+ case 'f':
+ fmt.Fprintf(buf, "%06d", t.Microsecond())
+ case 'U':
+ w := t.Week(0)
+ buf.WriteString(FormatIntWidthN(w, 2))
+ case 'u':
+ w := t.Week(1)
+ buf.WriteString(FormatIntWidthN(w, 2))
+ case 'V':
+ w := t.Week(2)
+ buf.WriteString(FormatIntWidthN(w, 2))
+ case 'v':
+ _, w := t.YearWeek(3)
+ buf.WriteString(FormatIntWidthN(w, 2))
+ case 'a':
+ weekday := t.Weekday()
+ buf.WriteString(abbrevWeekdayName[weekday])
+ case 'W':
+ buf.WriteString(t.Weekday().String())
+ case 'w':
+ buf.WriteString(strconv.FormatInt(int64(t.Weekday()), 10))
+ case 'X':
+ year, _ := t.YearWeek(2)
+ if year < 0 {
+ buf.WriteString(strconv.FormatUint(uint64(math.MaxUint32), 10))
+ } else {
+ buf.WriteString(FormatIntWidthN(year, 4))
+ }
+ case 'x':
+ year, _ := t.YearWeek(3)
+ if year < 0 {
+ buf.WriteString(strconv.FormatUint(uint64(math.MaxUint32), 10))
+ } else {
+ buf.WriteString(FormatIntWidthN(year, 4))
+ }
+ case 'Y':
+ buf.WriteString(FormatIntWidthN(t.Year(), 4))
+ case 'y':
+ str := FormatIntWidthN(t.Year(), 4)
+ buf.WriteString(str[2:])
+ default:
+ buf.WriteRune(b)
+ }
+
+ return nil
+}
+
+// FormatIntWidthN uses to format int with width. Insufficient digits are filled by 0.
+func FormatIntWidthN(num, n int) string {
+ numString := strconv.FormatInt(int64(num), 10)
+ if len(numString) >= n {
+ return numString
+ }
+ padBytes := make([]byte, n-len(numString))
+ for i := range padBytes {
+ padBytes[i] = '0'
+ }
+ return string(padBytes) + numString
+}
+
+func abbrDayOfMonth(day int) string {
+ var str string
+ switch day {
+ case 1, 21, 31:
+ str = "st"
+ case 2, 22:
+ str = "nd"
+ case 3, 23:
+ str = "rd"
+ default:
+ str = "th"
+ }
+ return str
+}
+
+// StrToDate converts date string according to format.
+// See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_date-format
+func (t *Time) StrToDate(sc *stmtctx.StatementContext, date, format string) bool {
+ ctx := make(map[string]int)
+ var tm CoreTime
+ success, warning := strToDate(&tm, date, format, ctx)
+ if !success {
+ t.SetCoreTime(ZeroCoreTime)
+ t.SetType(mysql.TypeDatetime)
+ t.SetFsp(0)
+ return false
+ }
+ if err := mysqlTimeFix(&tm, ctx); err != nil {
+ return false
+ }
+
+ t.SetCoreTime(tm)
+ t.SetType(mysql.TypeDatetime)
+ if t.check(sc) != nil {
+ return false
+ }
+ if warning {
+ // Only append this warning when success but still need warning.
+ // Currently this only happens when `date` has extra characters at the end.
+ sc.AppendWarning(ErrTruncatedWrongVal.GenWithStackByArgs(DateTimeStr, date))
+ }
+ return true
+}
+
+// mysqlTimeFix fixes the Time use the values in the context.
+func mysqlTimeFix(t *CoreTime, ctx map[string]int) error {
+ // Key of the ctx is the format char, such as `%j` `%p` and so on.
+ if yearOfDay, ok := ctx["%j"]; ok {
+ // TODO: Implement the function that converts day of year to yy:mm:dd.
+ _ = yearOfDay
+ }
+ if valueAMorPm, ok := ctx["%p"]; ok {
+ if _, ok := ctx["%H"]; ok {
+ return ErrWrongValue.GenWithStackByArgs(TimeStr, t)
+ }
+ if t.Hour() == 0 {
+ return ErrWrongValue.GenWithStackByArgs(TimeStr, t)
+ }
+ if t.Hour() == 12 {
+ // 12 is a special hour.
+ switch valueAMorPm {
+ case constForAM:
+ t.setHour(0)
+ case constForPM:
+ t.setHour(12)
+ }
+ return nil
+ }
+ if valueAMorPm == constForPM {
+ t.setHour(t.getHour() + 12)
+ }
+ } else {
+ if _, ok := ctx["%h"]; ok && t.Hour() == 12 {
+ t.setHour(0)
+ }
+ }
+ return nil
+}
+
+// strToDate converts date string according to format,
+// the value will be stored in argument t or ctx.
+// The second return value is true when success but still need to append a warning.
+func strToDate(t *CoreTime, date string, format string, ctx map[string]int) (success bool, warning bool) {
+ date = skipWhiteSpace(date)
+ format = skipWhiteSpace(format)
+
+ token, formatRemain, succ := getFormatToken(format)
+ if !succ {
+ return false, false
+ }
+
+ if token == "" {
+ if len(date) != 0 {
+ // Extra characters at the end of date are ignored, but a warning should be reported at this case.
+ return true, true
+ }
+ // Normal case. Both token and date are empty now.
+ return true, false
+ }
+
+ if len(date) == 0 {
+ ctx[token] = 0
+ return true, false
+ }
+
+ dateRemain, succ := matchDateWithToken(t, date, token, ctx)
+ if !succ {
+ return false, false
+ }
+
+ return strToDate(t, dateRemain, formatRemain, ctx)
+}
+
+// getFormatToken takes one format control token from the string.
+// format "%d %H %m" will get token "%d" and the remain is " %H %m".
+func getFormatToken(format string) (token string, remain string, succ bool) {
+ if len(format) == 0 {
+ return "", "", true
+ }
+
+ // Just one character.
+ if len(format) == 1 {
+ if format[0] == '%' {
+ return "", "", false
+ }
+ return format, "", true
+ }
+
+ // More than one character.
+ if format[0] == '%' {
+ return format[:2], format[2:], true
+ }
+
+ return format[:1], format[1:], true
+}
+
+func skipWhiteSpace(input string) string {
+ for i, c := range input {
+ if !unicode.IsSpace(c) {
+ return input[i:]
+ }
+ }
+ return ""
+}
+
+var monthAbbrev = map[string]gotime.Month{
+ "Jan": gotime.January,
+ "Feb": gotime.February,
+ "Mar": gotime.March,
+ "Apr": gotime.April,
+ "May": gotime.May,
+ "Jun": gotime.June,
+ "Jul": gotime.July,
+ "Aug": gotime.August,
+ "Sep": gotime.September,
+ "Oct": gotime.October,
+ "Nov": gotime.November,
+ "Dec": gotime.December,
+}
+
+type dateFormatParser func(t *CoreTime, date string, ctx map[string]int) (remain string, succ bool)
+
+var dateFormatParserTable = map[string]dateFormatParser{
+ "%b": abbreviatedMonth, // Abbreviated month name (Jan..Dec)
+ "%c": monthNumeric, // Month, numeric (0..12)
+ "%d": dayOfMonthNumeric, // Day of the month, numeric (0..31)
+ "%e": dayOfMonthNumeric, // Day of the month, numeric (0..31)
+ "%f": microSeconds, // Microseconds (000000..999999)
+ "%h": hour12Numeric, // Hour (01..12)
+ "%H": hour24Numeric, // Hour (00..23)
+ "%I": hour12Numeric, // Hour (01..12)
+ "%i": minutesNumeric, // Minutes, numeric (00..59)
+ "%j": dayOfYearThreeDigits, // Day of year (001..366)
+ "%k": hour24Numeric, // Hour (0..23)
+ "%l": hour12Numeric, // Hour (1..12)
+ "%M": fullNameMonth, // Month name (January..December)
+ "%m": monthNumeric, // Month, numeric (00..12)
+ "%p": isAMOrPM, // AM or PM
+ "%r": time12Hour, // Time, 12-hour (hh:mm:ss followed by AM or PM)
+ "%s": secondsNumeric, // Seconds (00..59)
+ "%S": secondsNumeric, // Seconds (00..59)
+ "%T": time24Hour, // Time, 24-hour (hh:mm:ss)
+ "%Y": yearNumericFourDigits, // Year, numeric, four digits
+ "%#": skipAllNums, // Skip all numbers
+ "%.": skipAllPunct, // Skip all punctation characters
+ "%@": skipAllAlpha, // Skip all alpha characters
+ // Deprecated since MySQL 5.7.5
+ "%y": yearNumericTwoDigits, // Year, numeric (two digits)
+ // TODO: Add the following...
+ // "%a": abbreviatedWeekday, // Abbreviated weekday name (Sun..Sat)
+ // "%D": dayOfMonthWithSuffix, // Day of the month with English suffix (0th, 1st, 2nd, 3rd)
+ // "%U": weekMode0, // Week (00..53), where Sunday is the first day of the week; WEEK() mode 0
+ // "%u": weekMode1, // Week (00..53), where Monday is the first day of the week; WEEK() mode 1
+ // "%V": weekMode2, // Week (01..53), where Sunday is the first day of the week; WEEK() mode 2; used with %X
+ // "%v": weekMode3, // Week (01..53), where Monday is the first day of the week; WEEK() mode 3; used with %x
+ // "%W": weekdayName, // Weekday name (Sunday..Saturday)
+ // "%w": dayOfWeek, // Day of the week (0=Sunday..6=Saturday)
+ // "%X": yearOfWeek, // Year for the week where Sunday is the first day of the week, numeric, four digits; used with %V
+ // "%x": yearOfWeek, // Year for the week, where Monday is the first day of the week, numeric, four digits; used with %v
+}
+
+// GetFormatType checks the type(Duration, Date or Datetime) of a format string.
+func GetFormatType(format string) (isDuration, isDate bool) {
+ format = skipWhiteSpace(format)
+ var token string
+ var succ bool
+ for {
+ token, format, succ = getFormatToken(format)
+ if len(token) == 0 {
+ break
+ }
+ if !succ {
+ isDuration, isDate = false, false
+ break
+ }
+ if len(token) >= 2 && token[0] == '%' {
+ switch token[1] {
+ case 'h', 'H', 'i', 'I', 's', 'S', 'k', 'l', 'f', 'r', 'T':
+ isDuration = true
+ case 'y', 'Y', 'm', 'M', 'c', 'b', 'D', 'd', 'e':
+ isDate = true
+ }
+ }
+ if isDuration && isDate {
+ break
+ }
+ }
+ return
+}
+
+func matchDateWithToken(t *CoreTime, date string, token string, ctx map[string]int) (remain string, succ bool) {
+ if parse, ok := dateFormatParserTable[token]; ok {
+ return parse(t, date, ctx)
+ }
+
+ if strings.HasPrefix(date, token) {
+ return date[len(token):], true
+ }
+ return date, false
+}
+
+func parseDigits(input string, count int) (int, bool) {
+ if count <= 0 || len(input) < count {
+ return 0, false
+ }
+
+ v, err := strconv.ParseUint(input[:count], 10, 64)
+ if err != nil {
+ return int(v), false
+ }
+ return int(v), true
+}
+
+func secondsNumeric(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ result := oneOrTwoDigitRegex.FindString(input)
+ length := len(result)
+
+ v, succ := parseDigits(input, length)
+ if !succ || v >= 60 {
+ return input, false
+ }
+ t.setSecond(uint8(v))
+ return input[length:], true
+}
+
+func minutesNumeric(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ result := oneOrTwoDigitRegex.FindString(input)
+ length := len(result)
+
+ v, succ := parseDigits(input, length)
+ if !succ || v >= 60 {
+ return input, false
+ }
+ t.setMinute(uint8(v))
+ return input[length:], true
+}
+
+const time12HourLen = len("hh:mm:ssAM")
+
+func time12Hour(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ // hh:mm:ss AM
+ if len(input) < time12HourLen {
+ return input, false
+ }
+ hour, succ := parseDigits(input, 2)
+ if !succ || hour > 12 || hour == 0 || input[2] != ':' {
+ return input, false
+ }
+ // 12:34:56 AM -> 00:34:56
+ if hour == 12 {
+ hour = 0
+ }
+
+ minute, succ := parseDigits(input[3:], 2)
+ if !succ || minute > 59 || input[5] != ':' {
+ return input, false
+ }
+
+ second, succ := parseDigits(input[6:], 2)
+ if !succ || second > 59 {
+ return input, false
+ }
+
+ remain := skipWhiteSpace(input[8:])
+ switch {
+ case strings.HasPrefix(remain, "AM"):
+ t.setHour(uint8(hour))
+ remain = strings.TrimPrefix(remain, "AM")
+ case strings.HasPrefix(remain, "PM"):
+ t.setHour(uint8(hour + 12))
+ remain = strings.TrimPrefix(remain, "PM")
+ default:
+ return input, false
+ }
+
+ t.setMinute(uint8(minute))
+ t.setSecond(uint8(second))
+ return remain, true
+}
+
+const time24HourLen = len("hh:mm:ss")
+
+func time24Hour(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ // hh:mm:ss
+ if len(input) < time24HourLen {
+ return input, false
+ }
+
+ hour, succ := parseDigits(input, 2)
+ if !succ || hour > 23 || input[2] != ':' {
+ return input, false
+ }
+
+ minute, succ := parseDigits(input[3:], 2)
+ if !succ || minute > 59 || input[5] != ':' {
+ return input, false
+ }
+
+ second, succ := parseDigits(input[6:], 2)
+ if !succ || second > 59 {
+ return input, false
+ }
+
+ t.setHour(uint8(hour))
+ t.setMinute(uint8(minute))
+ t.setSecond(uint8(second))
+ return input[8:], true
+}
+
+const (
+ constForAM = 1 + iota
+ constForPM
+)
+
+func isAMOrPM(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ if len(input) < 2 {
+ return input, false
+ }
+
+ s := strings.ToLower(input[:2])
+ switch s {
+ case "am":
+ ctx["%p"] = constForAM
+ case "pm":
+ ctx["%p"] = constForPM
+ default:
+ return input, false
+ }
+ return input[2:], true
+}
+
+// digitRegex: it was used to scan a variable-length monthly day or month in the string. Ex: "01" or "1" or "30"
+var oneOrTwoDigitRegex = regexp.MustCompile("^[0-9]{1,2}")
+
+// oneToSixDigitRegex: it was just for [0, 999999]
+var oneToSixDigitRegex = regexp.MustCompile("^[0-9]{0,6}")
+
+// numericRegex: it was for any numeric characters
+var numericRegex = regexp.MustCompile("[0-9]+")
+
+func dayOfMonthNumeric(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ result := oneOrTwoDigitRegex.FindString(input) // 0..31
+ length := len(result)
+
+ v, ok := parseDigits(input, length)
+
+ if !ok || v > 31 {
+ return input, false
+ }
+ t.setDay(uint8(v))
+ return input[length:], true
+}
+
+func hour24Numeric(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ result := oneOrTwoDigitRegex.FindString(input) // 0..23
+ length := len(result)
+
+ v, ok := parseDigits(input, length)
+
+ if !ok || v > 23 {
+ return input, false
+ }
+ t.setHour(uint8(v))
+ ctx["%H"] = v
+ return input[length:], true
+}
+
+func hour12Numeric(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ result := oneOrTwoDigitRegex.FindString(input) // 1..12
+ length := len(result)
+
+ v, ok := parseDigits(input, length)
+
+ if !ok || v > 12 || v == 0 {
+ return input, false
+ }
+ t.setHour(uint8(v))
+ ctx["%h"] = v
+ return input[length:], true
+}
+
+func microSeconds(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ result := oneToSixDigitRegex.FindString(input)
+ length := len(result)
+ if length == 0 {
+ t.setMicrosecond(0)
+ return input, true
+ }
+
+ v, ok := parseDigits(input, length)
+
+ if !ok {
+ return input, false
+ }
+ for v > 0 && v*10 < 1000000 {
+ v *= 10
+ }
+ t.setMicrosecond(uint32(v))
+ return input[length:], true
+}
+
+func yearNumericFourDigits(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ return yearNumericNDigits(t, input, ctx, 4)
+}
+
+func yearNumericTwoDigits(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ return yearNumericNDigits(t, input, ctx, 2)
+}
+
+func yearNumericNDigits(t *CoreTime, input string, ctx map[string]int, n int) (string, bool) {
+ effectiveCount, effectiveValue := 0, 0
+ for effectiveCount+1 <= n {
+ value, succeed := parseDigits(input, effectiveCount+1)
+ if !succeed {
+ break
+ }
+ effectiveCount++
+ effectiveValue = value
+ }
+ if effectiveCount == 0 {
+ return input, false
+ }
+ if effectiveCount <= 2 {
+ effectiveValue = adjustYear(effectiveValue)
+ }
+ t.setYear(uint16(effectiveValue))
+ return input[effectiveCount:], true
+}
+
+func dayOfYearThreeDigits(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ v, succ := parseDigits(input, 3)
+ if !succ || v == 0 || v > 366 {
+ return input, false
+ }
+ ctx["%j"] = v
+ return input[3:], true
+}
+
+func abbreviatedMonth(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ if len(input) >= 3 {
+ monthName := input[:3]
+ if month, ok := monthAbbrev[monthName]; ok {
+ t.setMonth(uint8(month))
+ return input[len(monthName):], true
+ }
+ }
+ return input, false
+}
+
+func fullNameMonth(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ for i, month := range MonthNames {
+ if strings.HasPrefix(input, month) {
+ t.setMonth(uint8(i + 1))
+ return input[len(month):], true
+ }
+ }
+ return input, false
+}
+
+func monthNumeric(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ result := oneOrTwoDigitRegex.FindString(input) // 1..12
+ length := len(result)
+
+ v, ok := parseDigits(input, length)
+
+ if !ok || v > 12 {
+ return input, false
+ }
+ t.setMonth(uint8(v))
+ return input[length:], true
+}
+
+// DateFSP gets fsp from date string.
+func DateFSP(date string) (fsp int) {
+ i := strings.LastIndex(date, ".")
+ if i != -1 {
+ fsp = len(date) - i - 1
+ }
+ return
+}
+
+// DateTimeIsOverflow returns if this date is overflow.
+// See: https://dev.mysql.com/doc/refman/8.0/en/datetime.html
+func DateTimeIsOverflow(sc *stmtctx.StatementContext, date Time) (bool, error) {
+ tz := sc.TimeZone
+ if tz == nil {
+ tz = gotime.Local
+ }
+
+ var err error
+ var b, e, t gotime.Time
+ switch date.Type() {
+ case mysql.TypeDate, mysql.TypeDatetime:
+ if b, err = MinDatetime.GoTime(tz); err != nil {
+ return false, err
+ }
+ if e, err = MaxDatetime.GoTime(tz); err != nil {
+ return false, err
+ }
+ case mysql.TypeTimestamp:
+ minTS, maxTS := MinTimestamp, MaxTimestamp
+ if tz != gotime.UTC {
+ if err = minTS.ConvertTimeZone(gotime.UTC, tz); err != nil {
+ return false, err
+ }
+ if err = maxTS.ConvertTimeZone(gotime.UTC, tz); err != nil {
+ return false, err
+ }
+ }
+ if b, err = minTS.GoTime(tz); err != nil {
+ return false, err
+ }
+ if e, err = maxTS.GoTime(tz); err != nil {
+ return false, err
+ }
+ default:
+ return false, nil
+ }
+
+ if t, err = date.GoTime(tz); err != nil {
+ return false, err
+ }
+
+ inRange := (t.After(b) || t.Equal(b)) && (t.Before(e) || t.Equal(e))
+ return !inRange, nil
+}
+
+func skipAllNums(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ retIdx := 0
+ for i, ch := range input {
+ if unicode.IsNumber(ch) {
+ retIdx = i + 1
+ } else {
+ break
+ }
+ }
+ return input[retIdx:], true
+}
+
+func skipAllPunct(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ retIdx := 0
+ for i, ch := range input {
+ if unicode.IsPunct(ch) {
+ retIdx = i + 1
+ } else {
+ break
+ }
+ }
+ return input[retIdx:], true
+}
+
+func skipAllAlpha(t *CoreTime, input string, ctx map[string]int) (string, bool) {
+ retIdx := 0
+ for i, ch := range input {
+ if unicode.IsLetter(ch) {
+ retIdx = i + 1
+ } else {
+ break
+ }
+ }
+ return input[retIdx:], true
+}
diff --git a/pkg/util/arena/arena.go b/pkg/util/arena/arena.go
new file mode 100644
index 0000000000000000000000000000000000000000..834a30831382ab7a319838a66650bcb3a352697b
--- /dev/null
+++ b/pkg/util/arena/arena.go
@@ -0,0 +1,67 @@
+package arena
+
+// Allocator pre-allocates memory to reduce memory allocation cost.
+// It is not thread-safe.
+type Allocator interface {
+ // Alloc allocates memory with 0 len and capacity cap.
+ Alloc(capacity int) []byte
+
+ // AllocWithLen allocates memory with length and capacity.
+ AllocWithLen(length int, capacity int) []byte
+
+ // Reset resets arena offset.
+ // Make sure all the allocated memory are not used any more.
+ Reset()
+}
+
+// SimpleAllocator is a simple implementation of ArenaAllocator.
+type SimpleAllocator struct {
+ arena []byte
+ off int
+}
+
+type stdAllocator struct {
+}
+
+func (a *stdAllocator) Alloc(capacity int) []byte {
+ return make([]byte, 0, capacity)
+}
+
+func (a *stdAllocator) AllocWithLen(length int, capacity int) []byte {
+ return make([]byte, length, capacity)
+}
+
+func (a *stdAllocator) Reset() {
+}
+
+var _ Allocator = &stdAllocator{}
+
+// StdAllocator implements Allocator but do not pre-allocate memory.
+var StdAllocator = &stdAllocator{}
+
+// NewAllocator creates an Allocator with a specified capacity.
+func NewAllocator(capacity int) *SimpleAllocator {
+ return &SimpleAllocator{arena: make([]byte, 0, capacity)}
+}
+
+// Alloc implements Allocator.AllocBytes interface.
+func (s *SimpleAllocator) Alloc(capacity int) []byte {
+ if s.off+capacity < cap(s.arena) {
+ slice := s.arena[s.off : s.off : s.off+capacity]
+ s.off += capacity
+ return slice
+ }
+
+ return make([]byte, 0, capacity)
+}
+
+// AllocWithLen implements Allocator.AllocWithLen interface.
+func (s *SimpleAllocator) AllocWithLen(length int, capacity int) []byte {
+ slice := s.Alloc(capacity)
+ return slice[:length:capacity]
+}
+
+// Reset implements Allocator.Reset interface.
+func (s *SimpleAllocator) Reset() {
+ s.off = 0
+}
diff --git a/pkg/util/chunk/chunk.go b/pkg/util/chunk/chunk.go
new file mode 100644
index 0000000000000000000000000000000000000000..53cf1e3686f63ba9cbece86f7a7c7359a906fb60
--- /dev/null
+++ b/pkg/util/chunk/chunk.go
@@ -0,0 +1,714 @@
+package chunk
+
+import (
+ "reflect"
+ "unsafe"
+
+ "github.com/cznic/mathutil"
+ "github.com/pingcap/errors"
+ "matrixbase/pkg/types"
+ "matrixbase/pkg/types/json"
+)
+
+var msgErrSelNotNil = "The selection vector of Chunk is not nil. Please file a bug to the TiDB Team"
+
+// Chunk stores multiple rows of data in Apache Arrow format.
+// See https://arrow.apache.org/docs/format/Columnar.html#physical-memory-layout
+// Values are appended in compact format and can be directly accessed without decoding.
+// When the chunk is done processing, we can reuse the allocated memory by resetting it.
+type Chunk struct {
+ // sel indicates which rows are selected.
+ // If it is nil, all rows are selected.
+ sel []int
+
+ columns []*Column
+ // numVirtualRows indicates the number of virtual rows, which have zero Column.
+ // It is used only when this Chunk doesn't hold any data, i.e. "len(columns)==0".
+ numVirtualRows int
+ // capacity indicates the max number of rows this chunk can hold.
+ // TODO: replace all usages of capacity to requiredRows and remove this field
+ capacity int
+
+ // requiredRows indicates how many rows the parent executor want.
+ requiredRows int
+}
+
+// Capacity constants.
+const (
+ InitialCapacity = 32
+ ZeroCapacity = 0
+)
+
+// NewChunkWithCapacity creates a new chunk with field types and capacity.
+func NewChunkWithCapacity(fields []*types.FieldType, cap int) *Chunk {
+ return New(fields, cap, cap) //FIXME: in following PR.
+}
+
+// New creates a new chunk.
+// cap: the limit for the max number of rows.
+// maxChunkSize: the max limit for the number of rows.
+func New(fields []*types.FieldType, cap, maxChunkSize int) *Chunk {
+ chk := &Chunk{
+ columns: make([]*Column, 0, len(fields)),
+ capacity: mathutil.Min(cap, maxChunkSize),
+ // set the default value of requiredRows to maxChunkSize to let chk.IsFull() behave
+ // like how we judge whether a chunk is full now, then the statement
+ // "chk.NumRows() < maxChunkSize"
+ // equals to "!chk.IsFull()".
+ requiredRows: maxChunkSize,
+ }
+
+ for _, f := range fields {
+ chk.columns = append(chk.columns, NewColumn(f, chk.capacity))
+ }
+
+ return chk
+}
+
+// renewWithCapacity creates a new Chunk based on an existing Chunk with capacity. The newly
+// created Chunk has the same data schema with the old Chunk.
+func renewWithCapacity(chk *Chunk, cap, maxChunkSize int) *Chunk {
+ newChk := new(Chunk)
+ if chk.columns == nil {
+ return newChk
+ }
+ newChk.columns = renewColumns(chk.columns, cap)
+ newChk.numVirtualRows = 0
+ newChk.capacity = cap
+ newChk.requiredRows = maxChunkSize
+ return newChk
+}
+
+// Renew creates a new Chunk based on an existing Chunk. The newly created Chunk
+// has the same data schema with the old Chunk. The capacity of the new Chunk
+// might be doubled based on the capacity of the old Chunk and the maxChunkSize.
+// chk: old chunk(often used in previous call).
+// maxChunkSize: the limit for the max number of rows.
+func Renew(chk *Chunk, maxChunkSize int) *Chunk {
+ newCap := reCalcCapacity(chk, maxChunkSize)
+ return renewWithCapacity(chk, newCap, maxChunkSize)
+}
+
+// renewColumns creates the columns of a Chunk. The capacity of the newly
+// created columns is equal to cap.
+func renewColumns(oldCol []*Column, cap int) []*Column {
+ columns := make([]*Column, 0, len(oldCol))
+ for _, col := range oldCol {
+ columns = append(columns, newColumn(col.typeSize(), cap))
+ }
+ return columns
+}
+
+// renewEmpty creates a new Chunk based on an existing Chunk
+// but keep columns empty.
+func renewEmpty(chk *Chunk) *Chunk {
+ newChk := &Chunk{
+ columns: nil,
+ numVirtualRows: chk.numVirtualRows,
+ capacity: chk.capacity,
+ requiredRows: chk.requiredRows,
+ }
+ if chk.sel != nil {
+ newChk.sel = make([]int, len(chk.sel))
+ copy(newChk.sel, chk.sel)
+ }
+ return newChk
+}
+
+// MemoryUsage returns the total memory usage of a Chunk in bytes.
+// We ignore the size of Column.length and Column.nullCount
+// since they have little effect of the total memory usage.
+func (c *Chunk) MemoryUsage() (sum int64) {
+ for _, col := range c.columns {
+ curColMemUsage := int64(unsafe.Sizeof(*col)) + int64(cap(col.nullBitmap)) + int64(cap(col.offsets)*8) + int64(cap(col.data)) + int64(cap(col.elemBuf))
+ sum += curColMemUsage
+ }
+ return
+}
+
+// newFixedLenColumn creates a fixed length Column with elemLen and initial data capacity.
+func newFixedLenColumn(elemLen, cap int) *Column {
+ return &Column{
+ elemBuf: make([]byte, elemLen),
+ data: make([]byte, 0, cap*elemLen),
+ nullBitmap: make([]byte, 0, (cap+7)>>3),
+ }
+}
+
+// newVarLenColumn creates a variable length Column with initial data capacity.
+func newVarLenColumn(cap int, old *Column) *Column {
+ estimatedElemLen := 8
+ // For varLenColumn (e.g. varchar), the accurate length of an element is unknown.
+ // Therefore, in the first executor.Next we use an experience value -- 8 (so it may make runtime.growslice)
+ // but in the following Next call we estimate the length as AVG x 1.125 elemLen of the previous call.
+ if old != nil && old.length != 0 {
+ estimatedElemLen = (len(old.data) + len(old.data)/8) / old.length
+ }
+ return &Column{
+ offsets: make([]int64, 1, cap+1),
+ data: make([]byte, 0, cap*estimatedElemLen),
+ nullBitmap: make([]byte, 0, (cap+7)>>3),
+ }
+}
+
+// RequiredRows returns how many rows is considered full.
+func (c *Chunk) RequiredRows() int {
+ return c.requiredRows
+}
+
+// SetRequiredRows sets the number of required rows.
+func (c *Chunk) SetRequiredRows(requiredRows, maxChunkSize int) *Chunk {
+ if requiredRows <= 0 || requiredRows > maxChunkSize {
+ requiredRows = maxChunkSize
+ }
+ c.requiredRows = requiredRows
+ return c
+}
+
+// IsFull returns if this chunk is considered full.
+func (c *Chunk) IsFull() bool {
+ return c.NumRows() >= c.requiredRows
+}
+
+// Prune creates a new Chunk according to `c` and prunes the columns
+// whose index is not in `usedColIdxs`
+func (c *Chunk) Prune(usedColIdxs []int) *Chunk {
+ chk := renewEmpty(c)
+ chk.columns = make([]*Column, len(usedColIdxs))
+ for i, idx := range usedColIdxs {
+ chk.columns[i] = c.columns[idx]
+ }
+ return chk
+}
+
+// MakeRef makes Column in "dstColIdx" reference to Column in "srcColIdx".
+func (c *Chunk) MakeRef(srcColIdx, dstColIdx int) {
+ c.columns[dstColIdx] = c.columns[srcColIdx]
+}
+
+// MakeRefTo copies columns `src.columns[srcColIdx]` to `c.columns[dstColIdx]`.
+func (c *Chunk) MakeRefTo(dstColIdx int, src *Chunk, srcColIdx int) error {
+ if c.sel != nil || src.sel != nil {
+ return errors.New(msgErrSelNotNil)
+ }
+ c.columns[dstColIdx] = src.columns[srcColIdx]
+ return nil
+}
+
+// SwapColumn swaps Column "c.columns[colIdx]" with Column
+// "other.columns[otherIdx]". If there exists columns refer to the Column to be
+// swapped, we need to re-build the reference.
+func (c *Chunk) SwapColumn(colIdx int, other *Chunk, otherIdx int) error {
+ if c.sel != nil || other.sel != nil {
+ return errors.New(msgErrSelNotNil)
+ }
+ // Find the leftmost Column of the reference which is the actual Column to
+ // be swapped.
+ for i := 0; i < colIdx; i++ {
+ if c.columns[i] == c.columns[colIdx] {
+ colIdx = i
+ }
+ }
+ for i := 0; i < otherIdx; i++ {
+ if other.columns[i] == other.columns[otherIdx] {
+ otherIdx = i
+ }
+ }
+
+ // Find the columns which refer to the actual Column to be swapped.
+ refColsIdx := make([]int, 0, len(c.columns)-colIdx)
+ for i := colIdx; i < len(c.columns); i++ {
+ if c.columns[i] == c.columns[colIdx] {
+ refColsIdx = append(refColsIdx, i)
+ }
+ }
+ refColsIdx4Other := make([]int, 0, len(other.columns)-otherIdx)
+ for i := otherIdx; i < len(other.columns); i++ {
+ if other.columns[i] == other.columns[otherIdx] {
+ refColsIdx4Other = append(refColsIdx4Other, i)
+ }
+ }
+
+ // Swap columns from two chunks.
+ c.columns[colIdx], other.columns[otherIdx] = other.columns[otherIdx], c.columns[colIdx]
+
+ // Rebuild the reference.
+ for _, i := range refColsIdx {
+ c.MakeRef(colIdx, i)
+ }
+ for _, i := range refColsIdx4Other {
+ other.MakeRef(otherIdx, i)
+ }
+ return nil
+}
+
+// SwapColumns swaps columns with another Chunk.
+func (c *Chunk) SwapColumns(other *Chunk) {
+ c.sel, other.sel = other.sel, c.sel
+ c.columns, other.columns = other.columns, c.columns
+ c.numVirtualRows, other.numVirtualRows = other.numVirtualRows, c.numVirtualRows
+}
+
+// SetNumVirtualRows sets the virtual row number for a Chunk.
+// It should only be used when there exists no Column in the Chunk.
+func (c *Chunk) SetNumVirtualRows(numVirtualRows int) {
+ c.numVirtualRows = numVirtualRows
+}
+
+// Reset resets the chunk, so the memory it allocated can be reused.
+// Make sure all the data in the chunk is not used anymore before you reuse this chunk.
+func (c *Chunk) Reset() {
+ c.sel = nil
+ if c.columns == nil {
+ return
+ }
+ for _, col := range c.columns {
+ col.reset()
+ }
+ c.numVirtualRows = 0
+}
+
+// CopyConstruct creates a new chunk and copies this chunk's data into it.
+func (c *Chunk) CopyConstruct() *Chunk {
+ newChk := renewEmpty(c)
+ newChk.columns = make([]*Column, len(c.columns))
+ for i := range c.columns {
+ newChk.columns[i] = c.columns[i].CopyConstruct(nil)
+ }
+ return newChk
+}
+
+// GrowAndReset resets the Chunk and doubles the capacity of the Chunk.
+// The doubled capacity should not be larger than maxChunkSize.
+// TODO: this method will be used in following PR.
+func (c *Chunk) GrowAndReset(maxChunkSize int) {
+ c.sel = nil
+ if c.columns == nil {
+ return
+ }
+ newCap := reCalcCapacity(c, maxChunkSize)
+ if newCap <= c.capacity {
+ c.Reset()
+ return
+ }
+ c.capacity = newCap
+ c.columns = renewColumns(c.columns, newCap)
+ c.numVirtualRows = 0
+ c.requiredRows = maxChunkSize
+}
+
+// reCalcCapacity calculates the capacity for another Chunk based on the current
+// Chunk. The new capacity is doubled only when the current Chunk is full.
+func reCalcCapacity(c *Chunk, maxChunkSize int) int {
+ if c.NumRows() < c.capacity {
+ return c.capacity
+ }
+ return mathutil.Min(c.capacity*2, maxChunkSize)
+}
+
+// Capacity returns the capacity of the Chunk.
+func (c *Chunk) Capacity() int {
+ return c.capacity
+}
+
+// NumCols returns the number of columns in the chunk.
+func (c *Chunk) NumCols() int {
+ return len(c.columns)
+}
+
+// NumRows returns the number of rows in the chunk.
+func (c *Chunk) NumRows() int {
+ if c.sel != nil {
+ return len(c.sel)
+ }
+ if c.NumCols() == 0 {
+ return c.numVirtualRows
+ }
+ return c.columns[0].length
+}
+
+// GetRow gets the Row in the chunk with the row index.
+func (c *Chunk) GetRow(idx int) Row {
+ if c.sel != nil {
+ // mapping the logical RowIdx to the actual physical RowIdx;
+ // for example, if the Sel is [1, 5, 6], then
+ // logical 0 -> physical 1,
+ // logical 1 -> physical 5,
+ // logical 2 -> physical 6.
+ // Then when we iterate this Chunk according to Row, only selected rows will be
+ // accessed while all filtered rows will be ignored.
+ return Row{c: c, idx: c.sel[idx]}
+ }
+ return Row{c: c, idx: idx}
+}
+
+// AppendRow appends a row to the chunk.
+func (c *Chunk) AppendRow(row Row) {
+ c.AppendPartialRow(0, row)
+ c.numVirtualRows++
+}
+
+// AppendPartialRow appends a row to the chunk.
+func (c *Chunk) AppendPartialRow(colOff int, row Row) {
+ c.appendSel(colOff)
+ for i, rowCol := range row.c.columns {
+ chkCol := c.columns[colOff+i]
+ appendCellByCell(chkCol, rowCol, row.idx)
+ }
+}
+
+// AppendRowByColIdxs appends a row by its colIdxs to the chunk.
+// 1. every columns are used if colIdxs is nil.
+// 2. no columns are used if colIdxs is not nil but the size of colIdxs is 0.
+func (c *Chunk) AppendRowByColIdxs(row Row, colIdxs []int) (wide int) {
+ wide = c.AppendPartialRowByColIdxs(0, row, colIdxs)
+ c.numVirtualRows++
+ return
+}
+
+// AppendPartialRowByColIdxs appends a row by its colIdxs to the chunk.
+// 1. every columns are used if colIdxs is nil.
+// 2. no columns are used if colIdxs is not nil but the size of colIdxs is 0.
+func (c *Chunk) AppendPartialRowByColIdxs(colOff int, row Row, colIdxs []int) (wide int) {
+ if colIdxs == nil {
+ c.AppendPartialRow(colOff, row)
+ return row.Len()
+ }
+
+ c.appendSel(colOff)
+ for i, colIdx := range colIdxs {
+ rowCol := row.c.columns[colIdx]
+ chkCol := c.columns[colOff+i]
+ appendCellByCell(chkCol, rowCol, row.idx)
+ }
+ return len(colIdxs)
+}
+
+// appendCellByCell appends the cell with rowIdx of src into dst.
+func appendCellByCell(dst *Column, src *Column, rowIdx int) {
+ dst.appendNullBitmap(!src.IsNull(rowIdx))
+ if src.isFixed() {
+ elemLen := len(src.elemBuf)
+ offset := rowIdx * elemLen
+ dst.data = append(dst.data, src.data[offset:offset+elemLen]...)
+ } else {
+ start, end := src.offsets[rowIdx], src.offsets[rowIdx+1]
+ dst.data = append(dst.data, src.data[start:end]...)
+ dst.offsets = append(dst.offsets, int64(len(dst.data)))
+ }
+ dst.length++
+}
+
+// preAlloc pre-allocates the memory space in a Chunk to store the Row.
+// NOTE: only used in test.
+// 1. The Chunk must be empty or holds no useful data.
+// 2. The schema of the Row must be the same with the Chunk.
+// 3. This API is paired with the `Insert()` function, which inserts all the
+// rows data into the Chunk after the pre-allocation.
+// 4. We set the null bitmap here instead of in the Insert() function because
+// when the Insert() function is called parallelly, the data race on a byte
+// can not be avoided although the manipulated bits are different inside a
+// byte.
+func (c *Chunk) preAlloc(row Row) (rowIdx uint32) {
+ rowIdx = uint32(c.NumRows())
+ for i, srcCol := range row.c.columns {
+ dstCol := c.columns[i]
+ dstCol.appendNullBitmap(!srcCol.IsNull(row.idx))
+ elemLen := len(srcCol.elemBuf)
+ if !srcCol.isFixed() {
+ elemLen = int(srcCol.offsets[row.idx+1] - srcCol.offsets[row.idx])
+ dstCol.offsets = append(dstCol.offsets, int64(len(dstCol.data)+elemLen))
+ }
+ dstCol.length++
+ needCap := len(dstCol.data) + elemLen
+ if needCap <= cap(dstCol.data) {
+ (*reflect.SliceHeader)(unsafe.Pointer(&dstCol.data)).Len = len(dstCol.data) + elemLen
+ continue
+ }
+ // Grow the capacity according to golang.growslice.
+ // Implementation differences with golang:
+ // 1. We double the capacity when `dstCol.data < 1024*elemLen bytes` but
+ // not `1024 bytes`.
+ // 2. We expand the capacity to 1.5*originCap rather than 1.25*originCap
+ // during the slow-increasing phase.
+ newCap := cap(dstCol.data)
+ doubleCap := newCap << 1
+ if needCap > doubleCap {
+ newCap = needCap
+ } else {
+ avgElemLen := elemLen
+ if !srcCol.isFixed() {
+ avgElemLen = len(dstCol.data) / len(dstCol.offsets)
+ }
+ // slowIncThreshold indicates the threshold exceeding which the
+ // dstCol.data capacity increase fold decreases from 2 to 1.5.
+ slowIncThreshold := 1024 * avgElemLen
+ if len(dstCol.data) < slowIncThreshold {
+ newCap = doubleCap
+ } else {
+ for 0 < newCap && newCap < needCap {
+ newCap += newCap / 2
+ }
+ if newCap <= 0 {
+ newCap = needCap
+ }
+ }
+ }
+ dstCol.data = make([]byte, len(dstCol.data)+elemLen, newCap)
+ }
+ return
+}
+
+// insert inserts `row` on the position specified by `rowIdx`.
+// NOTE: only used in test.
+// Note: Insert will cover the origin data, it should be called after
+// PreAlloc.
+func (c *Chunk) insert(rowIdx int, row Row) {
+ for i, srcCol := range row.c.columns {
+ if row.IsNull(i) {
+ continue
+ }
+ dstCol := c.columns[i]
+ var srcStart, srcEnd, destStart, destEnd int
+ if srcCol.isFixed() {
+ srcElemLen, destElemLen := len(srcCol.elemBuf), len(dstCol.elemBuf)
+ srcStart, destStart = row.idx*srcElemLen, rowIdx*destElemLen
+ srcEnd, destEnd = srcStart+srcElemLen, destStart+destElemLen
+ } else {
+ srcStart, srcEnd = int(srcCol.offsets[row.idx]), int(srcCol.offsets[row.idx+1])
+ destStart, destEnd = int(dstCol.offsets[rowIdx]), int(dstCol.offsets[rowIdx+1])
+ }
+ copy(dstCol.data[destStart:destEnd], srcCol.data[srcStart:srcEnd])
+ }
+}
+
+// Append appends rows in [begin, end) in another Chunk to a Chunk.
+func (c *Chunk) Append(other *Chunk, begin, end int) {
+ for colID, src := range other.columns {
+ dst := c.columns[colID]
+ if src.isFixed() {
+ elemLen := len(src.elemBuf)
+ dst.data = append(dst.data, src.data[begin*elemLen:end*elemLen]...)
+ } else {
+ beginOffset, endOffset := src.offsets[begin], src.offsets[end]
+ dst.data = append(dst.data, src.data[beginOffset:endOffset]...)
+ for i := begin; i < end; i++ {
+ dst.offsets = append(dst.offsets, dst.offsets[len(dst.offsets)-1]+src.offsets[i+1]-src.offsets[i])
+ }
+ }
+ for i := begin; i < end; i++ {
+ c.appendSel(colID)
+ dst.appendNullBitmap(!src.IsNull(i))
+ dst.length++
+ }
+ }
+ c.numVirtualRows += end - begin
+}
+
+// TruncateTo truncates rows from tail to head in a Chunk to "numRows" rows.
+func (c *Chunk) TruncateTo(numRows int) {
+ c.Reconstruct()
+ for _, col := range c.columns {
+ if col.isFixed() {
+ elemLen := len(col.elemBuf)
+ col.data = col.data[:numRows*elemLen]
+ } else {
+ col.data = col.data[:col.offsets[numRows]]
+ col.offsets = col.offsets[:numRows+1]
+ }
+ col.length = numRows
+ bitmapLen := (col.length + 7) / 8
+ col.nullBitmap = col.nullBitmap[:bitmapLen]
+ if col.length%8 != 0 {
+ // When we append null, we simply increment the nullCount,
+ // so we need to clear the unused bits in the last bitmap byte.
+ lastByte := col.nullBitmap[bitmapLen-1]
+ unusedBitsLen := 8 - uint(col.length%8)
+ lastByte <<= unusedBitsLen
+ lastByte >>= unusedBitsLen
+ col.nullBitmap[bitmapLen-1] = lastByte
+ }
+ }
+ c.numVirtualRows = numRows
+}
+
+// AppendNull appends a null value to the chunk.
+func (c *Chunk) AppendNull(colIdx int) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendNull()
+}
+
+// AppendInt64 appends a int64 value to the chunk.
+func (c *Chunk) AppendInt64(colIdx int, i int64) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendInt64(i)
+}
+
+// AppendUint64 appends a uint64 value to the chunk.
+func (c *Chunk) AppendUint64(colIdx int, u uint64) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendUint64(u)
+}
+
+// AppendFloat32 appends a float32 value to the chunk.
+func (c *Chunk) AppendFloat32(colIdx int, f float32) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendFloat32(f)
+}
+
+// AppendFloat64 appends a float64 value to the chunk.
+func (c *Chunk) AppendFloat64(colIdx int, f float64) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendFloat64(f)
+}
+
+// AppendString appends a string value to the chunk.
+func (c *Chunk) AppendString(colIdx int, str string) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendString(str)
+}
+
+// AppendBytes appends a bytes value to the chunk.
+func (c *Chunk) AppendBytes(colIdx int, b []byte) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendBytes(b)
+}
+
+// AppendTime appends a Time value to the chunk.
+func (c *Chunk) AppendTime(colIdx int, t types.Time) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendTime(t)
+}
+
+// AppendDuration appends a Duration value to the chunk.
+func (c *Chunk) AppendDuration(colIdx int, dur types.Duration) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendDuration(dur)
+}
+
+// AppendMyDecimal appends a MyDecimal value to the chunk.
+func (c *Chunk) AppendMyDecimal(colIdx int, dec *types.MyDecimal) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendMyDecimal(dec)
+}
+
+// AppendEnum appends an Enum value to the chunk.
+func (c *Chunk) AppendEnum(colIdx int, enum types.Enum) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].appendNameValue(enum.Name, enum.Value)
+}
+
+// AppendSet appends a Set value to the chunk.
+func (c *Chunk) AppendSet(colIdx int, set types.Set) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].appendNameValue(set.Name, set.Value)
+}
+
+// AppendJSON appends a JSON value to the chunk.
+func (c *Chunk) AppendJSON(colIdx int, j json.BinaryJSON) {
+ c.appendSel(colIdx)
+ c.columns[colIdx].AppendJSON(j)
+}
+
+func (c *Chunk) appendSel(colIdx int) {
+ if colIdx == 0 && c.sel != nil { // use column 0 as standard
+ c.sel = append(c.sel, c.columns[0].length)
+ }
+}
+
+// AppendDatum appends a datum into the chunk.
+func (c *Chunk) AppendDatum(colIdx int, d *types.Datum) {
+ switch d.Kind() {
+ case types.KindNull:
+ c.AppendNull(colIdx)
+ case types.KindInt64:
+ c.AppendInt64(colIdx, d.GetInt64())
+ case types.KindUint64:
+ c.AppendUint64(colIdx, d.GetUint64())
+ case types.KindFloat32:
+ c.AppendFloat32(colIdx, d.GetFloat32())
+ case types.KindFloat64:
+ c.AppendFloat64(colIdx, d.GetFloat64())
+ case types.KindString, types.KindBytes, types.KindBinaryLiteral, types.KindRaw, types.KindMysqlBit:
+ c.AppendBytes(colIdx, d.GetBytes())
+ case types.KindMysqlDecimal:
+ c.AppendMyDecimal(colIdx, d.GetMysqlDecimal())
+ case types.KindMysqlDuration:
+ c.AppendDuration(colIdx, d.GetMysqlDuration())
+ case types.KindMysqlEnum:
+ c.AppendEnum(colIdx, d.GetMysqlEnum())
+ case types.KindMysqlSet:
+ c.AppendSet(colIdx, d.GetMysqlSet())
+ case types.KindMysqlTime:
+ c.AppendTime(colIdx, d.GetMysqlTime())
+ case types.KindMysqlJSON:
+ c.AppendJSON(colIdx, d.GetMysqlJSON())
+ }
+}
+
+// Column returns the specific column.
+func (c *Chunk) Column(colIdx int) *Column {
+ return c.columns[colIdx]
+}
+
+// SetCol sets the colIdx Column to col and returns the old Column.
+func (c *Chunk) SetCol(colIdx int, col *Column) *Column {
+ if col == c.columns[colIdx] {
+ return nil
+ }
+ old := c.columns[colIdx]
+ c.columns[colIdx] = col
+ return old
+}
+
+// Sel returns Sel of this Chunk.
+func (c *Chunk) Sel() []int {
+ return c.sel
+}
+
+// SetSel sets a Sel for this Chunk.
+func (c *Chunk) SetSel(sel []int) {
+ c.sel = sel
+}
+
+// Reconstruct removes all filtered rows in this Chunk.
+func (c *Chunk) Reconstruct() {
+ if c.sel == nil {
+ return
+ }
+ for _, col := range c.columns {
+ col.reconstruct(c.sel)
+ }
+ c.numVirtualRows = len(c.sel)
+ c.sel = nil
+}
+
+// ToString returns all the values in a chunk.
+func (c *Chunk) ToString(ft []*types.FieldType) string {
+ var buf []byte
+ for rowIdx := 0; rowIdx < c.NumRows(); rowIdx++ {
+ row := c.GetRow(rowIdx)
+ buf = append(buf, row.ToString(ft)...)
+ buf = append(buf, '\n')
+ }
+ return string(buf)
+}
+
+// AppendRows appends multiple rows to the chunk.
+func (c *Chunk) AppendRows(rows []Row) {
+ c.AppendPartialRows(0, rows)
+ c.numVirtualRows += len(rows)
+}
+
+// AppendPartialRows appends multiple rows to the chunk.
+func (c *Chunk) AppendPartialRows(colOff int, rows []Row) {
+ columns := c.columns[colOff:]
+ for i, dstCol := range columns {
+ for _, srcRow := range rows {
+ if i == 0 {
+ c.appendSel(colOff)
+ }
+ appendCellByCell(dstCol, srcRow.c.columns[i], srcRow.idx)
+ }
+ }
+}
diff --git a/pkg/util/chunk/row.go b/pkg/util/chunk/row.go
new file mode 100644
index 0000000000000000000000000000000000000000..eb2ff6d6dfbe6c7df8435f4ed6a42f2c79c288a2
--- /dev/null
+++ b/pkg/util/chunk/row.go
@@ -0,0 +1,256 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chunk
+
+import (
+ "strconv"
+
+ "github.com/pingcap/parser/mysql"
+ "matrixbase/pkg/types"
+ "matrixbase/pkg/types/json"
+)
+
+// Row represents a row of data, can be used to access values.
+type Row struct {
+ c *Chunk
+ idx int
+}
+
+// Chunk returns the Chunk which the row belongs to.
+func (r Row) Chunk() *Chunk {
+ return r.c
+}
+
+// IsEmpty returns true if the Row is empty.
+func (r Row) IsEmpty() bool {
+ return r == Row{}
+}
+
+// Idx returns the row index of Chunk.
+func (r Row) Idx() int {
+ return r.idx
+}
+
+// Len returns the number of values in the row.
+func (r Row) Len() int {
+ return r.c.NumCols()
+}
+
+// GetInt64 returns the int64 value with the colIdx.
+func (r Row) GetInt64(colIdx int) int64 {
+ return r.c.columns[colIdx].GetInt64(r.idx)
+}
+
+// GetUint64 returns the uint64 value with the colIdx.
+func (r Row) GetUint64(colIdx int) uint64 {
+ return r.c.columns[colIdx].GetUint64(r.idx)
+}
+
+// GetFloat32 returns the float32 value with the colIdx.
+func (r Row) GetFloat32(colIdx int) float32 {
+ return r.c.columns[colIdx].GetFloat32(r.idx)
+}
+
+// GetFloat64 returns the float64 value with the colIdx.
+func (r Row) GetFloat64(colIdx int) float64 {
+ return r.c.columns[colIdx].GetFloat64(r.idx)
+}
+
+// GetString returns the string value with the colIdx.
+func (r Row) GetString(colIdx int) string {
+ return r.c.columns[colIdx].GetString(r.idx)
+}
+
+// GetBytes returns the bytes value with the colIdx.
+func (r Row) GetBytes(colIdx int) []byte {
+ return r.c.columns[colIdx].GetBytes(r.idx)
+}
+
+// GetTime returns the Time value with the colIdx.
+func (r Row) GetTime(colIdx int) types.Time {
+ return r.c.columns[colIdx].GetTime(r.idx)
+}
+
+// GetDuration returns the Duration value with the colIdx.
+func (r Row) GetDuration(colIdx int, fillFsp int) types.Duration {
+ return r.c.columns[colIdx].GetDuration(r.idx, fillFsp)
+}
+
+func (r Row) getNameValue(colIdx int) (string, uint64) {
+ return r.c.columns[colIdx].getNameValue(r.idx)
+}
+
+// GetEnum returns the Enum value with the colIdx.
+func (r Row) GetEnum(colIdx int) types.Enum {
+ return r.c.columns[colIdx].GetEnum(r.idx)
+}
+
+// GetSet returns the Set value with the colIdx.
+func (r Row) GetSet(colIdx int) types.Set {
+ return r.c.columns[colIdx].GetSet(r.idx)
+}
+
+// GetMyDecimal returns the MyDecimal value with the colIdx.
+func (r Row) GetMyDecimal(colIdx int) *types.MyDecimal {
+ return r.c.columns[colIdx].GetDecimal(r.idx)
+}
+
+// GetJSON returns the JSON value with the colIdx.
+func (r Row) GetJSON(colIdx int) json.BinaryJSON {
+ return r.c.columns[colIdx].GetJSON(r.idx)
+}
+
+// GetDatumRow converts chunk.Row to types.DatumRow.
+// Keep in mind that GetDatumRow has a reference to r.c, which is a chunk,
+// this function works only if the underlying chunk is valid or unchanged.
+func (r Row) GetDatumRow(fields []*types.FieldType) []types.Datum {
+ datumRow := make([]types.Datum, 0, r.c.NumCols())
+ for colIdx := 0; colIdx < r.c.NumCols(); colIdx++ {
+ datum := r.GetDatum(colIdx, fields[colIdx])
+ datumRow = append(datumRow, datum)
+ }
+ return datumRow
+}
+
+// GetDatum implements the chunk.Row interface.
+func (r Row) GetDatum(colIdx int, tp *types.FieldType) types.Datum {
+ var d types.Datum
+ switch tp.Tp {
+ case mysql.TypeTiny, mysql.TypeShort, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong:
+ if !r.IsNull(colIdx) {
+ if mysql.HasUnsignedFlag(tp.Flag) {
+ d.SetUint64(r.GetUint64(colIdx))
+ } else {
+ d.SetInt64(r.GetInt64(colIdx))
+ }
+ }
+ case mysql.TypeYear:
+ // FIXBUG: because insert type of TypeYear is definite int64, so we regardless of the unsigned flag.
+ if !r.IsNull(colIdx) {
+ d.SetInt64(r.GetInt64(colIdx))
+ }
+ case mysql.TypeFloat:
+ if !r.IsNull(colIdx) {
+ d.SetFloat32(r.GetFloat32(colIdx))
+ }
+ case mysql.TypeDouble:
+ if !r.IsNull(colIdx) {
+ d.SetFloat64(r.GetFloat64(colIdx))
+ }
+ case mysql.TypeVarchar, mysql.TypeVarString, mysql.TypeString, mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob:
+ if !r.IsNull(colIdx) {
+ d.SetString(r.GetString(colIdx), tp.Collate)
+ }
+ case mysql.TypeDate, mysql.TypeDatetime, mysql.TypeTimestamp:
+ if !r.IsNull(colIdx) {
+ d.SetMysqlTime(r.GetTime(colIdx))
+ }
+ case mysql.TypeDuration:
+ if !r.IsNull(colIdx) {
+ duration := r.GetDuration(colIdx, tp.Decimal)
+ d.SetMysqlDuration(duration)
+ }
+ case mysql.TypeNewDecimal:
+ if !r.IsNull(colIdx) {
+ d.SetMysqlDecimal(r.GetMyDecimal(colIdx))
+ d.SetLength(tp.Flen)
+ // If tp.Decimal is unspecified(-1), we should set it to the real
+ // fraction length of the decimal value, if not, the d.Frac will
+ // be set to MAX_UINT16 which will cause unexpected BadNumber error
+ // when encoding.
+ if tp.Decimal == types.UnspecifiedLength {
+ d.SetFrac(d.Frac())
+ } else {
+ d.SetFrac(tp.Decimal)
+ }
+ }
+ case mysql.TypeEnum:
+ if !r.IsNull(colIdx) {
+ d.SetMysqlEnum(r.GetEnum(colIdx), tp.Collate)
+ }
+ case mysql.TypeSet:
+ if !r.IsNull(colIdx) {
+ d.SetMysqlSet(r.GetSet(colIdx), tp.Collate)
+ }
+ case mysql.TypeBit:
+ if !r.IsNull(colIdx) {
+ d.SetMysqlBit(r.GetBytes(colIdx))
+ }
+ case mysql.TypeJSON:
+ if !r.IsNull(colIdx) {
+ d.SetMysqlJSON(r.GetJSON(colIdx))
+ }
+ }
+ return d
+}
+
+// GetRaw returns the underlying raw bytes with the colIdx.
+func (r Row) GetRaw(colIdx int) []byte {
+ return r.c.columns[colIdx].GetRaw(r.idx)
+}
+
+// IsNull returns if the datum in the chunk.Row is null.
+func (r Row) IsNull(colIdx int) bool {
+ return r.c.columns[colIdx].IsNull(r.idx)
+}
+
+// CopyConstruct creates a new row and copies this row's data into it.
+func (r Row) CopyConstruct() Row {
+ newChk := renewWithCapacity(r.c, 1, 1)
+ newChk.AppendRow(r)
+ return newChk.GetRow(0)
+}
+
+// ToString returns all the values in a row.
+func (r Row) ToString(ft []*types.FieldType) string {
+ var buf []byte
+ for colIdx := 0; colIdx < r.Chunk().NumCols(); colIdx++ {
+ if r.IsNull(colIdx) {
+ buf = append(buf, "nil, "...)
+ continue
+ }
+ switch ft[colIdx].EvalType() {
+ case types.ETInt:
+ buf = strconv.AppendInt(buf, r.GetInt64(colIdx), 10)
+ case types.ETString:
+ switch ft[colIdx].Tp {
+ case mysql.TypeEnum:
+ buf = append(buf, r.GetEnum(colIdx).String()...)
+ case mysql.TypeSet:
+ buf = append(buf, r.GetSet(colIdx).String()...)
+ default:
+ buf = append(buf, r.GetString(colIdx)...)
+ }
+ case types.ETDatetime, types.ETTimestamp:
+ buf = append(buf, r.GetTime(colIdx).String()...)
+ case types.ETDecimal:
+ buf = append(buf, r.GetMyDecimal(colIdx).ToString()...)
+ case types.ETDuration:
+ buf = append(buf, r.GetDuration(colIdx, ft[colIdx].Decimal).String()...)
+ case types.ETJson:
+ buf = append(buf, r.GetJSON(colIdx).String()...)
+ case types.ETReal:
+ switch ft[colIdx].Tp {
+ case mysql.TypeFloat:
+ buf = strconv.AppendFloat(buf, float64(r.GetFloat32(colIdx)), 'f', -1, 32)
+ case mysql.TypeDouble:
+ buf = strconv.AppendFloat(buf, r.GetFloat64(colIdx), 'f', -1, 64)
+ }
+ }
+ if colIdx != r.Chunk().NumCols()-1 {
+ buf = append(buf, ", "...)
+ }
+ }
+ return string(buf)
+}
diff --git a/pkg/util/collate/bin.go b/pkg/util/collate/bin.go
new file mode 100644
index 0000000000000000000000000000000000000000..7060da9d44e9a029eed97673614a1e01d5aa0b90
--- /dev/null
+++ b/pkg/util/collate/bin.go
@@ -0,0 +1,69 @@
+// Copyright 2020 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collate
+
+import (
+ "matrixbase/pkg/util/stringutil"
+ "strings"
+)
+
+type binCollator struct {
+}
+
+// Compare implement Collator interface.
+func (bc *binCollator) Compare(a, b string) int {
+ return strings.Compare(a, b)
+}
+
+// Key implement Collator interface.
+func (bc *binCollator) Key(str string) []byte {
+ return []byte(str)
+}
+
+// Pattern implements Collator interface.
+func (bc *binCollator) Pattern() WildcardPattern {
+ return &binPattern{}
+}
+
+type binPaddingCollator struct {
+}
+
+func (bpc *binPaddingCollator) Compare(a, b string) int {
+ return strings.Compare(truncateTailingSpace(a), truncateTailingSpace(b))
+}
+
+func (bpc *binPaddingCollator) Key(str string) []byte {
+ return []byte(truncateTailingSpace(str))
+}
+
+// Pattern implements Collator interface.
+// Notice that trailing spaces are significant.
+func (bpc *binPaddingCollator) Pattern() WildcardPattern {
+ return &binPattern{}
+}
+
+type binPattern struct {
+ patChars []rune
+ patTypes []byte
+}
+
+// Compile implements WildcardPattern interface.
+func (p *binPattern) Compile(patternStr string, escape byte) {
+ p.patChars, p.patTypes = stringutil.CompilePattern(patternStr, escape)
+}
+
+// Compile implements WildcardPattern interface.
+func (p *binPattern) DoMatch(str string) bool {
+ return stringutil.DoMatch(str, p.patChars, p.patTypes)
+}
diff --git a/pkg/util/collate/collate.go b/pkg/util/collate/collate.go
new file mode 100644
index 0000000000000000000000000000000000000000..d0f0f3a733058daee3776d809e873e7542e9430a
--- /dev/null
+++ b/pkg/util/collate/collate.go
@@ -0,0 +1,312 @@
+// Copyright 2020 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collate
+
+import (
+ "sort"
+ "sync/atomic"
+
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser/charset"
+ "github.com/pingcap/parser/mysql"
+ "github.com/pingcap/parser/terror"
+ "matrixbase/pkg/util/dbterror"
+ // "matrixbase/pkg/util/stringutil"
+ // "github.com/pingcap/tidb/util/logutil"
+ // "go.uber.org/zap"
+)
+
+var (
+ newCollatorMap map[string]Collator
+ newCollatorIDMap map[int]Collator
+ newCollationEnabled int32
+
+ // binCollatorInstance is a singleton used for all collations when newCollationEnabled is false.
+ binCollatorInstance = &binCollator{}
+
+ // ErrUnsupportedCollation is returned when an unsupported collation is specified.
+ ErrUnsupportedCollation = dbterror.ClassDDL.NewStdErr(mysql.ErrUnknownCollation, mysql.Message("Unsupported collation when new collation is enabled: '%-.64s'", nil))
+ // ErrIllegalMixCollation is returned when illegal mix of collations.
+ ErrIllegalMixCollation = dbterror.ClassExpression.NewStd(mysql.ErrCantAggregateNcollations)
+ // ErrIllegalMix2Collation is returned when illegal mix of 2 collations.
+ ErrIllegalMix2Collation = dbterror.ClassExpression.NewStd(mysql.ErrCantAggregate2collations)
+ // ErrIllegalMix3Collation is returned when illegal mix of 3 collations.
+ ErrIllegalMix3Collation = dbterror.ClassExpression.NewStd(mysql.ErrCantAggregate3collations)
+)
+
+const (
+ // DefaultLen is set for datum if the string datum don't know its length.
+ DefaultLen = 0
+ // first byte of a 2-byte encoding starts 110 and carries 5 bits of data
+ b2Mask = 0x1F // 0001 1111
+ // first byte of a 3-byte encoding starts 1110 and carries 4 bits of data
+ b3Mask = 0x0F // 0000 1111
+ // first byte of a 4-byte encoding starts 11110 and carries 3 bits of data
+ b4Mask = 0x07 // 0000 0111
+ // non-first bytes start 10 and carry 6 bits of data
+ mbMask = 0x3F // 0011 1111
+)
+
+// Collator provides functionality for comparing strings for a given
+// collation order.
+type Collator interface {
+ // Compare returns an integer comparing the two strings. The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
+ Compare(a, b string) int
+ // Key returns the collate key for str. If the collation is padding, make sure the PadLen >= len(rune[]str) in opt.
+ Key(str string) []byte
+ // Pattern get a collation-aware WildcardPattern.
+ Pattern() WildcardPattern
+}
+
+// WildcardPattern is the interface used for wildcard pattern match.
+type WildcardPattern interface {
+ // Compile compiles the patternStr with specified escape character.
+ Compile(patternStr string, escape byte)
+ // DoMatch tries to match the str with compiled pattern, `Compile()` must be called before calling it.
+ DoMatch(str string) bool
+}
+
+// EnableNewCollations enables the new collation.
+func EnableNewCollations() {
+ SetNewCollationEnabledForTest(true)
+}
+
+// SetNewCollationEnabledForTest sets if the new collation are enabled in test.
+// Note: Be careful to use this function, if this functions is used in tests, make sure the tests are serial.
+func SetNewCollationEnabledForTest(flag bool) {
+ if flag {
+ atomic.StoreInt32(&newCollationEnabled, 1)
+ return
+ }
+ atomic.StoreInt32(&newCollationEnabled, 0)
+}
+
+// NewCollationEnabled returns if the new collations are enabled.
+func NewCollationEnabled() bool {
+ return atomic.LoadInt32(&newCollationEnabled) == 1
+}
+
+// CompatibleCollate checks whether the two collate are the same.
+func CompatibleCollate(collate1, collate2 string) bool {
+ if (collate1 == "utf8mb4_general_ci" || collate1 == "utf8_general_ci") && (collate2 == "utf8mb4_general_ci" || collate2 == "utf8_general_ci") {
+ return true
+ } else if (collate1 == "utf8mb4_bin" || collate1 == "utf8_bin") && (collate2 == "utf8mb4_bin" || collate2 == "utf8_bin") {
+ return true
+ } else if (collate1 == "utf8mb4_unicode_ci" || collate1 == "utf8_unicode_ci") && (collate2 == "utf8mb4_unicode_ci" || collate2 == "utf8_unicode_ci") {
+ return true
+ } else {
+ return collate1 == collate2
+ }
+}
+
+// RewriteNewCollationIDIfNeeded rewrites a collation id if the new collations are enabled.
+// When new collations are enabled, we turn the collation id to negative so that other the
+// components of the cluster(for example, TiKV) is able to aware of it without any change to
+// the protocol definition.
+// When new collations are not enabled, collation id remains the same.
+func RewriteNewCollationIDIfNeeded(id int32) int32 {
+ if atomic.LoadInt32(&newCollationEnabled) == 1 {
+ if id < 0 {
+ // logutil.BgLogger().Warn("Unexpected negative collation ID for rewrite.", zap.Int32("ID", id))
+ } else {
+ return -id
+ }
+ }
+ return id
+}
+
+// RestoreCollationIDIfNeeded restores a collation id if the new collations are enabled.
+func RestoreCollationIDIfNeeded(id int32) int32 {
+ if atomic.LoadInt32(&newCollationEnabled) == 1 {
+ if id > 0 {
+ // logutil.BgLogger().Warn("Unexpected positive collation ID for restore.", zap.Int32("ID", id))
+ } else {
+ return -id
+ }
+ }
+ return id
+}
+
+// GetCollator get the collator according to collate, it will return the binary collator if the corresponding collator doesn't exist.
+func GetCollator(collate string) Collator {
+ if atomic.LoadInt32(&newCollationEnabled) == 1 {
+ ctor, ok := newCollatorMap[collate]
+ if !ok {
+ // logutil.BgLogger().Warn(
+ // "Unable to get collator by name, use binCollator instead.",
+ // zap.String("name", collate),
+ // zap.Stack("stack"))
+ return newCollatorMap["utf8mb4_bin"]
+ }
+ return ctor
+ }
+ return binCollatorInstance
+}
+
+// GetCollatorByID get the collator according to id, it will return the binary collator if the corresponding collator doesn't exist.
+func GetCollatorByID(id int) Collator {
+ if atomic.LoadInt32(&newCollationEnabled) == 1 {
+ ctor, ok := newCollatorIDMap[id]
+ if !ok {
+ // logutil.BgLogger().Warn(
+ // "Unable to get collator by ID, use binCollator instead.",
+ // zap.Int("ID", id),
+ // zap.Stack("stack"))
+ return newCollatorMap["utf8mb4_bin"]
+ }
+ return ctor
+ }
+ return binCollatorInstance
+}
+
+// CollationID2Name return the collation name by the given id.
+// If the id is not found in the map, the default collation is returned.
+func CollationID2Name(id int32) string {
+ collation, err := charset.GetCollationByID(int(id))
+ if err != nil {
+ // TODO(bb7133): fix repeating logs when the following code is uncommented.
+ // logutil.BgLogger().Warn(
+ // "Unable to get collation name from ID, use default collation instead.",
+ // zap.Int32("ID", id),
+ // zap.Stack("stack"))
+ return mysql.DefaultCollationName
+ }
+ return collation.Name
+}
+
+// CollationName2ID return the collation id by the given name.
+// If the name is not found in the map, the default collation id is returned
+func CollationName2ID(name string) int {
+ if coll, err := charset.GetCollationByName(name); err == nil {
+ return coll.ID
+ }
+ return mysql.DefaultCollationID
+}
+
+// GetCollationByName wraps charset.GetCollationByName, it checks the collation.
+func GetCollationByName(name string) (coll *charset.Collation, err error) {
+ if coll, err = charset.GetCollationByName(name); err != nil {
+ return nil, errors.Trace(err)
+ }
+ if atomic.LoadInt32(&newCollationEnabled) == 1 {
+ if _, ok := newCollatorIDMap[coll.ID]; !ok {
+ return nil, ErrUnsupportedCollation.GenWithStackByArgs(name)
+ }
+ }
+ return
+}
+
+// GetSupportedCollations gets information for all collations supported so far.
+func GetSupportedCollations() []*charset.Collation {
+ if atomic.LoadInt32(&newCollationEnabled) == 1 {
+ newSupportedCollations := make([]*charset.Collation, 0, len(newCollatorMap))
+ for name := range newCollatorMap {
+ if coll, err := charset.GetCollationByName(name); err != nil {
+ // Should never happens.
+ terror.Log(err)
+ } else {
+ newSupportedCollations = append(newSupportedCollations, coll)
+ }
+ }
+ sort.Slice(newSupportedCollations, func(i int, j int) bool {
+ return newSupportedCollations[i].Name < newSupportedCollations[j].Name
+ })
+ return newSupportedCollations
+ }
+ return charset.GetSupportedCollations()
+}
+
+func truncateTailingSpace(str string) string {
+ byteLen := len(str)
+ i := byteLen - 1
+ for ; i >= 0; i-- {
+ if str[i] != ' ' {
+ break
+ }
+ }
+ str = str[:i+1]
+ return str
+}
+
+func sign(i int) int {
+ if i < 0 {
+ return -1
+ } else if i > 0 {
+ return 1
+ }
+ return 0
+}
+
+// decode rune by hand
+func decodeRune(s string, si int) (r rune, newIndex int) {
+ switch b := s[si]; {
+ case b < 0x80:
+ r = rune(b)
+ newIndex = si + 1
+ case b < 0xE0:
+ r = rune(b&b2Mask)<<6 |
+ rune(s[1+si]&mbMask)
+ newIndex = si + 2
+ case b < 0xF0:
+ r = rune(b&b3Mask)<<12 |
+ rune(s[si+1]&mbMask)<<6 |
+ rune(s[si+2]&mbMask)
+ newIndex = si + 3
+ default:
+ r = rune(b&b4Mask)<<18 |
+ rune(s[si+1]&mbMask)<<12 |
+ rune(s[si+2]&mbMask)<<6 |
+ rune(s[si+3]&mbMask)
+ newIndex = si + 4
+ }
+ return
+}
+
+// IsCICollation returns if the collation is case-sensitive
+func IsCICollation(collate string) bool {
+ return collate == "utf8_general_ci" || collate == "utf8mb4_general_ci" ||
+ collate == "utf8_unicode_ci" || collate == "utf8mb4_unicode_ci"
+}
+
+// IsBinCollation returns if the collation is 'xx_bin'
+func IsBinCollation(collate string) bool {
+ return collate == "ascii_bin" || collate == "latin1_bin" ||
+ collate == "utf8_bin" || collate == "utf8mb4_bin"
+}
+
+func init() {
+ newCollatorMap = make(map[string]Collator)
+ newCollatorIDMap = make(map[int]Collator)
+
+ newCollatorMap["binary"] = &binCollator{}
+ newCollatorIDMap[CollationName2ID("binary")] = &binCollator{}
+ newCollatorMap["ascii_bin"] = &binPaddingCollator{}
+ newCollatorIDMap[CollationName2ID("ascii_bin")] = &binPaddingCollator{}
+ newCollatorMap["latin1_bin"] = &binPaddingCollator{}
+ newCollatorIDMap[CollationName2ID("latin1_bin")] = &binPaddingCollator{}
+ newCollatorMap["utf8mb4_bin"] = &binPaddingCollator{}
+ newCollatorIDMap[CollationName2ID("utf8mb4_bin")] = &binPaddingCollator{}
+ newCollatorMap["utf8_bin"] = &binPaddingCollator{}
+ newCollatorIDMap[CollationName2ID("utf8_bin")] = &binPaddingCollator{}
+ newCollatorMap["utf8mb4_general_ci"] = &generalCICollator{}
+ newCollatorIDMap[CollationName2ID("utf8mb4_general_ci")] = &generalCICollator{}
+ newCollatorMap["utf8_general_ci"] = &generalCICollator{}
+ newCollatorIDMap[CollationName2ID("utf8_general_ci")] = &generalCICollator{}
+ newCollatorMap["utf8mb4_unicode_ci"] = &unicodeCICollator{}
+ newCollatorIDMap[CollationName2ID("utf8mb4_unicode_ci")] = &unicodeCICollator{}
+ newCollatorMap["utf8_unicode_ci"] = &unicodeCICollator{}
+ newCollatorIDMap[CollationName2ID("utf8_unicode_ci")] = &unicodeCICollator{}
+ newCollatorMap["utf8mb4_zh_pinyin_tidb_as_cs"] = &zhPinyinTiDBASCSCollator{}
+ newCollatorIDMap[CollationName2ID("utf8mb4_zh_pinyin_tidb_as_cs")] = &zhPinyinTiDBASCSCollator{}
+}
diff --git a/pkg/util/collate/collate_bench_test.go b/pkg/util/collate/collate_bench_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9195019a0703661f387e78739c1f06206d9e97d2
--- /dev/null
+++ b/pkg/util/collate/collate_bench_test.go
@@ -0,0 +1,113 @@
+package collate
+
+import (
+ "math/rand"
+ "testing"
+
+ _ "net/http/pprof"
+)
+
+const short = 2 << 4
+const middle = 2 << 10
+const long = 2 << 20
+
+func generateData(length int) string {
+ rs := []rune("ßss")
+ r := make([]rune, length)
+ for i := range r {
+ r[i] = rs[rand.Intn(len(rs))]
+ }
+
+ return string(r)
+}
+
+func compare(b *testing.B, collator Collator, length int) {
+ s1 := generateData(length)
+ s2 := generateData(length)
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ collator.Compare(s1, s2)
+ }
+}
+
+func key(b *testing.B, collator Collator, length int) {
+ s := generateData(length)
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ collator.Key(s)
+ }
+}
+
+func BenchmarkUtf8mb4Bin_CompareShort(b *testing.B) {
+ compare(b, &binCollator{}, short)
+}
+
+func BenchmarkUtf8mb4GeneralCI_CompareShort(b *testing.B) {
+ compare(b, &generalCICollator{}, short)
+}
+
+func BenchmarkUtf8mb4UnicodeCI_CompareShort(b *testing.B) {
+ compare(b, &unicodeCICollator{}, short)
+}
+
+func BenchmarkUtf8mb4Bin_CompareMid(b *testing.B) {
+ compare(b, &binCollator{}, middle)
+}
+
+func BenchmarkUtf8mb4GeneralCI_CompareMid(b *testing.B) {
+ compare(b, &generalCICollator{}, middle)
+}
+
+func BenchmarkUtf8mb4UnicodeCI_CompareMid(b *testing.B) {
+ compare(b, &unicodeCICollator{}, middle)
+}
+
+func BenchmarkUtf8mb4Bin_CompareLong(b *testing.B) {
+ compare(b, &binCollator{}, long)
+}
+
+func BenchmarkUtf8mb4GeneralCI_CompareLong(b *testing.B) {
+ compare(b, &generalCICollator{}, long)
+}
+
+func BenchmarkUtf8mb4UnicodeCI_CompareLong(b *testing.B) {
+ compare(b, &unicodeCICollator{}, long)
+}
+
+func BenchmarkUtf8mb4Bin_KeyShort(b *testing.B) {
+ key(b, &binCollator{}, short)
+}
+
+func BenchmarkUtf8mb4GeneralCI_KeyShort(b *testing.B) {
+ key(b, &generalCICollator{}, short)
+}
+
+func BenchmarkUtf8mb4UnicodeCI_KeyShort(b *testing.B) {
+ key(b, &unicodeCICollator{}, short)
+}
+
+func BenchmarkUtf8mb4Bin_KeyMid(b *testing.B) {
+ key(b, &binCollator{}, middle)
+}
+
+func BenchmarkUtf8mb4GeneralCI_KeyMid(b *testing.B) {
+ key(b, &generalCICollator{}, middle)
+}
+
+func BenchmarkUtf8mb4UnicodeCI_KeyMid(b *testing.B) {
+ key(b, &unicodeCICollator{}, middle)
+}
+
+func BenchmarkUtf8mb4Bin_KeyLong(b *testing.B) {
+ key(b, &binCollator{}, long)
+}
+
+func BenchmarkUtf8mb4GeneralCI_KeyLong(b *testing.B) {
+ key(b, &generalCICollator{}, long)
+}
+
+func BenchmarkUtf8mb4UnicodeCI_KeyLong(b *testing.B) {
+ key(b, &unicodeCICollator{}, long)
+}
diff --git a/pkg/util/collate/general_ci.go b/pkg/util/collate/general_ci.go
new file mode 100644
index 0000000000000000000000000000000000000000..c54c4b829c596ca24241b9d05e7ba6af1a39dbe9
--- /dev/null
+++ b/pkg/util/collate/general_ci.go
@@ -0,0 +1,317 @@
+// Copyright 2020 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collate
+
+import (
+ "matrixbase/pkg/util/stringutil"
+)
+
+type generalCICollator struct {
+}
+
+// Compare implements Collator interface.
+func (gc *generalCICollator) Compare(a, b string) int {
+ a = truncateTailingSpace(a)
+ b = truncateTailingSpace(b)
+ r1, r2 := rune(0), rune(0)
+ ai, bi := 0, 0
+ for ai < len(a) && bi < len(b) {
+ r1, ai = decodeRune(a, ai)
+ r2, bi = decodeRune(b, bi)
+
+ cmp := int(convertRuneGeneralCI(r1)) - int(convertRuneGeneralCI(r2))
+ if cmp != 0 {
+ return sign(cmp)
+ }
+ }
+ return sign((len(a) - ai) - (len(b) - bi))
+}
+
+// Key implements Collator interface.
+func (gc *generalCICollator) Key(str string) []byte {
+ str = truncateTailingSpace(str)
+ buf := make([]byte, 0, len(str))
+ i := 0
+ r := rune(0)
+ for i < len(str) {
+ r, i = decodeRune(str, i)
+ u16 := convertRuneGeneralCI(r)
+ buf = append(buf, byte(u16>>8), byte(u16))
+ }
+ return buf
+}
+
+// Pattern implements Collator interface.
+func (gc *generalCICollator) Pattern() WildcardPattern {
+ return &ciPattern{}
+}
+
+type ciPattern struct {
+ patChars []rune
+ patTypes []byte
+}
+
+// Compile implements WildcardPattern interface.
+func (p *ciPattern) Compile(patternStr string, escape byte) {
+ p.patChars, p.patTypes = stringutil.CompilePatternInner(patternStr, escape)
+}
+
+// Compile implements WildcardPattern interface.
+func (p *ciPattern) DoMatch(str string) bool {
+ return stringutil.DoMatchInner(str, p.patChars, p.patTypes, func(a, b rune) bool {
+ return convertRuneGeneralCI(a) == convertRuneGeneralCI(b)
+ })
+}
+
+func convertRuneGeneralCI(r rune) uint16 {
+ if r > 0xFFFF {
+ return 0xFFFD
+ }
+ plane := planeTable[r>>8]
+ if plane == nil {
+ return uint16(r)
+ }
+ return plane[r&0xFF]
+}
+
+var (
+ plane00 = []uint16{
+ 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+ 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+ 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+ 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+ 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+ 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+ 0x0060, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+ 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+ 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+ 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+ 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x039C, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+ 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x00C6, 0x0043, 0x0045, 0x0045, 0x0045, 0x0045, 0x0049, 0x0049, 0x0049, 0x0049,
+ 0x00D0, 0x004E, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x00D7, 0x00D8, 0x0055, 0x0055, 0x0055, 0x0055, 0x0059, 0x00DE, 0x0053,
+ 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x00C6, 0x0043, 0x0045, 0x0045, 0x0045, 0x0045, 0x0049, 0x0049, 0x0049, 0x0049,
+ 0x00D0, 0x004E, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x00F7, 0x00D8, 0x0055, 0x0055, 0x0055, 0x0055, 0x0059, 0x00DE, 0x0059}
+
+ plane01 = []uint16{
+ 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0043, 0x0043, 0x0043, 0x0043, 0x0043, 0x0043, 0x0043, 0x0043, 0x0044, 0x0044,
+ 0x0110, 0x0110, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0047, 0x0047, 0x0047, 0x0047,
+ 0x0047, 0x0047, 0x0047, 0x0047, 0x0048, 0x0048, 0x0126, 0x0126, 0x0049, 0x0049, 0x0049, 0x0049, 0x0049, 0x0049, 0x0049, 0x0049,
+ 0x0049, 0x0049, 0x0132, 0x0132, 0x004A, 0x004A, 0x004B, 0x004B, 0x0138, 0x004C, 0x004C, 0x004C, 0x004C, 0x004C, 0x004C, 0x013F,
+ 0x013F, 0x0141, 0x0141, 0x004E, 0x004E, 0x004E, 0x004E, 0x004E, 0x004E, 0x0149, 0x014A, 0x014A, 0x004F, 0x004F, 0x004F, 0x004F,
+ 0x004F, 0x004F, 0x0152, 0x0152, 0x0052, 0x0052, 0x0052, 0x0052, 0x0052, 0x0052, 0x0053, 0x0053, 0x0053, 0x0053, 0x0053, 0x0053,
+ 0x0053, 0x0053, 0x0054, 0x0054, 0x0054, 0x0054, 0x0166, 0x0166, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055,
+ 0x0055, 0x0055, 0x0055, 0x0055, 0x0057, 0x0057, 0x0059, 0x0059, 0x0059, 0x005A, 0x005A, 0x005A, 0x005A, 0x005A, 0x005A, 0x0053,
+ 0x0180, 0x0181, 0x0182, 0x0182, 0x0184, 0x0184, 0x0186, 0x0187, 0x0187, 0x0189, 0x018A, 0x018B, 0x018B, 0x018D, 0x018E, 0x018F,
+ 0x0190, 0x0191, 0x0191, 0x0193, 0x0194, 0x01F6, 0x0196, 0x0197, 0x0198, 0x0198, 0x019A, 0x019B, 0x019C, 0x019D, 0x019E, 0x019F,
+ 0x004F, 0x004F, 0x01A2, 0x01A2, 0x01A4, 0x01A4, 0x01A6, 0x01A7, 0x01A7, 0x01A9, 0x01AA, 0x01AB, 0x01AC, 0x01AC, 0x01AE, 0x0055,
+ 0x0055, 0x01B1, 0x01B2, 0x01B3, 0x01B3, 0x01B5, 0x01B5, 0x01B7, 0x01B8, 0x01B8, 0x01BA, 0x01BB, 0x01BC, 0x01BC, 0x01BE, 0x01F7,
+ 0x01C0, 0x01C1, 0x01C2, 0x01C3, 0x01C4, 0x01C4, 0x01C4, 0x01C7, 0x01C7, 0x01C7, 0x01CA, 0x01CA, 0x01CA, 0x0041, 0x0041, 0x0049,
+ 0x0049, 0x004F, 0x004F, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x018E, 0x0041, 0x0041,
+ 0x0041, 0x0041, 0x00C6, 0x00C6, 0x01E4, 0x01E4, 0x0047, 0x0047, 0x004B, 0x004B, 0x004F, 0x004F, 0x004F, 0x004F, 0x01B7, 0x01B7,
+ 0x004A, 0x01F1, 0x01F1, 0x01F1, 0x0047, 0x0047, 0x01F6, 0x01F7, 0x004E, 0x004E, 0x0041, 0x0041, 0x00C6, 0x00C6, 0x00D8, 0x00D8}
+
+ plane02 = []uint16{
+ 0x0041, 0x0041, 0x0041, 0x0041, 0x0045, 0x0045, 0x0045, 0x0045, 0x0049, 0x0049, 0x0049, 0x0049, 0x004F, 0x004F, 0x004F, 0x004F,
+ 0x0052, 0x0052, 0x0052, 0x0052, 0x0055, 0x0055, 0x0055, 0x0055, 0x0053, 0x0053, 0x0054, 0x0054, 0x021C, 0x021C, 0x0048, 0x0048,
+ 0x0220, 0x0221, 0x0222, 0x0222, 0x0224, 0x0224, 0x0041, 0x0041, 0x0045, 0x0045, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F,
+ 0x004F, 0x004F, 0x0059, 0x0059, 0x0234, 0x0235, 0x0236, 0x0237, 0x0238, 0x0239, 0x023A, 0x023B, 0x023C, 0x023D, 0x023E, 0x023F,
+ 0x0240, 0x0241, 0x0242, 0x0243, 0x0244, 0x0245, 0x0246, 0x0247, 0x0248, 0x0249, 0x024A, 0x024B, 0x024C, 0x024D, 0x024E, 0x024F,
+ 0x0250, 0x0251, 0x0252, 0x0181, 0x0186, 0x0255, 0x0189, 0x018A, 0x0258, 0x018F, 0x025A, 0x0190, 0x025C, 0x025D, 0x025E, 0x025F,
+ 0x0193, 0x0261, 0x0262, 0x0194, 0x0264, 0x0265, 0x0266, 0x0267, 0x0197, 0x0196, 0x026A, 0x026B, 0x026C, 0x026D, 0x026E, 0x019C,
+ 0x0270, 0x0271, 0x019D, 0x0273, 0x0274, 0x019F, 0x0276, 0x0277, 0x0278, 0x0279, 0x027A, 0x027B, 0x027C, 0x027D, 0x027E, 0x027F,
+ 0x01A6, 0x0281, 0x0282, 0x01A9, 0x0284, 0x0285, 0x0286, 0x0287, 0x01AE, 0x0289, 0x01B1, 0x01B2, 0x028C, 0x028D, 0x028E, 0x028F,
+ 0x0290, 0x0291, 0x01B7, 0x0293, 0x0294, 0x0295, 0x0296, 0x0297, 0x0298, 0x0299, 0x029A, 0x029B, 0x029C, 0x029D, 0x029E, 0x029F,
+ 0x02A0, 0x02A1, 0x02A2, 0x02A3, 0x02A4, 0x02A5, 0x02A6, 0x02A7, 0x02A8, 0x02A9, 0x02AA, 0x02AB, 0x02AC, 0x02AD, 0x02AE, 0x02AF,
+ 0x02B0, 0x02B1, 0x02B2, 0x02B3, 0x02B4, 0x02B5, 0x02B6, 0x02B7, 0x02B8, 0x02B9, 0x02BA, 0x02BB, 0x02BC, 0x02BD, 0x02BE, 0x02BF,
+ 0x02C0, 0x02C1, 0x02C2, 0x02C3, 0x02C4, 0x02C5, 0x02C6, 0x02C7, 0x02C8, 0x02C9, 0x02CA, 0x02CB, 0x02CC, 0x02CD, 0x02CE, 0x02CF,
+ 0x02D0, 0x02D1, 0x02D2, 0x02D3, 0x02D4, 0x02D5, 0x02D6, 0x02D7, 0x02D8, 0x02D9, 0x02DA, 0x02DB, 0x02DC, 0x02DD, 0x02DE, 0x02DF,
+ 0x02E0, 0x02E1, 0x02E2, 0x02E3, 0x02E4, 0x02E5, 0x02E6, 0x02E7, 0x02E8, 0x02E9, 0x02EA, 0x02EB, 0x02EC, 0x02ED, 0x02EE, 0x02EF,
+ 0x02F0, 0x02F1, 0x02F2, 0x02F3, 0x02F4, 0x02F5, 0x02F6, 0x02F7, 0x02F8, 0x02F9, 0x02FA, 0x02FB, 0x02FC, 0x02FD, 0x02FE, 0x02FF}
+
+ plane03 = []uint16{
+ 0x0300, 0x0301, 0x0302, 0x0303, 0x0304, 0x0305, 0x0306, 0x0307, 0x0308, 0x0309, 0x030A, 0x030B, 0x030C, 0x030D, 0x030E, 0x030F,
+ 0x0310, 0x0311, 0x0312, 0x0313, 0x0314, 0x0315, 0x0316, 0x0317, 0x0318, 0x0319, 0x031A, 0x031B, 0x031C, 0x031D, 0x031E, 0x031F,
+ 0x0320, 0x0321, 0x0322, 0x0323, 0x0324, 0x0325, 0x0326, 0x0327, 0x0328, 0x0329, 0x032A, 0x032B, 0x032C, 0x032D, 0x032E, 0x032F,
+ 0x0330, 0x0331, 0x0332, 0x0333, 0x0334, 0x0335, 0x0336, 0x0337, 0x0338, 0x0339, 0x033A, 0x033B, 0x033C, 0x033D, 0x033E, 0x033F,
+ 0x0340, 0x0341, 0x0342, 0x0343, 0x0344, 0x0399, 0x0346, 0x0347, 0x0348, 0x0349, 0x034A, 0x034B, 0x034C, 0x034D, 0x034E, 0x034F,
+ 0x0350, 0x0351, 0x0352, 0x0353, 0x0354, 0x0355, 0x0356, 0x0357, 0x0358, 0x0359, 0x035A, 0x035B, 0x035C, 0x035D, 0x035E, 0x035F,
+ 0x0360, 0x0361, 0x0362, 0x0363, 0x0364, 0x0365, 0x0366, 0x0367, 0x0368, 0x0369, 0x036A, 0x036B, 0x036C, 0x036D, 0x036E, 0x036F,
+ 0x0370, 0x0371, 0x0372, 0x0373, 0x0374, 0x0375, 0x0376, 0x0377, 0x0378, 0x0379, 0x037A, 0x037B, 0x037C, 0x037D, 0x037E, 0x037F,
+ 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0391, 0x0387, 0x0395, 0x0397, 0x0399, 0x038B, 0x039F, 0x038D, 0x03A5, 0x03A9,
+ 0x0399, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
+ 0x03A0, 0x03A1, 0x03A2, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x0399, 0x03A5, 0x0391, 0x0395, 0x0397, 0x0399,
+ 0x03A5, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
+ 0x03A0, 0x03A1, 0x03A3, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x0399, 0x03A5, 0x039F, 0x03A5, 0x03A9, 0x03CF,
+ 0x0392, 0x0398, 0x03D2, 0x03D2, 0x03D2, 0x03A6, 0x03A0, 0x03D7, 0x03D8, 0x03D9, 0x03DA, 0x03DA, 0x03DC, 0x03DC, 0x03DE, 0x03DE,
+ 0x03E0, 0x03E0, 0x03E2, 0x03E2, 0x03E4, 0x03E4, 0x03E6, 0x03E6, 0x03E8, 0x03E8, 0x03EA, 0x03EA, 0x03EC, 0x03EC, 0x03EE, 0x03EE,
+ 0x039A, 0x03A1, 0x03A3, 0x03F3, 0x03F4, 0x03F5, 0x03F6, 0x03F7, 0x03F8, 0x03F9, 0x03FA, 0x03FB, 0x03FC, 0x03FD, 0x03FE, 0x03FF}
+
+ plane04 = []uint16{
+ 0x0415, 0x0415, 0x0402, 0x0413, 0x0404, 0x0405, 0x0406, 0x0406, 0x0408, 0x0409, 0x040A, 0x040B, 0x041A, 0x0418, 0x0423, 0x040F,
+ 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+ 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+ 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+ 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+ 0x0415, 0x0415, 0x0402, 0x0413, 0x0404, 0x0405, 0x0406, 0x0406, 0x0408, 0x0409, 0x040A, 0x040B, 0x041A, 0x0418, 0x0423, 0x040F,
+ 0x0460, 0x0460, 0x0462, 0x0462, 0x0464, 0x0464, 0x0466, 0x0466, 0x0468, 0x0468, 0x046A, 0x046A, 0x046C, 0x046C, 0x046E, 0x046E,
+ 0x0470, 0x0470, 0x0472, 0x0472, 0x0474, 0x0474, 0x0474, 0x0474, 0x0478, 0x0478, 0x047A, 0x047A, 0x047C, 0x047C, 0x047E, 0x047E,
+ 0x0480, 0x0480, 0x0482, 0x0483, 0x0484, 0x0485, 0x0486, 0x0487, 0x0488, 0x0489, 0x048A, 0x048B, 0x048C, 0x048C, 0x048E, 0x048E,
+ 0x0490, 0x0490, 0x0492, 0x0492, 0x0494, 0x0494, 0x0496, 0x0496, 0x0498, 0x0498, 0x049A, 0x049A, 0x049C, 0x049C, 0x049E, 0x049E,
+ 0x04A0, 0x04A0, 0x04A2, 0x04A2, 0x04A4, 0x04A4, 0x04A6, 0x04A6, 0x04A8, 0x04A8, 0x04AA, 0x04AA, 0x04AC, 0x04AC, 0x04AE, 0x04AE,
+ 0x04B0, 0x04B0, 0x04B2, 0x04B2, 0x04B4, 0x04B4, 0x04B6, 0x04B6, 0x04B8, 0x04B8, 0x04BA, 0x04BA, 0x04BC, 0x04BC, 0x04BE, 0x04BE,
+ 0x04C0, 0x0416, 0x0416, 0x04C3, 0x04C3, 0x04C5, 0x04C6, 0x04C7, 0x04C7, 0x04C9, 0x04CA, 0x04CB, 0x04CB, 0x04CD, 0x04CE, 0x04CF,
+ 0x0410, 0x0410, 0x0410, 0x0410, 0x04D4, 0x04D4, 0x0415, 0x0415, 0x04D8, 0x04D8, 0x04D8, 0x04D8, 0x0416, 0x0416, 0x0417, 0x0417,
+ 0x04E0, 0x04E0, 0x0418, 0x0418, 0x0418, 0x0418, 0x041E, 0x041E, 0x04E8, 0x04E8, 0x04E8, 0x04E8, 0x042D, 0x042D, 0x0423, 0x0423,
+ 0x0423, 0x0423, 0x0423, 0x0423, 0x0427, 0x0427, 0x04F6, 0x04F7, 0x042B, 0x042B, 0x04FA, 0x04FB, 0x04FC, 0x04FD, 0x04FE, 0x04FF}
+
+ plane05 = []uint16{
+ 0x0500, 0x0501, 0x0502, 0x0503, 0x0504, 0x0505, 0x0506, 0x0507, 0x0508, 0x0509, 0x050A, 0x050B, 0x050C, 0x050D, 0x050E, 0x050F,
+ 0x0510, 0x0511, 0x0512, 0x0513, 0x0514, 0x0515, 0x0516, 0x0517, 0x0518, 0x0519, 0x051A, 0x051B, 0x051C, 0x051D, 0x051E, 0x051F,
+ 0x0520, 0x0521, 0x0522, 0x0523, 0x0524, 0x0525, 0x0526, 0x0527, 0x0528, 0x0529, 0x052A, 0x052B, 0x052C, 0x052D, 0x052E, 0x052F,
+ 0x0530, 0x0531, 0x0532, 0x0533, 0x0534, 0x0535, 0x0536, 0x0537, 0x0538, 0x0539, 0x053A, 0x053B, 0x053C, 0x053D, 0x053E, 0x053F,
+ 0x0540, 0x0541, 0x0542, 0x0543, 0x0544, 0x0545, 0x0546, 0x0547, 0x0548, 0x0549, 0x054A, 0x054B, 0x054C, 0x054D, 0x054E, 0x054F,
+ 0x0550, 0x0551, 0x0552, 0x0553, 0x0554, 0x0555, 0x0556, 0x0557, 0x0558, 0x0559, 0x055A, 0x055B, 0x055C, 0x055D, 0x055E, 0x055F,
+ 0x0560, 0x0531, 0x0532, 0x0533, 0x0534, 0x0535, 0x0536, 0x0537, 0x0538, 0x0539, 0x053A, 0x053B, 0x053C, 0x053D, 0x053E, 0x053F,
+ 0x0540, 0x0541, 0x0542, 0x0543, 0x0544, 0x0545, 0x0546, 0x0547, 0x0548, 0x0549, 0x054A, 0x054B, 0x054C, 0x054D, 0x054E, 0x054F,
+ 0x0550, 0x0551, 0x0552, 0x0553, 0x0554, 0x0555, 0x0556, 0x0587, 0x0588, 0x0589, 0x058A, 0x058B, 0x058C, 0x058D, 0x058E, 0x058F,
+ 0x0590, 0x0591, 0x0592, 0x0593, 0x0594, 0x0595, 0x0596, 0x0597, 0x0598, 0x0599, 0x059A, 0x059B, 0x059C, 0x059D, 0x059E, 0x059F,
+ 0x05A0, 0x05A1, 0x05A2, 0x05A3, 0x05A4, 0x05A5, 0x05A6, 0x05A7, 0x05A8, 0x05A9, 0x05AA, 0x05AB, 0x05AC, 0x05AD, 0x05AE, 0x05AF,
+ 0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7, 0x05B8, 0x05B9, 0x05BA, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
+ 0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05C4, 0x05C5, 0x05C6, 0x05C7, 0x05C8, 0x05C9, 0x05CA, 0x05CB, 0x05CC, 0x05CD, 0x05CE, 0x05CF,
+ 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
+ 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA, 0x05EB, 0x05EC, 0x05ED, 0x05EE, 0x05EF,
+ 0x05F0, 0x05F1, 0x05F2, 0x05F3, 0x05F4, 0x05F5, 0x05F6, 0x05F7, 0x05F8, 0x05F9, 0x05FA, 0x05FB, 0x05FC, 0x05FD, 0x05FE, 0x05FF}
+
+ plane1E = []uint16{
+ 0x0041, 0x0041, 0x0042, 0x0042, 0x0042, 0x0042, 0x0042, 0x0042, 0x0043, 0x0043, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044, 0x0044,
+ 0x0044, 0x0044, 0x0044, 0x0044, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0046, 0x0046,
+ 0x0047, 0x0047, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0049, 0x0049, 0x0049, 0x0049,
+ 0x004B, 0x004B, 0x004B, 0x004B, 0x004B, 0x004B, 0x004C, 0x004C, 0x004C, 0x004C, 0x004C, 0x004C, 0x004C, 0x004C, 0x004D, 0x004D,
+ 0x004D, 0x004D, 0x004D, 0x004D, 0x004E, 0x004E, 0x004E, 0x004E, 0x004E, 0x004E, 0x004E, 0x004E, 0x004F, 0x004F, 0x004F, 0x004F,
+ 0x004F, 0x004F, 0x004F, 0x004F, 0x0050, 0x0050, 0x0050, 0x0050, 0x0052, 0x0052, 0x0052, 0x0052, 0x0052, 0x0052, 0x0052, 0x0052,
+ 0x0053, 0x0053, 0x0053, 0x0053, 0x0053, 0x0053, 0x0053, 0x0053, 0x0053, 0x0053, 0x0054, 0x0054, 0x0054, 0x0054, 0x0054, 0x0054,
+ 0x0054, 0x0054, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0056, 0x0056, 0x0056, 0x0056,
+ 0x0057, 0x0057, 0x0057, 0x0057, 0x0057, 0x0057, 0x0057, 0x0057, 0x0057, 0x0057, 0x0058, 0x0058, 0x0058, 0x0058, 0x0059, 0x0059,
+ 0x005A, 0x005A, 0x005A, 0x005A, 0x005A, 0x005A, 0x0048, 0x0054, 0x0057, 0x0059, 0x1E9A, 0x0053, 0x1E9C, 0x1E9D, 0x1E9E, 0x1E9F,
+ 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041,
+ 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045,
+ 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0045, 0x0049, 0x0049, 0x0049, 0x0049, 0x004F, 0x004F, 0x004F, 0x004F,
+ 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F, 0x004F,
+ 0x004F, 0x004F, 0x004F, 0x004F, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055,
+ 0x0055, 0x0055, 0x0059, 0x0059, 0x0059, 0x0059, 0x0059, 0x0059, 0x0059, 0x0059, 0x1EFA, 0x1EFB, 0x1EFC, 0x1EFD, 0x1EFE, 0x1EFF}
+
+ plane1F = []uint16{
+ 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391,
+ 0x0395, 0x0395, 0x0395, 0x0395, 0x0395, 0x0395, 0x1F16, 0x1F17, 0x0395, 0x0395, 0x0395, 0x0395, 0x0395, 0x0395, 0x1F1E, 0x1F1F,
+ 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397,
+ 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399,
+ 0x039F, 0x039F, 0x039F, 0x039F, 0x039F, 0x039F, 0x1F46, 0x1F47, 0x039F, 0x039F, 0x039F, 0x039F, 0x039F, 0x039F, 0x1F4E, 0x1F4F,
+ 0x03A5, 0x03A5, 0x03A5, 0x03A5, 0x03A5, 0x03A5, 0x03A5, 0x03A5, 0x1F58, 0x03A5, 0x1F5A, 0x03A5, 0x1F5C, 0x03A5, 0x1F5E, 0x03A5,
+ 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9,
+ 0x0391, 0x1FBB, 0x0395, 0x1FC9, 0x0397, 0x1FCB, 0x0399, 0x1FDB, 0x039F, 0x1FF9, 0x03A5, 0x1FEB, 0x03A9, 0x1FFB, 0x1F7E, 0x1F7F,
+ 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391,
+ 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397, 0x0397,
+ 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9, 0x03A9,
+ 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x1FB5, 0x0391, 0x0391, 0x0391, 0x0391, 0x0391, 0x1FBB, 0x0391, 0x1FBD, 0x0399, 0x1FBF,
+ 0x1FC0, 0x1FC1, 0x0397, 0x0397, 0x0397, 0x1FC5, 0x0397, 0x0397, 0x0395, 0x1FC9, 0x0397, 0x1FCB, 0x0397, 0x1FCD, 0x1FCE, 0x1FCF,
+ 0x0399, 0x0399, 0x0399, 0x1FD3, 0x1FD4, 0x1FD5, 0x0399, 0x0399, 0x0399, 0x0399, 0x0399, 0x1FDB, 0x1FDC, 0x1FDD, 0x1FDE, 0x1FDF,
+ 0x03A5, 0x03A5, 0x03A5, 0x1FE3, 0x03A1, 0x03A1, 0x03A5, 0x03A5, 0x03A5, 0x03A5, 0x03A5, 0x1FEB, 0x03A1, 0x1FED, 0x1FEE, 0x1FEF,
+ 0x1FF0, 0x1FF1, 0x03A9, 0x03A9, 0x03A9, 0x1FF5, 0x03A9, 0x03A9, 0x039F, 0x1FF9, 0x03A9, 0x1FFB, 0x03A9, 0x1FFD, 0x1FFE, 0x1FFF}
+
+ plane21 = []uint16{
+ 0x2100, 0x2101, 0x2102, 0x2103, 0x2104, 0x2105, 0x2106, 0x2107, 0x2108, 0x2109, 0x210A, 0x210B, 0x210C, 0x210D, 0x210E, 0x210F,
+ 0x2110, 0x2111, 0x2112, 0x2113, 0x2114, 0x2115, 0x2116, 0x2117, 0x2118, 0x2119, 0x211A, 0x211B, 0x211C, 0x211D, 0x211E, 0x211F,
+ 0x2120, 0x2121, 0x2122, 0x2123, 0x2124, 0x2125, 0x2126, 0x2127, 0x2128, 0x2129, 0x212A, 0x212B, 0x212C, 0x212D, 0x212E, 0x212F,
+ 0x2130, 0x2131, 0x2132, 0x2133, 0x2134, 0x2135, 0x2136, 0x2137, 0x2138, 0x2139, 0x213A, 0x213B, 0x213C, 0x213D, 0x213E, 0x213F,
+ 0x2140, 0x2141, 0x2142, 0x2143, 0x2144, 0x2145, 0x2146, 0x2147, 0x2148, 0x2149, 0x214A, 0x214B, 0x214C, 0x214D, 0x214E, 0x214F,
+ 0x2150, 0x2151, 0x2152, 0x2153, 0x2154, 0x2155, 0x2156, 0x2157, 0x2158, 0x2159, 0x215A, 0x215B, 0x215C, 0x215D, 0x215E, 0x215F,
+ 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F,
+ 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F,
+ 0x2180, 0x2181, 0x2182, 0x2183, 0x2184, 0x2185, 0x2186, 0x2187, 0x2188, 0x2189, 0x218A, 0x218B, 0x218C, 0x218D, 0x218E, 0x218F,
+ 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x2196, 0x2197, 0x2198, 0x2199, 0x219A, 0x219B, 0x219C, 0x219D, 0x219E, 0x219F,
+ 0x21A0, 0x21A1, 0x21A2, 0x21A3, 0x21A4, 0x21A5, 0x21A6, 0x21A7, 0x21A8, 0x21A9, 0x21AA, 0x21AB, 0x21AC, 0x21AD, 0x21AE, 0x21AF,
+ 0x21B0, 0x21B1, 0x21B2, 0x21B3, 0x21B4, 0x21B5, 0x21B6, 0x21B7, 0x21B8, 0x21B9, 0x21BA, 0x21BB, 0x21BC, 0x21BD, 0x21BE, 0x21BF,
+ 0x21C0, 0x21C1, 0x21C2, 0x21C3, 0x21C4, 0x21C5, 0x21C6, 0x21C7, 0x21C8, 0x21C9, 0x21CA, 0x21CB, 0x21CC, 0x21CD, 0x21CE, 0x21CF,
+ 0x21D0, 0x21D1, 0x21D2, 0x21D3, 0x21D4, 0x21D5, 0x21D6, 0x21D7, 0x21D8, 0x21D9, 0x21DA, 0x21DB, 0x21DC, 0x21DD, 0x21DE, 0x21DF,
+ 0x21E0, 0x21E1, 0x21E2, 0x21E3, 0x21E4, 0x21E5, 0x21E6, 0x21E7, 0x21E8, 0x21E9, 0x21EA, 0x21EB, 0x21EC, 0x21ED, 0x21EE, 0x21EF,
+ 0x21F0, 0x21F1, 0x21F2, 0x21F3, 0x21F4, 0x21F5, 0x21F6, 0x21F7, 0x21F8, 0x21F9, 0x21FA, 0x21FB, 0x21FC, 0x21FD, 0x21FE, 0x21FF}
+
+ plane24 = []uint16{
+ 0x2400, 0x2401, 0x2402, 0x2403, 0x2404, 0x2405, 0x2406, 0x2407, 0x2408, 0x2409, 0x240A, 0x240B, 0x240C, 0x240D, 0x240E, 0x240F,
+ 0x2410, 0x2411, 0x2412, 0x2413, 0x2414, 0x2415, 0x2416, 0x2417, 0x2418, 0x2419, 0x241A, 0x241B, 0x241C, 0x241D, 0x241E, 0x241F,
+ 0x2420, 0x2421, 0x2422, 0x2423, 0x2424, 0x2425, 0x2426, 0x2427, 0x2428, 0x2429, 0x242A, 0x242B, 0x242C, 0x242D, 0x242E, 0x242F,
+ 0x2430, 0x2431, 0x2432, 0x2433, 0x2434, 0x2435, 0x2436, 0x2437, 0x2438, 0x2439, 0x243A, 0x243B, 0x243C, 0x243D, 0x243E, 0x243F,
+ 0x2440, 0x2441, 0x2442, 0x2443, 0x2444, 0x2445, 0x2446, 0x2447, 0x2448, 0x2449, 0x244A, 0x244B, 0x244C, 0x244D, 0x244E, 0x244F,
+ 0x2450, 0x2451, 0x2452, 0x2453, 0x2454, 0x2455, 0x2456, 0x2457, 0x2458, 0x2459, 0x245A, 0x245B, 0x245C, 0x245D, 0x245E, 0x245F,
+ 0x2460, 0x2461, 0x2462, 0x2463, 0x2464, 0x2465, 0x2466, 0x2467, 0x2468, 0x2469, 0x246A, 0x246B, 0x246C, 0x246D, 0x246E, 0x246F,
+ 0x2470, 0x2471, 0x2472, 0x2473, 0x2474, 0x2475, 0x2476, 0x2477, 0x2478, 0x2479, 0x247A, 0x247B, 0x247C, 0x247D, 0x247E, 0x247F,
+ 0x2480, 0x2481, 0x2482, 0x2483, 0x2484, 0x2485, 0x2486, 0x2487, 0x2488, 0x2489, 0x248A, 0x248B, 0x248C, 0x248D, 0x248E, 0x248F,
+ 0x2490, 0x2491, 0x2492, 0x2493, 0x2494, 0x2495, 0x2496, 0x2497, 0x2498, 0x2499, 0x249A, 0x249B, 0x249C, 0x249D, 0x249E, 0x249F,
+ 0x24A0, 0x24A1, 0x24A2, 0x24A3, 0x24A4, 0x24A5, 0x24A6, 0x24A7, 0x24A8, 0x24A9, 0x24AA, 0x24AB, 0x24AC, 0x24AD, 0x24AE, 0x24AF,
+ 0x24B0, 0x24B1, 0x24B2, 0x24B3, 0x24B4, 0x24B5, 0x24B6, 0x24B7, 0x24B8, 0x24B9, 0x24BA, 0x24BB, 0x24BC, 0x24BD, 0x24BE, 0x24BF,
+ 0x24C0, 0x24C1, 0x24C2, 0x24C3, 0x24C4, 0x24C5, 0x24C6, 0x24C7, 0x24C8, 0x24C9, 0x24CA, 0x24CB, 0x24CC, 0x24CD, 0x24CE, 0x24CF,
+ 0x24B6, 0x24B7, 0x24B8, 0x24B9, 0x24BA, 0x24BB, 0x24BC, 0x24BD, 0x24BE, 0x24BF, 0x24C0, 0x24C1, 0x24C2, 0x24C3, 0x24C4, 0x24C5,
+ 0x24C6, 0x24C7, 0x24C8, 0x24C9, 0x24CA, 0x24CB, 0x24CC, 0x24CD, 0x24CE, 0x24CF, 0x24EA, 0x24EB, 0x24EC, 0x24ED, 0x24EE, 0x24EF,
+ 0x24F0, 0x24F1, 0x24F2, 0x24F3, 0x24F4, 0x24F5, 0x24F6, 0x24F7, 0x24F8, 0x24F9, 0x24FA, 0x24FB, 0x24FC, 0x24FD, 0x24FE, 0x24FF}
+
+ planeFF = []uint16{
+ 0xFF00, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F,
+ 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F,
+ 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F,
+ 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F,
+ 0xFF40, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F,
+ 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E, 0xFF5F,
+ 0xFF60, 0xFF61, 0xFF62, 0xFF63, 0xFF64, 0xFF65, 0xFF66, 0xFF67, 0xFF68, 0xFF69, 0xFF6A, 0xFF6B, 0xFF6C, 0xFF6D, 0xFF6E, 0xFF6F,
+ 0xFF70, 0xFF71, 0xFF72, 0xFF73, 0xFF74, 0xFF75, 0xFF76, 0xFF77, 0xFF78, 0xFF79, 0xFF7A, 0xFF7B, 0xFF7C, 0xFF7D, 0xFF7E, 0xFF7F,
+ 0xFF80, 0xFF81, 0xFF82, 0xFF83, 0xFF84, 0xFF85, 0xFF86, 0xFF87, 0xFF88, 0xFF89, 0xFF8A, 0xFF8B, 0xFF8C, 0xFF8D, 0xFF8E, 0xFF8F,
+ 0xFF90, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95, 0xFF96, 0xFF97, 0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D, 0xFF9E, 0xFF9F,
+ 0xFFA0, 0xFFA1, 0xFFA2, 0xFFA3, 0xFFA4, 0xFFA5, 0xFFA6, 0xFFA7, 0xFFA8, 0xFFA9, 0xFFAA, 0xFFAB, 0xFFAC, 0xFFAD, 0xFFAE, 0xFFAF,
+ 0xFFB0, 0xFFB1, 0xFFB2, 0xFFB3, 0xFFB4, 0xFFB5, 0xFFB6, 0xFFB7, 0xFFB8, 0xFFB9, 0xFFBA, 0xFFBB, 0xFFBC, 0xFFBD, 0xFFBE, 0xFFBF,
+ 0xFFC0, 0xFFC1, 0xFFC2, 0xFFC3, 0xFFC4, 0xFFC5, 0xFFC6, 0xFFC7, 0xFFC8, 0xFFC9, 0xFFCA, 0xFFCB, 0xFFCC, 0xFFCD, 0xFFCE, 0xFFCF,
+ 0xFFD0, 0xFFD1, 0xFFD2, 0xFFD3, 0xFFD4, 0xFFD5, 0xFFD6, 0xFFD7, 0xFFD8, 0xFFD9, 0xFFDA, 0xFFDB, 0xFFDC, 0xFFDD, 0xFFDE, 0xFFDF,
+ 0xFFE0, 0xFFE1, 0xFFE2, 0xFFE3, 0xFFE4, 0xFFE5, 0xFFE6, 0xFFE7, 0xFFE8, 0xFFE9, 0xFFEA, 0xFFEB, 0xFFEC, 0xFFED, 0xFFEE, 0xFFEF,
+ 0xFFF0, 0xFFF1, 0xFFF2, 0xFFF3, 0xFFF4, 0xFFF5, 0xFFF6, 0xFFF7, 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF}
+
+ planeTable = [][]uint16{
+ plane00, plane01, plane02, plane03, plane04, plane05, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, plane1E, plane1F, nil, plane21, nil, nil,
+ plane24, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, nil, nil, nil, nil, nil, nil,
+ nil, nil, nil, planeFF}
+)
diff --git a/pkg/util/collate/pinyin_tidb_as_cs.go b/pkg/util/collate/pinyin_tidb_as_cs.go
new file mode 100644
index 0000000000000000000000000000000000000000..565680e2cff5613f4d4b56901ba01112e06bef51
--- /dev/null
+++ b/pkg/util/collate/pinyin_tidb_as_cs.go
@@ -0,0 +1,33 @@
+// Copyright 2020 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collate
+
+// Collation of utf8mb4_zh_pinyin_tidb_as_cs
+type zhPinyinTiDBASCSCollator struct {
+}
+
+// Collator interface, no implements now.
+func (py *zhPinyinTiDBASCSCollator) Compare(a, b string) int {
+ panic("implement me")
+}
+
+// Collator interface, no implements now.
+func (py *zhPinyinTiDBASCSCollator) Key(str string) []byte {
+ panic("implement me")
+}
+
+// Collator interface, no implements now.
+func (py *zhPinyinTiDBASCSCollator) Pattern() WildcardPattern {
+ panic("implement me")
+}
diff --git a/pkg/util/collate/unicode_ci.go b/pkg/util/collate/unicode_ci.go
new file mode 100644
index 0000000000000000000000000000000000000000..2605492eaaa3ab61b5e7e904a9cd1bdb0a0d4248
--- /dev/null
+++ b/pkg/util/collate/unicode_ci.go
@@ -0,0 +1,154 @@
+// Copyright 2020 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collate
+
+import (
+ "matrixbase/pkg/util/stringutil"
+)
+
+const (
+ // magic number indicate weight has 2 uint64, should get from `longRuneMap`
+ longRune uint64 = 0xFFFD
+)
+
+// unicodeCICollator implements UCA. see http://unicode.org/reports/tr10/
+type unicodeCICollator struct {
+}
+
+// Compare implements Collator interface.
+func (uc *unicodeCICollator) Compare(a, b string) int {
+ a = truncateTailingSpace(a)
+ b = truncateTailingSpace(b)
+ // weight of a, b. weight in unicode_ci may has 8 uint16s. xn indicate first 4 u16s, xs indicate last 4 u16s
+ an, bn := uint64(0), uint64(0)
+ as, bs := uint64(0), uint64(0)
+ // rune of a, b
+ ar, br := rune(0), rune(0)
+ // decode index of a, b
+ ai, bi := 0, 0
+ for {
+ if an == 0 {
+ if as == 0 {
+ for an == 0 && ai < len(a) {
+ ar, ai = decodeRune(a, ai)
+ an, as = convertRuneUnicodeCI(ar)
+ }
+ } else {
+ an = as
+ as = 0
+ }
+ }
+
+ if bn == 0 {
+ if bs == 0 {
+ for bn == 0 && bi < len(b) {
+ br, bi = decodeRune(b, bi)
+ bn, bs = convertRuneUnicodeCI(br)
+ }
+ } else {
+ bn = bs
+ bs = 0
+ }
+ }
+
+ if an == 0 || bn == 0 {
+ return sign(int(an) - int(bn))
+ }
+
+ if an == bn {
+ an, bn = 0, 0
+ continue
+ }
+
+ for an != 0 && bn != 0 {
+ if (an^bn)&0xFFFF == 0 {
+ an >>= 16
+ bn >>= 16
+ } else {
+ return sign(int(an&0xFFFF) - int(bn&0xFFFF))
+ }
+ }
+ }
+}
+
+// Key implements Collator interface.
+func (uc *unicodeCICollator) Key(str string) []byte {
+ str = truncateTailingSpace(str)
+ buf := make([]byte, 0, len(str)*2)
+ r := rune(0)
+ si := 0 // decode index of s
+ sn, ss := uint64(0), uint64(0) // weight of str. weight in unicode_ci may has 8 uint16s. sn indicate first 4 u16s, ss indicate last 4 u16s
+
+ for si < len(str) {
+ r, si = decodeRune(str, si)
+ sn, ss = convertRuneUnicodeCI(r)
+ for sn != 0 {
+ buf = append(buf, byte((sn&0xFF00)>>8), byte(sn))
+ sn >>= 16
+ }
+ for ss != 0 {
+ buf = append(buf, byte((ss&0xFF00)>>8), byte(ss))
+ ss >>= 16
+ }
+ }
+ return buf
+}
+
+// convert rune to weights.
+// `first` represent first 4 uint16 weights of rune
+// `second` represent last 4 uint16 weights of rune if exist, 0 if not
+func convertRuneUnicodeCI(r rune) (first, second uint64) {
+ if r > 0xFFFF {
+ return 0xFFFD, 0
+ }
+ if mapTable[r] == longRune {
+ return longRuneMap[r][0], longRuneMap[r][1]
+ }
+ return mapTable[r], 0
+}
+
+// Pattern implements Collator interface.
+func (uc *unicodeCICollator) Pattern() WildcardPattern {
+ return &unicodePattern{}
+}
+
+type unicodePattern struct {
+ patChars []rune
+ patTypes []byte
+}
+
+// Compile implements WildcardPattern interface.
+func (p *unicodePattern) Compile(patternStr string, escape byte) {
+ p.patChars, p.patTypes = stringutil.CompilePatternInner(patternStr, escape)
+}
+
+// DoMatch implements WildcardPattern interface.
+func (p *unicodePattern) DoMatch(str string) bool {
+ return stringutil.DoMatchInner(str, p.patChars, p.patTypes, func(a, b rune) bool {
+ if a > 0xFFFF || b > 0xFFFF {
+ return a == b
+ }
+
+ ar, br := mapTable[a], mapTable[b]
+ if ar != br {
+ return false
+ }
+
+ if ar == longRune {
+ return a == b
+ }
+
+ return true
+ })
+}
diff --git a/pkg/util/collate/unicode_ci_data.go b/pkg/util/collate/unicode_ci_data.go
new file mode 100644
index 0000000000000000000000000000000000000000..5248c02a96732f584eedec3be04cd4165dbfcf9f
--- /dev/null
+++ b/pkg/util/collate/unicode_ci_data.go
@@ -0,0 +1,394 @@
+// Copyright 2020 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collate
+
+/* Data from allkeys.txt(http://www.unicode.org/Public/UCA/4.0.0/allkeys-4.0.0.txt). Unicode version '4.0.0'. Do not EDIT */
+var (
+ mapTable = []uint64{
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x201, 0x202, 0x203, 0x204, 0x205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x209, 0x251, 0x27E, 0x2D2, 0xE0F, 0x2D3, 0x2CF, 0x277, 0x288, 0x289, 0x2C8, 0x428, 0x22F, 0x221, 0x25D, 0x2CC, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x23D, 0x23A, 0x42C, 0x42D, 0x42E, 0x255, 0x2C7, 0xE33, 0xE4A, 0xE60, 0xE6D, 0xE8B, 0xEB9, 0xEC1, 0xEE1, 0xEFB, 0xF10, 0xF21, 0xF2E, 0xF5B, 0xF64, 0xF82, 0xFA7, 0xFB4, 0xFC0, 0xFEA, 0x1002, 0x101F, 0x1044, 0x1051, 0x105A, 0x105E, 0x106A, 0x28A, 0x2CE, 0x28B, 0x20F, 0x21B, 0x20C, 0xE33, 0xE4A, 0xE60, 0xE6D, 0xE8B, 0xEB9, 0xEC1, 0xEE1, 0xEFB, 0xF10, 0xF21, 0xF2E, 0xF5B, 0xF64, 0xF82, 0xFA7, 0xFB4, 0xFC0, 0xFEA, 0x1002, 0x101F, 0x1044, 0x1051, 0x105A, 0x105E, 0x106A, 0x28C, 0x430, 0x28D, 0x433, 0, 0, 0, 0, 0, 0, 0x206, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x209, 0x252, 0xE0E, 0xE10, 0xE0D, 0xE11, 0x431, 0x2C2, 0x214, 0x2C5, 0xE33, 0x286, 0x42F, 0x220, 0x2C6, 0x210, 0x34A, 0x429, 0xE2B, 0xE2C, 0x20D, 0x10F8, 0x2C3, 0x267, 0x219, 0xE2A, 0xF82, 0x287, 0xE2D02CD0E2A, 0xE2B02CD0E2A, 0xE2D02CD0E2C, 0x256, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE38, 0xE60, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xE86, 0xF64, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0x42B, 0xF8D, 0x101F, 0x101F, 0x101F, 0x101F, 0x105E, 0x1094, 0xFEA0FEA, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE38, 0xE60, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xE86, 0xF64, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0x42A, 0xF8D, 0x101F, 0x101F, 0x101F, 0x101F, 0x105E, 0x1094, 0x105E, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE60, 0xE60, 0xE60, 0xE60, 0xE60, 0xE60, 0xE60, 0xE60, 0xE6D, 0xE6D, 0xE72, 0xE72, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xEC1, 0xEC1, 0xEC1, 0xEC1, 0xEC1, 0xEC1, 0xEC1, 0xEC1, 0xEE1, 0xEE1, 0xEED, 0xEED, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xEFF, 0xF100EFB, 0xF100EFB, 0xF10, 0xF10, 0xF21, 0xF21, 0xFBC, 0xF2E, 0xF2E, 0xF2E, 0xF2E, /* 0000 */
+ 0xF2E, 0xF2E, 0x2670F2E, 0x2670F2E, 0xF36, 0xF36, 0xF64, 0xF64, 0xF64, 0xF64, 0xF64, 0xF64, 0xF6410B1, 0xF7E, 0xF7E, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xE8B0F82, 0xE8B0F82, 0xFC0, 0xFC0, 0xFC0, 0xFC0, 0xFC0, 0xFC0, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0x1002, 0x1002, 0x1002, 0x1002, 0x1007, 0x1007, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x1051, 0x1051, 0x105E, 0x105E, 0x105E, 0x106A, 0x106A, 0x106A, 0x106A, 0x106A, 0x106A, 0xFEA, 0xE52, 0xE58, 0xE5C, 0xE5C, 0x10A8, 0x10A8, 0xF92, 0xE65, 0xE65, 0xE76, 0xE7A, 0xE7E, 0xE7E, 0x1051106A, 0xE90, 0xE94, 0xE98, 0xEBD, 0xEBD, 0xED1, 0xED9, 0xEE9, 0xF0C, 0xF08, 0xF26, 0xF26, 0xF3B, 0xF53, 0x1037, 0xF6E, 0xF72, 0xF9A, 0xF82, 0xF82, 0xEDD, 0xEDD, 0xFAC, 0xFAC, 0xFC4, 0x10A0, 0x10A0, 0xFF2, 0xFF6, 0x100B, 0x100F, 0x100F, 0x1013, 0x101F, 0x101F, 0x1040, 0x1049, 0x1066, 0x1066, 0x106F, 0x106F, 0x107F, 0x1084, 0x1084, 0x1088, 0x109C, 0x10A4, 0x10A4, 0xFEA1002, 0x1098, 0x10C8, 0x10CC, 0x10D0, 0x10D4, 0x106A0E6D, 0x106A0E6D, 0x106A0E6D, 0xF100F2E, 0xF100F2E, 0xF100F2E, 0xF100F64, 0xF100F64, 0xF100F64, 0xE33, 0xE33, 0xEFB, 0xEFB, 0xF82, 0xF82, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0xE90, 0xE33, 0xE33, 0xE33, 0xE33, 0xE38, 0xE38, 0xECD, 0xECD, 0xEC1, 0xEC1, 0xF21, 0xF21, 0xF82, 0xF82, 0xF82, 0xF82, 0x107F, 0x107F, 0xF10, 0x106A0E6D, 0x106A0E6D, 0x106A0E6D, 0xEC1, 0xEC1, 0xEE9, 0x1098, 0xF64, 0xF64, 0xE33, 0xE33, 0xE38, 0xE38, 0xF8D, 0xF8D, 0xE33, 0xE33, 0xE33, 0xE33, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xF82, 0xF82, 0xF82, 0xF82, 0xFC0, 0xFC0, 0xFC0, 0xFC0, 0x101F, 0x101F, 0x101F, 0x101F, 0xFEA, 0xFEA, 0x1002, 0x1002, 0x1090, 0x1090, 0xEE1, 0xEE1, 0xF72, 0xE82, 0xFA2, 0xFA2, 0x1073, 0x1073, 0xE33, 0xE33, 0xE8B, 0xE8B, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0x105E, 0x105E, 0xF4B, 0xF7A, 0x1017, 0x8237FBC0, 0x8238FBC0, 0x8239FBC0, 0x823AFBC0, 0x823BFBC0, 0x823CFBC0, 0x823DFBC0, 0x823EFBC0, 0x823FFBC0, 0x8240FBC0, /* 013D */
+ 0x8241FBC0, 0x8242FBC0, 0x8243FBC0, 0x8244FBC0, 0x8245FBC0, 0x8246FBC0, 0x8247FBC0, 0x8248FBC0, 0x8249FBC0, 0x824AFBC0, 0x824BFBC0, 0x824CFBC0, 0x824DFBC0, 0x824EFBC0, 0x824FFBC0, 0xE3E, 0xE42, 0xE46, 0xE58, 0xF92, 0xE69, 0xE76, 0xE7A, 0xE9C, 0xE94, 0xEA0, 0xE98, 0xEA4, 0xEA9, 0xEAD, 0xF19, 0xED1, 0xEC5, 0xEC9, 0xED9, 0xEB5, 0x102B, 0xEF1, 0xEF5, 0xF08, 0xF0C, 0xF03, 0xF3F, 0xF43, 0xF47, 0xF4F, 0x1037, 0x103C, 0xF60, 0xF6E, 0xF76, 0xF68, 0xF9A, 0xF88, 0xF9E, 0xFB0, 0xFC9, 0xFCE, 0xFD2, 0xFD6, 0xFDA, 0xFDE, 0xFE2, 0xFC4, 0xFE6, 0xFEE, 0xFF2, 0xF1D, 0xFFA, 0xFFE, 0x101B, 0x1013, 0x1027, 0x1040, 0x1049, 0x104D, 0x1056, 0xF57, 0x1062, 0x1077, 0x107B, 0x107F, 0x108C, 0x10AC, 0x10B4, 0x10C4, 0x10D8, 0x10DC, 0xE4E, 0xEB1, 0xED5, 0xEE5, 0xF15, 0xF2A, 0xF32, 0xFB8, 0x10BC, 0x10C0, 0x106A0E6D, 0x107F0E6D, 0x107B0E6D, 0xFEA1002, 0xFF21002, 0xE691002, 0xF7E0EB9, 0xFEA0F2E, 0x106A0F2E, 0x10E0, 0x10E4, 0x102F, 0x1033, 0xEE1, 0xEF1, 0xF10, 0xFC0, 0xFC9, 0xFD2, 0xFE6, 0x1051, 0x105E, 0x317, 0x319, 0xEF9, 0x10B1, 0xEFA, 0x10B3, 0x10B8, 0x10B0, 0x10B9, 0x31A, 0x31B, 0x31C, 0x31D, 0x31E, 0x31F, 0x320, 0x321, 0x322, 0x323, 0x324, 0x325, 0x326, 0x327, 0xE01, 0xE02, 0x328, 0x329, 0x32A, 0x32B, 0x32C, 0x32D, 0x212, 0x213, 0x215, 0x21A, 0x20E, 0x216, 0x32E, 0x32F, 0xED9, 0xF2E, 0xFEA, 0x105A, 0x10B4, 0x330, 0x331, 0x332, 0x333, 0x334, 0x335, 0x336, 0x337, 0x338, 0x10B2, 0x339, 0x33A, 0x33B, 0x33C, 0x33D, 0x33E, 0x33F, 0x340, 0x341, 0x342, 0x343, 0x344, 0x345, 0x346, 0x347, 0x348, 0x349, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x8358FBC0, 0x8359FBC0, 0x835AFBC0, 0x835BFBC0, 0x835CFBC0, 0, 0, 0, 0, 0, 0, 0xE33, 0xE8B, 0xEFB, 0xF82, 0x101F, 0xE60, 0xE6D, 0xEE1, 0xF5B, 0xFC0, 0x1002, 0x1044, 0x105A, 0x8370FBC0, 0x8371FBC0, 0x8372FBC0, 0x8373FBC0, 0x317, 0x318, 0x8376FBC0, 0x8377FBC0, 0x8378FBC0, 0x8379FBC0, 0x10F3, /* 0241 */
+ 0x837BFBC0, 0x837CFBC0, 0x837DFBC0, 0x23A, 0x837FFBC0, 0x8380FBC0, 0x8381FBC0, 0x8382FBC0, 0x8383FBC0, 0x20D, 0x214, 0x10E8, 0x267, 0x10ED, 0x10F1, 0x10F3, 0x838BFBC0, 0x10FB, 0x838DFBC0, 0x1104, 0x1109, 0x10F3, 0x10E8, 0x10E9, 0x10EA, 0x10EC, 0x10ED, 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F5, 0x10F6, 0x10F8, 0x10F9, 0x10FA, 0x10FB, 0x10FC, 0x1100, 0x83A2FBC0, 0x1102, 0x1103, 0x1104, 0x1105, 0x1106, 0x1107, 0x1109, 0x10F3, 0x1104, 0x10E8, 0x10ED, 0x10F1, 0x10F3, 0x1104, 0x10E8, 0x10E9, 0x10EA, 0x10EC, 0x10ED, 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F5, 0x10F6, 0x10F8, 0x10F9, 0x10FA, 0x10FB, 0x10FC, 0x1100, 0x1102, 0x1102, 0x1103, 0x1104, 0x1105, 0x1106, 0x1107, 0x1109, 0x10F3, 0x1104, 0x10FB, 0x1104, 0x1109, 0x83CFFBC0, 0x10E9, 0x10F2, 0x1104, 0x1104, 0x1104, 0x1105, 0x10FC, 0x10F310E810F5, 0x10FF, 0x10FF, 0x10EF, 0x10EF, 0x10EE, 0x10EE, 0x10FE, 0x10FE, 0x110A, 0x110A, 0x110D, 0x110D, 0x110E, 0x110E, 0x110F, 0x110F, 0x1110, 0x1110, 0x1111, 0x1111, 0x1112, 0x1112, 0x1113, 0x1113, 0x10F5, 0x1100, 0x1102, 0x10F4, 0x10F2, 0x10ED, 0x423, 0x110B, 0x110B, 0x1102, 0x110C, 0x110C, 0x83FCFBC0, 0x83FDFBC0, 0x83FEFBC0, 0x83FFFBC0, 0x1152, 0x1152, 0x1145, 0x114A, 0x115A, 0x1173, 0x1188, 0x118C, 0x1194, 0x11B9, 0x11DA, 0x1215, 0x1219, 0x117C, 0x1221, 0x127D, 0x1114, 0x112C, 0x1130, 0x1134, 0x1140, 0x1152, 0x115E, 0x116A, 0x117C, 0x1190, 0x1198, 0x11B0, 0x11BE, 0x11C6, 0x11DF, 0x11EF, 0x11FB, 0x1203, 0x120C, 0x121D, 0x1239, 0x123D, 0x1259, 0x1261, 0x1281, 0x1285, 0x1289, 0x128D, 0x1295, 0x12A1, 0x12A9, 0x12AD, 0x1114, 0x112C, 0x1130, 0x1134, 0x1140, 0x1152, 0x115E, 0x116A, 0x117C, 0x1190, 0x1198, 0x11B0, 0x11BE, 0x11C6, 0x11DF, 0x11EF, 0x11FB, 0x1203, 0x120C, 0x121D, 0x1239, 0x123D, 0x1259, 0x1261, 0x1281, 0x1285, 0x1289, 0x128D, 0x1295, 0x12A1, 0x12A9, 0x12AD, 0x1152, 0x1152, 0x1145, 0x114A, 0x115A, 0x1173, 0x1188, 0x118C, 0x1194, 0x11B9, 0x11DA, 0x1215, 0x1219, 0x117C, 0x1221, 0x127D, 0x1249, 0x1249, 0x129D, 0x129D, 0x12B1, 0x12B1, 0x12B5, 0x12B5, 0x12BD, 0x12BD, 0x12B9, 0x12B9, 0x12C1, 0x12C1, 0x12C5, 0x12C5, 0x12C9, 0x12C9, /* 037B */
+ 0x12CD, 0x12CD, 0x12D1, 0x12D1, 0x12D5, 0x12D5, 0x1235, 0x1235, 0x1255, 0x1255, 0x1251, 0x1251, 0x124D, 0x124D, 0x11F7, 0x11F7, 0x34B, 0, 0, 0, 0, 0x8487FBC0, 0, 0, 0x1180, 0x1180, 0x1299, 0x1299, 0x11FF, 0x11FF, 0x1134, 0x1134, 0x1138, 0x1138, 0x113C, 0x113C, 0x1166, 0x1166, 0x114E, 0x114E, 0x119C, 0x119C, 0x11AC, 0x11AC, 0x11A8, 0x11A8, 0x11A4, 0x11A4, 0x11CE, 0x11CE, 0x11D6, 0x11D6, 0x11F3, 0x11F3, 0x12D9, 0x12D9, 0x1208, 0x1208, 0x1211, 0x1211, 0x122D, 0x122D, 0x1231, 0x1231, 0x1241, 0x1241, 0x125D, 0x125D, 0x1269, 0x1269, 0x1271, 0x1271, 0x1245, 0x1245, 0x1275, 0x1275, 0x1279, 0x1279, 0x12DD, 0x115E, 0x115E, 0x11A0, 0x11A0, 0x11B5, 0x11B5, 0x11D2, 0x11D2, 0x11CA, 0x11CA, 0x126D, 0x126D, 0x11C2, 0x11C2, 0x84CFFBC0, 0x1118, 0x1118, 0x111C, 0x111C, 0x1128, 0x1128, 0x1156, 0x1156, 0x1120, 0x1120, 0x1124, 0x1124, 0x1162, 0x1162, 0x116F, 0x116F, 0x1177, 0x1177, 0x117C, 0x117C, 0x1184, 0x1184, 0x11E3, 0x11E3, 0x11E7, 0x11E7, 0x11EB, 0x11EB, 0x12A5, 0x12A5, 0x121D, 0x121D, 0x1225, 0x1225, 0x1229, 0x1229, 0x1265, 0x1265, 0x84F6FBC0, 0x84F7FBC0, 0x1291, 0x1291, 0x84FAFBC0, 0x84FBFBC0, 0x84FCFBC0, 0x84FDFBC0, 0x84FEFBC0, 0x84FFFBC0, 0x1144, 0x1144, 0x1149, 0x1149, 0x116E, 0x116E, 0x117B, 0x117B, 0x11BD, 0x11BD, 0x11DE, 0x11DE, 0x1207, 0x1207, 0x1210, 0x1210, 0x8510FBC0, 0x8511FBC0, 0x8512FBC0, 0x8513FBC0, 0x8514FBC0, 0x8515FBC0, 0x8516FBC0, 0x8517FBC0, 0x8518FBC0, 0x8519FBC0, 0x851AFBC0, 0x851BFBC0, 0x851CFBC0, 0x851DFBC0, 0x851EFBC0, 0x851FFBC0, 0x8520FBC0, 0x8521FBC0, 0x8522FBC0, 0x8523FBC0, 0x8524FBC0, 0x8525FBC0, 0x8526FBC0, 0x8527FBC0, 0x8528FBC0, 0x8529FBC0, 0x852AFBC0, 0x852BFBC0, 0x852CFBC0, 0x852DFBC0, 0x852EFBC0, 0x852FFBC0, 0x8530FBC0, 0x130A, 0x130B, 0x130C, 0x130D, 0x130E, 0x130F, 0x1310, 0x1311, 0x1312, 0x1313, 0x1314, 0x1315, 0x1316, 0x1317, 0x1318, 0x1319, 0x131A, 0x131B, 0x131C, 0x131D, 0x131E, 0x131F, 0x1320, 0x1321, 0x1322, 0x1323, 0x1324, 0x1325, 0x1326, 0x1327, 0x1328, 0x1329, 0x132A, 0x132B, 0x132C, 0x132D, 0x132E, 0x132F, 0x8557FBC0, 0x8558FBC0, 0x1330, 0x2EC, 0x2ED, 0x253, 0x230, 0x257, 0x2EE, /* 0472 */
+ 0x8560FBC0, 0x130A, 0x130B, 0x130C, 0x130D, 0x130E, 0x130F, 0x1310, 0x1311, 0x1312, 0x1313, 0x1314, 0x1315, 0x1316, 0x1317, 0x1318, 0x1319, 0x131A, 0x131B, 0x131C, 0x131D, 0x131E, 0x131F, 0x1320, 0x1321, 0x1322, 0x1323, 0x1324, 0x1325, 0x1326, 0x1327, 0x1328, 0x1329, 0x132A, 0x132B, 0x132C, 0x132D, 0x132E, 0x132F, 0x132B130E, 0x8588FBC0, 0x23E, 0x222, 0x858BFBC0, 0x858CFBC0, 0x858DFBC0, 0x858EFBC0, 0x858FFBC0, 0x8590FBC0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x85A2FBC0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x85BAFBC0, 0, 0, 0, 0x2EF, 0, 0x2F0, 0, 0, 0x2F1, 0, 0x85C5FBC0, 0x85C6FBC0, 0x85C7FBC0, 0x85C8FBC0, 0x85C9FBC0, 0x85CAFBC0, 0x85CBFBC0, 0x85CCFBC0, 0x85CDFBC0, 0x85CEFBC0, 0x85CFFBC0, 0x1331, 0x1332, 0x1333, 0x1334, 0x1335, 0x1336, 0x1337, 0x1338, 0x1339, 0x133A, 0x133B, 0x133B, 0x133C, 0x133D, 0x133D, 0x133E, 0x133E, 0x133F, 0x1340, 0x1341, 0x1341, 0x1342, 0x1342, 0x1343, 0x1344, 0x1345, 0x1346, 0x85EBFBC0, 0x85ECFBC0, 0x85EDFBC0, 0x85EEFBC0, 0x85EFFBC0, 0x13361336, 0x133A1336, 0x133A133A, 0x2F2, 0x2F3, 0x85F5FBC0, 0x85F6FBC0, 0x85F7FBC0, 0x85F8FBC0, 0x85F9FBC0, 0x85FAFBC0, 0x85FBFBC0, 0x85FCFBC0, 0x85FDFBC0, 0x85FEFBC0, 0x85FFFBC0, 0, 0, 0, 0, 0x8604FBC0, 0x8605FBC0, 0x8606FBC0, 0x8607FBC0, 0x8608FBC0, 0x8609FBC0, 0x860AFBC0, 0x860BFBC0, 0x231, 0x232, 0x34C, 0x34D, 0, 0, 0, 0, 0, 0, 0x8616FBC0, 0x8617FBC0, 0x8618FBC0, 0x8619FBC0, 0x861AFBC0, 0x23B, 0x861CFBC0, 0x861DFBC0, 0x861EFBC0, 0x258, 0x8620FBC0, 0x1347, 0x1348, 0x1349, 0x134C, 0x134D, 0x134F, 0x1350, 0x1352, 0x1356, 0x1357, 0x1358, 0x135E, 0x1364, 0x1365, 0x1369, 0x136A, 0x1375, 0x1376, 0x1381, 0x1382, 0x1387, 0x1388, 0x138C, 0x138D, 0x138F, 0x1390, 0x863BFBC0, 0x863CFBC0, 0x863DFBC0, 0x863EFBC0, 0x863FFBC0, 0x20B, 0x1393, 0x139B, 0x139E, 0x13AB, 0x13B0, 0x13B1, 0x13B7, 0x13BD, 0x13C7, 0x13C8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x8659FBC0, 0x865AFBC0, 0x865BFBC0, 0x865CFBC0, 0x865DFBC0, 0x865EFBC0, 0x865FFBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x2D4, 0x233, /* 0560 */
+ 0x234, 0x2CB, 0x1351, 0x139A, 0, 0x134B, 0x134A, 0x134E, 0x1347, 0x13471350, 0x134713BD, 0x134713C1, 0x134713C8, 0x1359, 0x135A, 0x1353, 0x135B, 0x135C, 0x1354, 0x135D, 0x1355, 0x1366, 0x1367, 0x135F, 0x1360, 0x1368, 0x1361, 0x1363, 0x136B, 0x136C, 0x136D, 0x136E, 0x136F, 0x1370, 0x1371, 0x1372, 0x1373, 0x1377, 0x1378, 0x1379, 0x137A, 0x137B, 0x137C, 0x137D, 0x137E, 0x137F, 0x1383, 0x1384, 0x1385, 0x1389, 0x138A, 0x138E, 0x1391, 0x1394, 0x1395, 0x1396, 0x1397, 0x1398, 0x1399, 0x139C, 0x139D, 0x139F, 0x13A0, 0x13A1, 0x13A2, 0x13A3, 0x13A4, 0x13A5, 0x13A6, 0x13A7, 0x13A8, 0x13A9, 0x13AA, 0x13AC, 0x13AD, 0x13AE, 0x13AF, 0x13B6, 0x13B2, 0x13B3, 0x13B4, 0x13B5, 0x13B8, 0x1362, 0x13BC, 0x13B9, 0x13B9, 0x13BA, 0x13BE, 0x13BF, 0x13C0, 0x13C1, 0x13C2, 0x13C3, 0x13C4, 0x13C5, 0x13C9, 0x13CA, 0x13CB, 0x13C6, 0x13CC, 0x13CD, 0x13CE, 0x13CE, 0x25F, 0x13BC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x13BD, 0x13C8, 0, 0, 0x34E, 0, 0, 0, 0, 0x1374, 0x1380, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x1386, 0x138B, 0x1392, 0x1347, 0x13B0, 0x13BB, 0x270, 0x260, 0x261, 0x23F, 0x240, 0x241, 0x242, 0x243, 0x244, 0x259, 0x2F4, 0x2F5, 0x2F6, 0x2F7, 0x870EFBC0, 0, 0x13CF, 0, 0x13D0, 0x13D1, 0x13D1, 0x13D3, 0x13D2, 0x13D4, 0x13D5, 0x13D6, 0x13D8, 0x13D9, 0x13D9, 0x13DA, 0x13DB, 0x13DC, 0x13DE, 0x13DF, 0x13E0, 0x13E1, 0x13E1, 0x13E2, 0x13E3, 0x13E3, 0x13E5, 0x13E6, 0x13E7, 0x13E8, 0x13E9, 0x13D0, 0x13D1, 0x13D3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x874BFBC0, 0x874CFBC0, 0x13D7, 0x13DD, 0x13E4, 0x8750FBC0, 0x8751FBC0, 0x8752FBC0, 0x8753FBC0, 0x8754FBC0, 0x8755FBC0, 0x8756FBC0, 0x8757FBC0, 0x8758FBC0, 0x8759FBC0, 0x875AFBC0, 0x875BFBC0, 0x875CFBC0, 0x875DFBC0, 0x875EFBC0, 0x875FFBC0, 0x8760FBC0, 0x8761FBC0, 0x8762FBC0, 0x8763FBC0, 0x8764FBC0, 0x8765FBC0, 0x8766FBC0, 0x8767FBC0, 0x8768FBC0, 0x8769FBC0, 0x876AFBC0, 0x876BFBC0, 0x876CFBC0, 0x876DFBC0, 0x876EFBC0, 0x876FFBC0, 0x8770FBC0, 0x8771FBC0, 0x8772FBC0, 0x8773FBC0, 0x8774FBC0, 0x8775FBC0, 0x8776FBC0, /* 066C */
+ 0x8777FBC0, 0x8778FBC0, 0x8779FBC0, 0x877AFBC0, 0x877BFBC0, 0x877CFBC0, 0x877DFBC0, 0x877EFBC0, 0x877FFBC0, 0x13EA, 0x13ED, 0x13EE, 0x13EF, 0x13F1, 0x13F2, 0x13F3, 0x13F4, 0x13F7, 0x13F9, 0x13FA, 0x13FB, 0x13FD, 0x1401, 0x1402, 0x1404, 0x1405, 0x1409, 0x140A, 0x140B, 0x140C, 0x140D, 0x140E, 0x140F, 0x13FE, 0x13EB, 0x13EC, 0x13FC, 0x13F0, 0x1406, 0x1407, 0x1408, 0x13FF, 0x1400, 0x13F5, 0x13F6, 0x1403, 0x13F8, 0x1411, 0x1412, 0x1413, 0x1414, 0x1415, 0x1416, 0x1417, 0x1418, 0x1419, 0x141A, 0x141B, 0x1410, 0x87B2FBC0, 0x87B3FBC0, 0x87B4FBC0, 0x87B5FBC0, 0x87B6FBC0, 0x87B7FBC0, 0x87B8FBC0, 0x87B9FBC0, 0x87BAFBC0, 0x87BBFBC0, 0x87BCFBC0, 0x87BDFBC0, 0x87BEFBC0, 0x87BFFBC0, 0x87C0FBC0, 0x87C1FBC0, 0x87C2FBC0, 0x87C3FBC0, 0x87C4FBC0, 0x87C5FBC0, 0x87C6FBC0, 0x87C7FBC0, 0x87C8FBC0, 0x87C9FBC0, 0x87CAFBC0, 0x87CBFBC0, 0x87CCFBC0, 0x87CDFBC0, 0x87CEFBC0, 0x87CFFBC0, 0x87D0FBC0, 0x87D1FBC0, 0x87D2FBC0, 0x87D3FBC0, 0x87D4FBC0, 0x87D5FBC0, 0x87D6FBC0, 0x87D7FBC0, 0x87D8FBC0, 0x87D9FBC0, 0x87DAFBC0, 0x87DBFBC0, 0x87DCFBC0, 0x87DDFBC0, 0x87DEFBC0, 0x87DFFBC0, 0x87E0FBC0, 0x87E1FBC0, 0x87E2FBC0, 0x87E3FBC0, 0x87E4FBC0, 0x87E5FBC0, 0x87E6FBC0, 0x87E7FBC0, 0x87E8FBC0, 0x87E9FBC0, 0x87EAFBC0, 0x87EBFBC0, 0x87ECFBC0, 0x87EDFBC0, 0x87EEFBC0, 0x87EFFBC0, 0x87F0FBC0, 0x87F1FBC0, 0x87F2FBC0, 0x87F3FBC0, 0x87F4FBC0, 0x87F5FBC0, 0x87F6FBC0, 0x87F7FBC0, 0x87F8FBC0, 0x87F9FBC0, 0x87FAFBC0, 0x87FBFBC0, 0x87FCFBC0, 0x87FDFBC0, 0x87FEFBC0, 0x87FFFBC0, 0x8800FBC0, 0x8801FBC0, 0x8802FBC0, 0x8803FBC0, 0x8804FBC0, 0x8805FBC0, 0x8806FBC0, 0x8807FBC0, 0x8808FBC0, 0x8809FBC0, 0x880AFBC0, 0x880BFBC0, 0x880CFBC0, 0x880DFBC0, 0x880EFBC0, 0x880FFBC0, 0x8810FBC0, 0x8811FBC0, 0x8812FBC0, 0x8813FBC0, 0x8814FBC0, 0x8815FBC0, 0x8816FBC0, 0x8817FBC0, 0x8818FBC0, 0x8819FBC0, 0x881AFBC0, 0x881BFBC0, 0x881CFBC0, 0x881DFBC0, 0x881EFBC0, 0x881FFBC0, 0x8820FBC0, 0x8821FBC0, 0x8822FBC0, 0x8823FBC0, 0x8824FBC0, 0x8825FBC0, 0x8826FBC0, 0x8827FBC0, 0x8828FBC0, 0x8829FBC0, 0x882AFBC0, 0x882BFBC0, 0x882CFBC0, 0x882DFBC0, 0x882EFBC0, 0x882FFBC0, 0x8830FBC0, 0x8831FBC0, /* 0777 */
+ 0x8832FBC0, 0x8833FBC0, 0x8834FBC0, 0x8835FBC0, 0x8836FBC0, 0x8837FBC0, 0x8838FBC0, 0x8839FBC0, 0x883AFBC0, 0x883BFBC0, 0x883CFBC0, 0x883DFBC0, 0x883EFBC0, 0x883FFBC0, 0x8840FBC0, 0x8841FBC0, 0x8842FBC0, 0x8843FBC0, 0x8844FBC0, 0x8845FBC0, 0x8846FBC0, 0x8847FBC0, 0x8848FBC0, 0x8849FBC0, 0x884AFBC0, 0x884BFBC0, 0x884CFBC0, 0x884DFBC0, 0x884EFBC0, 0x884FFBC0, 0x8850FBC0, 0x8851FBC0, 0x8852FBC0, 0x8853FBC0, 0x8854FBC0, 0x8855FBC0, 0x8856FBC0, 0x8857FBC0, 0x8858FBC0, 0x8859FBC0, 0x885AFBC0, 0x885BFBC0, 0x885CFBC0, 0x885DFBC0, 0x885EFBC0, 0x885FFBC0, 0x8860FBC0, 0x8861FBC0, 0x8862FBC0, 0x8863FBC0, 0x8864FBC0, 0x8865FBC0, 0x8866FBC0, 0x8867FBC0, 0x8868FBC0, 0x8869FBC0, 0x886AFBC0, 0x886BFBC0, 0x886CFBC0, 0x886DFBC0, 0x886EFBC0, 0x886FFBC0, 0x8870FBC0, 0x8871FBC0, 0x8872FBC0, 0x8873FBC0, 0x8874FBC0, 0x8875FBC0, 0x8876FBC0, 0x8877FBC0, 0x8878FBC0, 0x8879FBC0, 0x887AFBC0, 0x887BFBC0, 0x887CFBC0, 0x887DFBC0, 0x887EFBC0, 0x887FFBC0, 0x8880FBC0, 0x8881FBC0, 0x8882FBC0, 0x8883FBC0, 0x8884FBC0, 0x8885FBC0, 0x8886FBC0, 0x8887FBC0, 0x8888FBC0, 0x8889FBC0, 0x888AFBC0, 0x888BFBC0, 0x888CFBC0, 0x888DFBC0, 0x888EFBC0, 0x888FFBC0, 0x8890FBC0, 0x8891FBC0, 0x8892FBC0, 0x8893FBC0, 0x8894FBC0, 0x8895FBC0, 0x8896FBC0, 0x8897FBC0, 0x8898FBC0, 0x8899FBC0, 0x889AFBC0, 0x889BFBC0, 0x889CFBC0, 0x889DFBC0, 0x889EFBC0, 0x889FFBC0, 0x88A0FBC0, 0x88A1FBC0, 0x88A2FBC0, 0x88A3FBC0, 0x88A4FBC0, 0x88A5FBC0, 0x88A6FBC0, 0x88A7FBC0, 0x88A8FBC0, 0x88A9FBC0, 0x88AAFBC0, 0x88ABFBC0, 0x88ACFBC0, 0x88ADFBC0, 0x88AEFBC0, 0x88AFFBC0, 0x88B0FBC0, 0x88B1FBC0, 0x88B2FBC0, 0x88B3FBC0, 0x88B4FBC0, 0x88B5FBC0, 0x88B6FBC0, 0x88B7FBC0, 0x88B8FBC0, 0x88B9FBC0, 0x88BAFBC0, 0x88BBFBC0, 0x88BCFBC0, 0x88BDFBC0, 0x88BEFBC0, 0x88BFFBC0, 0x88C0FBC0, 0x88C1FBC0, 0x88C2FBC0, 0x88C3FBC0, 0x88C4FBC0, 0x88C5FBC0, 0x88C6FBC0, 0x88C7FBC0, 0x88C8FBC0, 0x88C9FBC0, 0x88CAFBC0, 0x88CBFBC0, 0x88CCFBC0, 0x88CDFBC0, 0x88CEFBC0, 0x88CFFBC0, 0x88D0FBC0, 0x88D1FBC0, 0x88D2FBC0, 0x88D3FBC0, 0x88D4FBC0, 0x88D5FBC0, 0x88D6FBC0, 0x88D7FBC0, 0x88D8FBC0, 0x88D9FBC0, 0x88DAFBC0, 0x88DBFBC0, /* 0832 */
+ 0x88DCFBC0, 0x88DDFBC0, 0x88DEFBC0, 0x88DFFBC0, 0x88E0FBC0, 0x88E1FBC0, 0x88E2FBC0, 0x88E3FBC0, 0x88E4FBC0, 0x88E5FBC0, 0x88E6FBC0, 0x88E7FBC0, 0x88E8FBC0, 0x88E9FBC0, 0x88EAFBC0, 0x88EBFBC0, 0x88ECFBC0, 0x88EDFBC0, 0x88EEFBC0, 0x88EFFBC0, 0x88F0FBC0, 0x88F1FBC0, 0x88F2FBC0, 0x88F3FBC0, 0x88F4FBC0, 0x88F5FBC0, 0x88F6FBC0, 0x88F7FBC0, 0x88F8FBC0, 0x88F9FBC0, 0x88FAFBC0, 0x88FBFBC0, 0x88FCFBC0, 0x88FDFBC0, 0x88FEFBC0, 0x88FFFBC0, 0x8900FBC0, 0, 0, 0, 0x155A, 0x155B, 0x155C, 0x155D, 0x155E, 0x155F, 0x1560, 0x1561, 0x1563, 0x1565, 0x1566, 0x1567, 0x1568, 0x1569, 0x156A, 0x156B, 0x156C, 0x156D, 0x156E, 0x156F, 0x1570, 0x1571, 0x1572, 0x1573, 0x1574, 0x1575, 0x1576, 0x1577, 0x1578, 0x1579, 0x157A, 0x157B, 0x157C, 0x157D, 0x157E, 0x157F, 0x1580, 0x1580, 0x1581, 0x1582, 0x1583, 0x1584, 0x1585, 0x1586, 0x1587, 0x1587, 0x1588, 0x1589, 0x1589, 0x158A, 0x158B, 0x158C, 0x158D, 0x158E, 0x893AFBC0, 0x893BFBC0, 0, 0x158F, 0x1590, 0x1591, 0x1592, 0x1593, 0x1594, 0x1595, 0x1596, 0x1599, 0x159A, 0x159B, 0x159C, 0x159D, 0x159E, 0x159F, 0x15A0, 0x15A1, 0x894EFBC0, 0x894FFBC0, 0x1559, 0, 0, 0, 0, 0x8955FBC0, 0x8956FBC0, 0x8957FBC0, 0x156D, 0x156E, 0x156F, 0x1574, 0x1579, 0x157A, 0x1582, 0x1586, 0x1562, 0x1564, 0x1597, 0x1598, 0x268, 0x269, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x2FA, 0x8971FBC0, 0x8972FBC0, 0x8973FBC0, 0x8974FBC0, 0x8975FBC0, 0x8976FBC0, 0x8977FBC0, 0x8978FBC0, 0x8979FBC0, 0x897AFBC0, 0x897BFBC0, 0x897CFBC0, 0x897DFBC0, 0x897EFBC0, 0x897FFBC0, 0x8980FBC0, 0, 0, 0, 0x8984FBC0, 0x15A2, 0x15A3, 0x15A4, 0x15A5, 0x15A6, 0x15A7, 0x15A8, 0x15AA, 0x898DFBC0, 0x898EFBC0, 0x15AC, 0x15AD, 0x8991FBC0, 0x8992FBC0, 0x15AE, 0x15AF, 0x15B0, 0x15B1, 0x15B2, 0x15B3, 0x15B4, 0x15B5, 0x15B6, 0x15B7, 0x15B8, 0x15B9, 0x15BA, 0x15BB, 0x15BC, 0x15BD, 0x15BE, 0x15BF, 0x15C0, 0x15C1, 0x15C2, 0x15C3, 0x89A9FBC0, 0x15C4, 0x15C5, 0x15C6, 0x15C7, 0x15C8, 0x15C9, 0x15CA, 0x89B1FBC0, 0x15CC, 0x89B3FBC0, 0x89B4FBC0, 0x89B5FBC0, 0x15CE, 0x15CF, 0x15D0, 0x15D1, 0x89BAFBC0, 0x89BBFBC0, 0, 0x15D2, 0x15D3, 0x15D4, 0x15D5, /* 08DC */
+ 0x15D6, 0x15D7, 0x15D8, 0x15D9, 0x89C5FBC0, 0x89C6FBC0, 0x15DC, 0x15DD, 0x89C9FBC0, 0x89CAFBC0, 0x15DE, 0x15DF, 0x15E0, 0x89CEFBC0, 0x89CFFBC0, 0x89D0FBC0, 0x89D1FBC0, 0x89D2FBC0, 0x89D3FBC0, 0x89D4FBC0, 0x89D5FBC0, 0x89D6FBC0, 0x15E1, 0x89D8FBC0, 0x89D9FBC0, 0x89DAFBC0, 0x89DBFBC0, 0x15BC, 0x15BD, 0x89DEFBC0, 0x15C9, 0x15A9, 0x15AB, 0x15DA, 0x15DB, 0x89E4FBC0, 0x89E5FBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x15CB, 0x15CD, 0xE12, 0xE13, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xDC7, 0xDC8, 0x350, 0x89FBFBC0, 0x89FCFBC0, 0x89FDFBC0, 0x89FEFBC0, 0x89FFFBC0, 0x8A00FBC0, 0, 0, 0, 0x8A04FBC0, 0x15E7, 0x15E8, 0x15EC, 0x15ED, 0x15E4, 0x15E5, 0x8A0BFBC0, 0x8A0CFBC0, 0x8A0DFBC0, 0x8A0EFBC0, 0x15EE, 0x15E9, 0x8A11FBC0, 0x8A12FBC0, 0x15E6, 0x15EA, 0x15F1, 0x15F2, 0x15F3, 0x15F4, 0x15F5, 0x15F6, 0x15F7, 0x15F8, 0x15F9, 0x15FA, 0x15FB, 0x15FC, 0x15FD, 0x15FE, 0x15FF, 0x1600, 0x1601, 0x1602, 0x1603, 0x1604, 0x8A29FBC0, 0x1605, 0x1606, 0x1607, 0x1608, 0x1609, 0x160A, 0x160B, 0x8A31FBC0, 0x160C, 0x160C, 0x8A34FBC0, 0x160D, 0x15EF, 0x8A37FBC0, 0x15EF, 0x15F0, 0x8A3AFBC0, 0x8A3BFBC0, 0, 0x8A3DFBC0, 0x160F, 0x1610, 0x1611, 0x1612, 0x1613, 0x8A43FBC0, 0x8A44FBC0, 0x8A45FBC0, 0x8A46FBC0, 0x1614, 0x1615, 0x8A49FBC0, 0x8A4AFBC0, 0x1616, 0x1617, 0x1618, 0x8A4EFBC0, 0x8A4FFBC0, 0x8A50FBC0, 0x8A51FBC0, 0x8A52FBC0, 0x8A53FBC0, 0x8A54FBC0, 0x8A55FBC0, 0x8A56FBC0, 0x8A57FBC0, 0x8A58FBC0, 0x15F2, 0x15F3, 0x15F8, 0x160E, 0x8A5DFBC0, 0x1606, 0x8A5FFBC0, 0x8A60FBC0, 0x8A61FBC0, 0x8A62FBC0, 0x8A63FBC0, 0x8A64FBC0, 0x8A65FBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0, 0, 0x15EB, 0x15E3, 0x15E2, 0x8A75FBC0, 0x8A76FBC0, 0x8A77FBC0, 0x8A78FBC0, 0x8A79FBC0, 0x8A7AFBC0, 0x8A7BFBC0, 0x8A7CFBC0, 0x8A7DFBC0, 0x8A7EFBC0, 0x8A7FFBC0, 0x8A80FBC0, 0, 0, 0, 0x8A84FBC0, 0x161A, 0x161B, 0x161C, 0x161D, 0x161E, 0x161F, 0x1620, 0x1622, 0x1624, 0x8A8EFBC0, 0x1625, 0x1626, 0x1627, 0x8A92FBC0, 0x1628, 0x1629, 0x162A, 0x162B, 0x162C, 0x162D, 0x162E, 0x162F, 0x1630, 0x1631, 0x1632, 0x1633, 0x1634, 0x1635, 0x1636, /* 09C1 */
+ 0x1637, 0x1638, 0x1639, 0x163A, 0x163B, 0x163C, 0x163D, 0x8AA9FBC0, 0x163E, 0x163F, 0x1640, 0x1641, 0x1642, 0x1643, 0x1644, 0x8AB1FBC0, 0x1645, 0x1646, 0x8AB4FBC0, 0x1647, 0x1648, 0x1649, 0x164A, 0x164B, 0x8ABAFBC0, 0x8ABBFBC0, 0, 0x164C, 0x164D, 0x164E, 0x164F, 0x1650, 0x1651, 0x1652, 0x1653, 0x1656, 0x8AC6FBC0, 0x1657, 0x1658, 0x1659, 0x8ACAFBC0, 0x165A, 0x165B, 0x165C, 0x8ACEFBC0, 0x8ACFFBC0, 0x1619, 0x8AD1FBC0, 0x8AD2FBC0, 0x8AD3FBC0, 0x8AD4FBC0, 0x8AD5FBC0, 0x8AD6FBC0, 0x8AD7FBC0, 0x8AD8FBC0, 0x8AD9FBC0, 0x8ADAFBC0, 0x8ADBFBC0, 0x8ADCFBC0, 0x8ADDFBC0, 0x8ADEFBC0, 0x8ADFFBC0, 0x1621, 0x1623, 0x1654, 0x1655, 0x8AE4FBC0, 0x8AE5FBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x8AF0FBC0, 0xE14, 0x8AF2FBC0, 0x8AF3FBC0, 0x8AF4FBC0, 0x8AF5FBC0, 0x8AF6FBC0, 0x8AF7FBC0, 0x8AF8FBC0, 0x8AF9FBC0, 0x8AFAFBC0, 0x8AFBFBC0, 0x8AFCFBC0, 0x8AFDFBC0, 0x8AFEFBC0, 0x8AFFFBC0, 0x8B00FBC0, 0, 0, 0, 0x8B04FBC0, 0x165D, 0x165E, 0x165F, 0x1660, 0x1661, 0x1662, 0x1663, 0x1665, 0x8B0DFBC0, 0x8B0EFBC0, 0x1667, 0x1668, 0x8B11FBC0, 0x8B12FBC0, 0x1669, 0x166A, 0x166B, 0x166C, 0x166D, 0x166E, 0x166F, 0x1670, 0x1671, 0x1672, 0x1673, 0x1674, 0x1675, 0x1676, 0x1677, 0x1678, 0x1679, 0x167A, 0x167B, 0x167C, 0x167D, 0x167E, 0x8B29FBC0, 0x167F, 0x1680, 0x1681, 0x1682, 0x1683, 0x1684, 0x1686, 0x8B31FBC0, 0x1687, 0x1688, 0x8B34FBC0, 0x1689, 0x168B, 0x168C, 0x168D, 0x168E, 0x8B3AFBC0, 0x8B3BFBC0, 0, 0x168F, 0x1690, 0x1691, 0x1692, 0x1693, 0x1694, 0x1695, 0x8B44FBC0, 0x8B45FBC0, 0x8B46FBC0, 0x1696, 0x1697, 0x8B49FBC0, 0x8B4AFBC0, 0x1698, 0x1699, 0x169A, 0x8B4EFBC0, 0x8B4FFBC0, 0x8B50FBC0, 0x8B51FBC0, 0x8B52FBC0, 0x8B53FBC0, 0x8B54FBC0, 0x8B55FBC0, 0x169B, 0x169C, 0x8B58FBC0, 0x8B59FBC0, 0x8B5AFBC0, 0x8B5BFBC0, 0x1677, 0x1678, 0x8B5EFBC0, 0x1685, 0x1664, 0x1666, 0x8B62FBC0, 0x8B63FBC0, 0x8B64FBC0, 0x8B65FBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x351, 0x168A, 0x8B72FBC0, 0x8B73FBC0, 0x8B74FBC0, 0x8B75FBC0, 0x8B76FBC0, 0x8B77FBC0, 0x8B78FBC0, 0x8B79FBC0, 0x8B7AFBC0, 0x8B7BFBC0, 0x8B7CFBC0, /* 0AA2 */
+ 0x8B7DFBC0, 0x8B7EFBC0, 0x8B7FFBC0, 0x8B80FBC0, 0x8B81FBC0, 0, 0x169D, 0x8B84FBC0, 0x169E, 0x169F, 0x16A0, 0x16A1, 0x16A2, 0x16A3, 0x8B8BFBC0, 0x8B8CFBC0, 0x8B8DFBC0, 0x16A4, 0x16A5, 0x16A6, 0x8B91FBC0, 0x16A7, 0x16A8, 0x16A9, 0x16AA, 0x8B96FBC0, 0x8B97FBC0, 0x8B98FBC0, 0x16AB, 0x16AC, 0x8B9BFBC0, 0x16AD, 0x8B9DFBC0, 0x16AE, 0x16AF, 0x8BA0FBC0, 0x8BA1FBC0, 0x8BA2FBC0, 0x16B0, 0x16B1, 0x8BA5FBC0, 0x8BA6FBC0, 0x8BA7FBC0, 0x16B2, 0x16B3, 0x16B4, 0x8BABFBC0, 0x8BACFBC0, 0x8BADFBC0, 0x16B5, 0x16B6, 0x16B7, 0x16B8, 0x16B9, 0x16BA, 0x16BB, 0x16BC, 0x8BB6FBC0, 0x16BD, 0x16BE, 0x16BF, 0x8BBAFBC0, 0x8BBBFBC0, 0x8BBCFBC0, 0x8BBDFBC0, 0x16C0, 0x16C1, 0x16C2, 0x16C3, 0x16C4, 0x8BC3FBC0, 0x8BC4FBC0, 0x8BC5FBC0, 0x16C5, 0x16C6, 0x16C7, 0x8BC9FBC0, 0x16C8, 0x16C9, 0x16CA, 0x16CB, 0x8BCEFBC0, 0x8BCFFBC0, 0x8BD0FBC0, 0x8BD1FBC0, 0x8BD2FBC0, 0x8BD3FBC0, 0x8BD4FBC0, 0x8BD5FBC0, 0x8BD6FBC0, 0x16CC, 0x8BD8FBC0, 0x8BD9FBC0, 0x8BDAFBC0, 0x8BDBFBC0, 0x8BDCFBC0, 0x8BDDFBC0, 0x8BDEFBC0, 0x8BDFFBC0, 0x8BE0FBC0, 0x8BE1FBC0, 0x8BE2FBC0, 0x8BE3FBC0, 0x8BE4FBC0, 0x8BE5FBC0, 0x8BE6FBC0, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0xDC9, 0xDCA, 0xDCB, 0x352, 0x353, 0x354, 0x355, 0x356, 0x357, 0xE15, 0x358, 0x8BFBFBC0, 0x8BFCFBC0, 0x8BFDFBC0, 0x8BFEFBC0, 0x8BFFFBC0, 0x8C00FBC0, 0, 0, 0, 0x8C04FBC0, 0x16CD, 0x16CE, 0x16CF, 0x16D0, 0x16D1, 0x16D2, 0x16D3, 0x16D5, 0x8C0DFBC0, 0x16D7, 0x16D8, 0x16D9, 0x8C11FBC0, 0x16DA, 0x16DB, 0x16DC, 0x16DD, 0x16DE, 0x16DF, 0x16E0, 0x16E1, 0x16E2, 0x16E3, 0x16E4, 0x16E5, 0x16E6, 0x16E7, 0x16E8, 0x16E9, 0x16EA, 0x16EB, 0x16EC, 0x16ED, 0x16EE, 0x16EF, 0x16F0, 0x8C29FBC0, 0x16F1, 0x16F2, 0x16F3, 0x16F4, 0x16F5, 0x16F6, 0x16F7, 0x16F8, 0x16F9, 0x16FA, 0x8C34FBC0, 0x16FB, 0x16FC, 0x16FD, 0x16FE, 0x16FF, 0x8C3AFBC0, 0x8C3BFBC0, 0x8C3CFBC0, 0x8C3DFBC0, 0x1700, 0x1701, 0x1702, 0x1703, 0x1704, 0x1705, 0x1706, 0x8C45FBC0, 0x1707, 0x1708, 0x1709, 0x8C49FBC0, 0x170A, 0x170B, 0x170C, 0x170D, 0x8C4EFBC0, 0x8C4FFBC0, 0x8C50FBC0, 0x8C51FBC0, 0x8C52FBC0, 0x8C53FBC0, 0x8C54FBC0, 0x170E, 0x170F, 0x8C57FBC0, /* 0B7D */
+ 0x8C58FBC0, 0x8C59FBC0, 0x8C5AFBC0, 0x8C5BFBC0, 0x8C5CFBC0, 0x8C5DFBC0, 0x8C5EFBC0, 0x8C5FFBC0, 0x16D4, 0x16D6, 0x8C62FBC0, 0x8C63FBC0, 0x8C64FBC0, 0x8C65FBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x8C70FBC0, 0x8C71FBC0, 0x8C72FBC0, 0x8C73FBC0, 0x8C74FBC0, 0x8C75FBC0, 0x8C76FBC0, 0x8C77FBC0, 0x8C78FBC0, 0x8C79FBC0, 0x8C7AFBC0, 0x8C7BFBC0, 0x8C7CFBC0, 0x8C7DFBC0, 0x8C7EFBC0, 0x8C7FFBC0, 0x8C80FBC0, 0x8C81FBC0, 0, 0, 0x8C84FBC0, 0x1710, 0x1711, 0x1712, 0x1713, 0x1714, 0x1715, 0x1716, 0x1718, 0x8C8DFBC0, 0x171A, 0x171B, 0x171C, 0x8C91FBC0, 0x171D, 0x171E, 0x171F, 0x1720, 0x1721, 0x1722, 0x1723, 0x1724, 0x1725, 0x1726, 0x1727, 0x1728, 0x1729, 0x172A, 0x172B, 0x172C, 0x172D, 0x172E, 0x172F, 0x1730, 0x1731, 0x1732, 0x1733, 0x8CA9FBC0, 0x1734, 0x1735, 0x1736, 0x1737, 0x1738, 0x1739, 0x173A, 0x173B, 0x173C, 0x1743, 0x8CB4FBC0, 0x173D, 0x173E, 0x173F, 0x1740, 0x1741, 0x8CBAFBC0, 0x8CBBFBC0, 0, 0x1742, 0x1745, 0x1746, 0x1747, 0x1748, 0x1749, 0x174A, 0x174B, 0x8CC5FBC0, 0x174C, 0x174D, 0x174E, 0x8CC9FBC0, 0x174F, 0x1750, 0x1751, 0x1752, 0x8CCEFBC0, 0x8CCFFBC0, 0x8CD0FBC0, 0x8CD1FBC0, 0x8CD2FBC0, 0x8CD3FBC0, 0x8CD4FBC0, 0x1753, 0x1754, 0x8CD7FBC0, 0x8CD8FBC0, 0x8CD9FBC0, 0x8CDAFBC0, 0x8CDBFBC0, 0x8CDCFBC0, 0x8CDDFBC0, 0x1744, 0x8CDFFBC0, 0x1717, 0x1719, 0x8CE2FBC0, 0x8CE3FBC0, 0x8CE4FBC0, 0x8CE5FBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x8CF0FBC0, 0x8CF1FBC0, 0x8CF2FBC0, 0x8CF3FBC0, 0x8CF4FBC0, 0x8CF5FBC0, 0x8CF6FBC0, 0x8CF7FBC0, 0x8CF8FBC0, 0x8CF9FBC0, 0x8CFAFBC0, 0x8CFBFBC0, 0x8CFCFBC0, 0x8CFDFBC0, 0x8CFEFBC0, 0x8CFFFBC0, 0x8D00FBC0, 0x8D01FBC0, 0, 0, 0x8D04FBC0, 0x1755, 0x1756, 0x1757, 0x1758, 0x1759, 0x175A, 0x175B, 0x175D, 0x8D0DFBC0, 0x175F, 0x1760, 0x1761, 0x8D11FBC0, 0x1762, 0x1763, 0x1764, 0x1765, 0x1766, 0x1767, 0x1768, 0x1769, 0x176A, 0x176B, 0x176C, 0x176D, 0x176E, 0x176F, 0x1770, 0x1771, 0x1772, 0x1773, 0x1774, 0x1775, 0x1776, 0x1777, 0x1778, 0x8D29FBC0, 0x1779, 0x177A, 0x177B, 0x177C, 0x177D, 0x177E, 0x177F, 0x1780, 0x1781, 0x1782, 0x1783, /* 0C58 */
+ 0x1784, 0x1785, 0x1786, 0x1787, 0x1788, 0x8D3AFBC0, 0x8D3BFBC0, 0x8D3CFBC0, 0x8D3DFBC0, 0x1789, 0x178A, 0x178B, 0x178C, 0x178D, 0x178E, 0x8D44FBC0, 0x8D45FBC0, 0x178F, 0x1790, 0x1791, 0x8D49FBC0, 0x1792, 0x1793, 0x1794, 0x1795, 0x8D4EFBC0, 0x8D4FFBC0, 0x8D50FBC0, 0x8D51FBC0, 0x8D52FBC0, 0x8D53FBC0, 0x8D54FBC0, 0x8D55FBC0, 0x8D56FBC0, 0x1796, 0x8D58FBC0, 0x8D59FBC0, 0x8D5AFBC0, 0x8D5BFBC0, 0x8D5CFBC0, 0x8D5DFBC0, 0x8D5EFBC0, 0x8D5FFBC0, 0x175C, 0x175E, 0x8D62FBC0, 0x8D63FBC0, 0x8D64FBC0, 0x8D65FBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x8D70FBC0, 0x8D71FBC0, 0x8D72FBC0, 0x8D73FBC0, 0x8D74FBC0, 0x8D75FBC0, 0x8D76FBC0, 0x8D77FBC0, 0x8D78FBC0, 0x8D79FBC0, 0x8D7AFBC0, 0x8D7BFBC0, 0x8D7CFBC0, 0x8D7DFBC0, 0x8D7EFBC0, 0x8D7FFBC0, 0x8D80FBC0, 0x8D81FBC0, 0, 0, 0x8D84FBC0, 0x1797, 0x1798, 0x1799, 0x179A, 0x179B, 0x179C, 0x179D, 0x179E, 0x179F, 0x17A0, 0x17A1, 0x17A2, 0x17A3, 0x17A4, 0x17A5, 0x17A6, 0x17A7, 0x17A8, 0x8D97FBC0, 0x8D98FBC0, 0x8D99FBC0, 0x17A9, 0x17AA, 0x17AB, 0x17AC, 0x17AD, 0x17AE, 0x17AF, 0x17B0, 0x17B1, 0x17B2, 0x17B3, 0x17B4, 0x17B5, 0x17B6, 0x17B7, 0x17B8, 0x17B9, 0x17BA, 0x17BB, 0x17BC, 0x17BD, 0x17BE, 0x17BF, 0x17C0, 0x8DB2FBC0, 0x17C1, 0x17C2, 0x17C3, 0x17C4, 0x17C5, 0x17C6, 0x17C7, 0x17C8, 0x17C9, 0x8DBCFBC0, 0x17CA, 0x8DBEFBC0, 0x8DBFFBC0, 0x17CB, 0x17CC, 0x17CD, 0x17CE, 0x17CF, 0x17D0, 0x17D1, 0x8DC7FBC0, 0x8DC8FBC0, 0x8DC9FBC0, 0x17D2, 0x8DCBFBC0, 0x8DCCFBC0, 0x8DCDFBC0, 0x8DCEFBC0, 0x17D3, 0x17D4, 0x17D5, 0x17D6, 0x17D7, 0x17D8, 0x8DD5FBC0, 0x17D9, 0x8DD7FBC0, 0x17DA, 0x17DB, 0x17DC, 0x17DD, 0x17DE, 0x17DF, 0x17E0, 0x17E1, 0x8DE0FBC0, 0x8DE1FBC0, 0x8DE2FBC0, 0x8DE3FBC0, 0x8DE4FBC0, 0x8DE5FBC0, 0x8DE6FBC0, 0x8DE7FBC0, 0x8DE8FBC0, 0x8DE9FBC0, 0x8DEAFBC0, 0x8DEBFBC0, 0x8DECFBC0, 0x8DEDFBC0, 0x8DEEFBC0, 0x8DEFFBC0, 0x8DF0FBC0, 0x8DF1FBC0, 0x17E2, 0x17E3, 0x2FB, 0x8DF5FBC0, 0x8DF6FBC0, 0x8DF7FBC0, 0x8DF8FBC0, 0x8DF9FBC0, 0x8DFAFBC0, 0x8DFBFBC0, 0x8DFCFBC0, 0x8DFDFBC0, 0x8DFEFBC0, 0x8DFFFBC0, 0x8E00FBC0, 0x17E4, 0x17E5, 0x17E6, 0x17E7, 0x17E8, 0x17E9, 0x17EA, 0x17EB, /* 0D35 */
+ 0x17EC, 0x17ED, 0x17EE, 0x17EF, 0x17F0, 0x17F1, 0x17F2, 0x17F3, 0x17F4, 0x17F5, 0x17F6, 0x17F7, 0x17F8, 0x17F9, 0x17FA, 0x17FB, 0x17FC, 0x17FD, 0x17FE, 0x17FF, 0x1800, 0x1801, 0x1802, 0x1803, 0x1804, 0x1805, 0x1806, 0x1807, 0x1808, 0x1809, 0x180A, 0x180B, 0x180C, 0x180D, 0x180E, 0x180F, 0x1810, 0x1811, 0x1812, 0x1813, 0x1814, 0x1815, 0x1816, 0x1817, 0x1818, 0x1819, 0x181A, 0x181B, 0x181C, 0x181D, 0x8E3BFBC0, 0x8E3CFBC0, 0x8E3DFBC0, 0x8E3EFBC0, 0xE16, 0x181E, 0x181F, 0x1820, 0x1821, 0x1822, 0x1823, 0xE03, 0, 0, 0, 0, 0, 0x1824, 0x1825, 0, 0x359, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x2FC, 0x2FD, 0x8E5CFBC0, 0x8E5DFBC0, 0x8E5EFBC0, 0x8E5FFBC0, 0x8E60FBC0, 0x8E61FBC0, 0x8E62FBC0, 0x8E63FBC0, 0x8E64FBC0, 0x8E65FBC0, 0x8E66FBC0, 0x8E67FBC0, 0x8E68FBC0, 0x8E69FBC0, 0x8E6AFBC0, 0x8E6BFBC0, 0x8E6CFBC0, 0x8E6DFBC0, 0x8E6EFBC0, 0x8E6FFBC0, 0x8E70FBC0, 0x8E71FBC0, 0x8E72FBC0, 0x8E73FBC0, 0x8E74FBC0, 0x8E75FBC0, 0x8E76FBC0, 0x8E77FBC0, 0x8E78FBC0, 0x8E79FBC0, 0x8E7AFBC0, 0x8E7BFBC0, 0x8E7CFBC0, 0x8E7DFBC0, 0x8E7EFBC0, 0x8E7FFBC0, 0x8E80FBC0, 0x1826, 0x1827, 0x8E83FBC0, 0x1828, 0x8E85FBC0, 0x8E86FBC0, 0x1829, 0x182A, 0x8E89FBC0, 0x182B, 0x8E8BFBC0, 0x8E8CFBC0, 0x182C, 0x8E8EFBC0, 0x8E8FFBC0, 0x8E90FBC0, 0x8E91FBC0, 0x8E92FBC0, 0x8E93FBC0, 0x182D, 0x182E, 0x182F, 0x1830, 0x8E98FBC0, 0x1831, 0x1832, 0x1833, 0x1834, 0x1835, 0x1836, 0x1837, 0x8EA0FBC0, 0x1838, 0x1839, 0x183A, 0x8EA4FBC0, 0x183B, 0x8EA6FBC0, 0x183C, 0x8EA8FBC0, 0x8EA9FBC0, 0x183D, 0x183E, 0x8EACFBC0, 0x183F, 0x1840, 0x1841, 0x1842, 0x1843, 0x1844, 0x1845, 0x1846, 0x1847, 0x1848, 0x1849, 0x184A, 0x184B, 0x8EBAFBC0, 0x184C, 0x184D, 0x184E, 0x8EBEFBC0, 0x8EBFFBC0, 0x184F, 0x1850, 0x1851, 0x1852, 0x1853, 0x8EC5FBC0, 0xE04, 0x8EC7FBC0, 0, 0, 0, 0, 0x1854, 0x1855, 0x8ECEFBC0, 0x8ECFFBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x8EDAFBC0, 0x8EDBFBC0, 0x1831183E, 0x1838183E, 0x8EDEFBC0, 0x8EDFFBC0, 0x8EE0FBC0, 0x8EE1FBC0, 0x8EE2FBC0, 0x8EE3FBC0, 0x8EE4FBC0, 0x8EE5FBC0, 0x8EE6FBC0, 0x8EE7FBC0, 0x8EE8FBC0, /* 0E09 */
+ 0x8EE9FBC0, 0x8EEAFBC0, 0x8EEBFBC0, 0x8EECFBC0, 0x8EEDFBC0, 0x8EEEFBC0, 0x8EEFFBC0, 0x8EF0FBC0, 0x8EF1FBC0, 0x8EF2FBC0, 0x8EF3FBC0, 0x8EF4FBC0, 0x8EF5FBC0, 0x8EF6FBC0, 0x8EF7FBC0, 0x8EF8FBC0, 0x8EF9FBC0, 0x8EFAFBC0, 0x8EFBFBC0, 0x8EFCFBC0, 0x8EFDFBC0, 0x8EFEFBC0, 0x8EFFFBC0, 0x18AD189A, 0x35A, 0x35B, 0x35C, 0x2FE, 0x2FF, 0x300, 0x301, 0x302, 0x303, 0x304, 0x305, 0x305, 0x306, 0x307, 0x308, 0x309, 0x30A, 0x30B, 0x35D, 0x24C, 0x35E, 0x35F, 0x360, 0, 0, 0x361, 0x362, 0x363, 0x364, 0x365, 0x366, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0xE29, 0x367, 0, 0x368, 0, 0x369, 0, 0x28E, 0x28F, 0x290, 0x291, 0x36A, 0x36B, 0x1856, 0x1858, 0x185A, 0x1899185A, 0x185C, 0x185E, 0x1860, 0x1862, 0x8F48FBC0, 0x1864, 0x1866, 0x1868, 0x186A, 0x1899186A, 0x186C, 0x186E, 0x1870, 0x1872, 0x18991872, 0x1874, 0x1876, 0x1878, 0x187A, 0x1899187A, 0x187C, 0x187E, 0x1880, 0x1882, 0x18991882, 0x1884, 0x1886, 0x1888, 0x188A, 0x188C, 0x188E, 0x1890, 0x1892, 0x1894, 0x1896, 0x1898, 0x189A, 0x18951856, 0x188E, 0x8F6BFBC0, 0x8F6CFBC0, 0x8F6DFBC0, 0x8F6EFBC0, 0x8F6FFBC0, 0x8F70FBC0, 0x18A0, 0x18A1, 0x18A2, 0x18A5, 0x18A6, 0x18A7, 0x18A8, 0x18A9, 0x18AA, 0x18AB, 0x18AC, 0x18AD, 0x18AE, 0, 0, 0x18A3, 0x18A4, 0, 0, 0x18AF, 0x30C, 0, 0, 0x189C, 0x189D, 0x189E, 0x189F, 0x8F8CFBC0, 0x8F8DFBC0, 0x8F8EFBC0, 0x8F8FFBC0, 0x1857, 0x1859, 0x185B, 0x1899185B, 0x185D, 0x185F, 0x1861, 0x1863, 0x8F98FBC0, 0x1865, 0x1867, 0x1869, 0x186B, 0x1899186B, 0x186D, 0x186F, 0x1871, 0x1873, 0x18991873, 0x1875, 0x1877, 0x1879, 0x187B, 0x1899187B, 0x187D, 0x187F, 0x1881, 0x1883, 0x18991883, 0x1885, 0x1887, 0x1889, 0x188B, 0x188D, 0x188F, 0x1891, 0x1893, 0x1895, 0x1897, 0x1899, 0x189B, 0x18951857, 0x1885, 0x188D, 0x188F, 0x8FBDFBC0, 0x36C, 0x36D, 0x36E, 0x36F, 0x370, 0x371, 0x372, 0x373, 0, 0x374, 0x375, 0x376, 0x377, 0x378, 0x379, 0x8FCDFBC0, 0x8FCEFBC0, 0x37A, 0x8FD0FBC0, 0x8FD1FBC0, 0x8FD2FBC0, 0x8FD3FBC0, 0x8FD4FBC0, 0x8FD5FBC0, 0x8FD6FBC0, 0x8FD7FBC0, 0x8FD8FBC0, 0x8FD9FBC0, /* 0EE9 */
+ 0x8FDAFBC0, 0x8FDBFBC0, 0x8FDCFBC0, 0x8FDDFBC0, 0x8FDEFBC0, 0x8FDFFBC0, 0x8FE0FBC0, 0x8FE1FBC0, 0x8FE2FBC0, 0x8FE3FBC0, 0x8FE4FBC0, 0x8FE5FBC0, 0x8FE6FBC0, 0x8FE7FBC0, 0x8FE8FBC0, 0x8FE9FBC0, 0x8FEAFBC0, 0x8FEBFBC0, 0x8FECFBC0, 0x8FEDFBC0, 0x8FEEFBC0, 0x8FEFFBC0, 0x8FF0FBC0, 0x8FF1FBC0, 0x8FF2FBC0, 0x8FF3FBC0, 0x8FF4FBC0, 0x8FF5FBC0, 0x8FF6FBC0, 0x8FF7FBC0, 0x8FF8FBC0, 0x8FF9FBC0, 0x8FFAFBC0, 0x8FFBFBC0, 0x8FFCFBC0, 0x8FFDFBC0, 0x8FFEFBC0, 0x8FFFFBC0, 0x1931, 0x1932, 0x1933, 0x1934, 0x1935, 0x1936, 0x1937, 0x1938, 0x1939, 0x193A, 0x193B, 0x193C, 0x193D, 0x193E, 0x193F, 0x1940, 0x1941, 0x1942, 0x1943, 0x1944, 0x1945, 0x1946, 0x1947, 0x1948, 0x1949, 0x194A, 0x194B, 0x194C, 0x194D, 0x194E, 0x1951, 0x1952, 0x1953, 0x1954, 0x9022FBC0, 0x1955, 0x1956, 0x1957, 0x1958, 0x1959, 0x9028FBC0, 0x195A, 0x195B, 0x902BFBC0, 0x1960, 0x1961, 0x1962, 0x1963, 0x1964, 0x1965, 0x1966, 0x9033FBC0, 0x9034FBC0, 0x9035FBC0, 0, 0, 0, 0x196B, 0x903AFBC0, 0x903BFBC0, 0x903CFBC0, 0x903DFBC0, 0x903EFBC0, 0x903FFBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x26C, 0x26D, 0x30E, 0x30F, 0x310, 0x311, 0x194F, 0x1950, 0x195C, 0x195D, 0x195E, 0x195F, 0x1967, 0x1968, 0x1969, 0x196A, 0x905AFBC0, 0x905BFBC0, 0x905CFBC0, 0x905DFBC0, 0x905EFBC0, 0x905FFBC0, 0x9060FBC0, 0x9061FBC0, 0x9062FBC0, 0x9063FBC0, 0x9064FBC0, 0x9065FBC0, 0x9066FBC0, 0x9067FBC0, 0x9068FBC0, 0x9069FBC0, 0x906AFBC0, 0x906BFBC0, 0x906CFBC0, 0x906DFBC0, 0x906EFBC0, 0x906FFBC0, 0x9070FBC0, 0x9071FBC0, 0x9072FBC0, 0x9073FBC0, 0x9074FBC0, 0x9075FBC0, 0x9076FBC0, 0x9077FBC0, 0x9078FBC0, 0x9079FBC0, 0x907AFBC0, 0x907BFBC0, 0x907CFBC0, 0x907DFBC0, 0x907EFBC0, 0x907FFBC0, 0x9080FBC0, 0x9081FBC0, 0x9082FBC0, 0x9083FBC0, 0x9084FBC0, 0x9085FBC0, 0x9086FBC0, 0x9087FBC0, 0x9088FBC0, 0x9089FBC0, 0x908AFBC0, 0x908BFBC0, 0x908CFBC0, 0x908DFBC0, 0x908EFBC0, 0x908FFBC0, 0x9090FBC0, 0x9091FBC0, 0x9092FBC0, 0x9093FBC0, 0x9094FBC0, 0x9095FBC0, 0x9096FBC0, 0x9097FBC0, 0x9098FBC0, 0x9099FBC0, 0x909AFBC0, 0x909BFBC0, 0x909CFBC0, 0x909DFBC0, 0x909EFBC0, 0x909FFBC0, 0x12E1, /* 0FDA */
+ 0x12E2, 0x12E3, 0x12E4, 0x12E5, 0x12E6, 0x12E7, 0x12E9, 0x12EA, 0x12EB, 0x12EC, 0x12ED, 0x12EE, 0x12F0, 0x12F1, 0x12F2, 0x12F3, 0x12F4, 0x12F5, 0x12F7, 0x12F8, 0x12F9, 0x12FA, 0x12FB, 0x12FC, 0x12FD, 0x12FE, 0x12FF, 0x1300, 0x1301, 0x1302, 0x1304, 0x1305, 0x12E8, 0x12EF, 0x12F6, 0x1303, 0x1306, 0x90C6FBC0, 0x90C7FBC0, 0x90C8FBC0, 0x90C9FBC0, 0x90CAFBC0, 0x90CBFBC0, 0x90CCFBC0, 0x90CDFBC0, 0x90CEFBC0, 0x90CFFBC0, 0x12E1, 0x12E2, 0x12E3, 0x12E4, 0x12E5, 0x12E6, 0x12E7, 0x12E9, 0x12EA, 0x12EB, 0x12EC, 0x12ED, 0x12EE, 0x12F0, 0x12F1, 0x12F2, 0x12F3, 0x12F4, 0x12F5, 0x12F7, 0x12F8, 0x12F9, 0x12FA, 0x12FB, 0x12FC, 0x12FD, 0x12FE, 0x12FF, 0x1300, 0x1301, 0x1302, 0x1304, 0x1305, 0x12E8, 0x12EF, 0x12F6, 0x1303, 0x1306, 0x1307, 0x1308, 0x1309, 0x90F9FBC0, 0x90FAFBC0, 0x271, 0x90FCFBC0, 0x90FDFBC0, 0x90FEFBC0, 0x90FFFBC0, 0x1D62, 0x1D63, 0x1D64, 0x1D65, 0x1D66, 0x1D67, 0x1D68, 0x1D69, 0x1D6A, 0x1D6B, 0x1D6C, 0x1D6D, 0x1D6E, 0x1D6F, 0x1D70, 0x1D71, 0x1D72, 0x1D73, 0x1D74, 0x1D75, 0x1D76, 0x1D77, 0x1D78, 0x1D79, 0x1D7A, 0x1D7B, 0x1D7C, 0x1D7D, 0x1D7E, 0x1D7F, 0x1D80, 0x1D81, 0x1D82, 0x1D83, 0x1D84, 0x1D85, 0x1D86, 0x1D87, 0x1D88, 0x1D89, 0x1D8A, 0x1D8B, 0x1D8C, 0x1D8D, 0x1D8E, 0x1D8F, 0x1D90, 0x1D91, 0x1D92, 0x1D93, 0x1D94, 0x1D95, 0x1D96, 0x1D97, 0x1D98, 0x1D99, 0x1D9A, 0x1D9B, 0x1D9C, 0x1D9D, 0x1D9E, 0x1D9F, 0x1DA0, 0x1DA1, 0x1DA2, 0x1DA3, 0x1DA4, 0x1DA5, 0x1DA6, 0x1DA7, 0x1DA8, 0x1DA9, 0x1DAA, 0x1DAB, 0x1DAC, 0x1DAD, 0x1DAE, 0x1DAF, 0x1DB0, 0x1DB1, 0x1DB2, 0x1DB3, 0x1DB4, 0x1DB5, 0x1DB6, 0x1DB7, 0x1DB8, 0x1DB9, 0x1DBA, 0x1DBB, 0x915AFBC0, 0x915BFBC0, 0x915CFBC0, 0x915DFBC0, 0x915EFBC0, 0x1DBC, 0x1DBD, 0x1DBE, 0x1DBF, 0x1DC0, 0x1DC1, 0x1DC2, 0x1DC3, 0x1DC4, 0x1DC5, 0x1DC6, 0x1DC7, 0x1DC8, 0x1DC9, 0x1DCA, 0x1DCB, 0x1DCC, 0x1DCD, 0x1DCE, 0x1DCF, 0x1DD0, 0x1DD1, 0x1DD2, 0x1DD3, 0x1DD4, 0x1DD5, 0x1DD6, 0x1DD7, 0x1DD8, 0x1DD9, 0x1DDA, 0x1DDB, 0x1DDC, 0x1DDD, 0x1DDE, 0x1DDF, 0x1DE0, 0x1DE1, 0x1DE2, 0x1DE3, 0x1DE4, 0x1DE5, 0x1DE6, 0x1DE7, 0x1DE8, 0x1DE9, 0x1DEA, 0x1DEB, 0x1DEC, 0x1DED, 0x1DEE, 0x1DEF, 0x1DF0, 0x1DF1, 0x1DF2, /* 10A1 */
+ 0x1DF3, 0x1DF4, 0x1DF5, 0x1DF6, 0x1DF7, 0x1DF8, 0x1DF9, 0x1DFA, 0x1DFB, 0x1DFC, 0x1DFD, 0x1DFE, 0x1DFF, 0x91A3FBC0, 0x91A4FBC0, 0x91A5FBC0, 0x91A6FBC0, 0x91A7FBC0, 0x1E00, 0x1E01, 0x1E02, 0x1E03, 0x1E04, 0x1E05, 0x1E06, 0x1E07, 0x1E08, 0x1E09, 0x1E0A, 0x1E0B, 0x1E0C, 0x1E0D, 0x1E0E, 0x1E0F, 0x1E10, 0x1E11, 0x1E12, 0x1E13, 0x1E14, 0x1E15, 0x1E16, 0x1E17, 0x1E18, 0x1E19, 0x1E1A, 0x1E1B, 0x1E1C, 0x1E1D, 0x1E1E, 0x1E1F, 0x1E20, 0x1E21, 0x1E22, 0x1E23, 0x1E24, 0x1E25, 0x1E26, 0x1E27, 0x1E28, 0x1E29, 0x1E2A, 0x1E2B, 0x1E2C, 0x1E2D, 0x1E2E, 0x1E2F, 0x1E30, 0x1E31, 0x1E32, 0x1E33, 0x1E34, 0x1E35, 0x1E36, 0x1E37, 0x1E38, 0x1E39, 0x1E3A, 0x1E3B, 0x1E3C, 0x1E3D, 0x1E3E, 0x1E3F, 0x1E40, 0x1E41, 0x1E42, 0x1E43, 0x1E44, 0x1E45, 0x1E46, 0x1E47, 0x1E48, 0x1E49, 0x1E4A, 0x1E4B, 0x1E4C, 0x1E4D, 0x1E4E, 0x1E4F, 0x1E50, 0x1E51, 0x91FAFBC0, 0x91FBFBC0, 0x91FCFBC0, 0x91FDFBC0, 0x91FEFBC0, 0x91FFFBC0, 0x141C, 0x141D, 0x141E, 0x141F, 0x1420, 0x1421, 0x1422, 0x9207FBC0, 0x1423, 0x1424, 0x1425, 0x1426, 0x1427, 0x1428, 0x1429, 0x142A, 0x142B, 0x142C, 0x142D, 0x142E, 0x142F, 0x1430, 0x1431, 0x1432, 0x1433, 0x1434, 0x1435, 0x1436, 0x1437, 0x1438, 0x1439, 0x143A, 0x143B, 0x143C, 0x143D, 0x143E, 0x143F, 0x1440, 0x1441, 0x1442, 0x1443, 0x1444, 0x1445, 0x1446, 0x1447, 0x1448, 0x1449, 0x144A, 0x144B, 0x144C, 0x144D, 0x144E, 0x144F, 0x1450, 0x1451, 0x1452, 0x1453, 0x1454, 0x1455, 0x1456, 0x1457, 0x1458, 0x1459, 0x145A, 0x145B, 0x145C, 0x145D, 0x145E, 0x145F, 0x1460, 0x1461, 0x9247FBC0, 0x1462, 0x9249FBC0, 0x1463, 0x1464, 0x1465, 0x1466, 0x924EFBC0, 0x924FFBC0, 0x1467, 0x1468, 0x1469, 0x146A, 0x146B, 0x146C, 0x146D, 0x9257FBC0, 0x146E, 0x9259FBC0, 0x146F, 0x1470, 0x1471, 0x1472, 0x925EFBC0, 0x925FFBC0, 0x1473, 0x1474, 0x1475, 0x1476, 0x1477, 0x1478, 0x1479, 0x147A, 0x147B, 0x147C, 0x147D, 0x147E, 0x147F, 0x1480, 0x1481, 0x1482, 0x1483, 0x1484, 0x1485, 0x1486, 0x1487, 0x1488, 0x1489, 0x148A, 0x148B, 0x148C, 0x148D, 0x148E, 0x148F, 0x1490, 0x1491, 0x1492, 0x1493, 0x1494, 0x1495, 0x1496, 0x1497, 0x1498, 0x1499, 0x9287FBC0, 0x149A, 0x9289FBC0, 0x149B, /* 1196 */
+ 0x149C, 0x149D, 0x149E, 0x928EFBC0, 0x928FFBC0, 0x149F, 0x14A0, 0x14A1, 0x14A2, 0x14A3, 0x14A4, 0x14A5, 0x14A6, 0x14A7, 0x14A8, 0x14A9, 0x14AA, 0x14AB, 0x14AC, 0x14AD, 0x14AE, 0x14AF, 0x14B0, 0x14B1, 0x14B2, 0x14B3, 0x14B4, 0x14B5, 0x14B6, 0x14B7, 0x14B8, 0x14B9, 0x14BA, 0x14BB, 0x14BC, 0x14BD, 0x92AFFBC0, 0x14BE, 0x92B1FBC0, 0x14BF, 0x14C0, 0x14C1, 0x14C2, 0x92B6FBC0, 0x92B7FBC0, 0x14C3, 0x14C4, 0x14C5, 0x14C6, 0x14C7, 0x14C8, 0x14C9, 0x92BFFBC0, 0x14CA, 0x92C1FBC0, 0x14CB, 0x14CC, 0x14CD, 0x14CE, 0x92C6FBC0, 0x92C7FBC0, 0x14CF, 0x14D0, 0x14D1, 0x14D2, 0x14D3, 0x14D4, 0x14D5, 0x92CFFBC0, 0x14D6, 0x14D7, 0x14D8, 0x14D9, 0x14DA, 0x14DB, 0x14DC, 0x92D7FBC0, 0x14DD, 0x14DE, 0x14DF, 0x14E0, 0x14E1, 0x14E2, 0x14E3, 0x14E4, 0x14E5, 0x14E6, 0x14E7, 0x14E8, 0x14E9, 0x14EA, 0x14EB, 0x14EC, 0x14ED, 0x14EE, 0x14EF, 0x14F0, 0x14F1, 0x14F2, 0x14F3, 0x92EFFBC0, 0x14F4, 0x14F5, 0x14F6, 0x14F7, 0x14F8, 0x14F9, 0x14FA, 0x14FB, 0x14FC, 0x14FD, 0x14FE, 0x14FF, 0x1500, 0x1501, 0x1502, 0x1503, 0x1504, 0x1505, 0x1506, 0x1507, 0x1508, 0x1509, 0x150A, 0x150B, 0x150C, 0x150D, 0x150E, 0x150F, 0x1510, 0x1511, 0x1512, 0x930FFBC0, 0x1513, 0x9311FBC0, 0x1514, 0x1515, 0x1516, 0x1517, 0x9316FBC0, 0x9317FBC0, 0x1518, 0x1519, 0x151A, 0x151B, 0x151C, 0x151D, 0x151E, 0x931FFBC0, 0x151F, 0x1520, 0x1521, 0x1522, 0x1523, 0x1524, 0x1525, 0x1526, 0x1527, 0x1528, 0x1529, 0x152A, 0x152B, 0x152C, 0x152D, 0x152E, 0x152F, 0x1530, 0x1531, 0x1532, 0x1533, 0x1534, 0x1535, 0x1536, 0x1537, 0x1538, 0x1539, 0x153A, 0x153B, 0x153C, 0x153D, 0x153E, 0x153F, 0x1540, 0x1541, 0x1542, 0x1543, 0x1544, 0x1545, 0x9347FBC0, 0x1546, 0x1547, 0x1548, 0x1549, 0x154A, 0x154B, 0x154C, 0x154D, 0x154E, 0x154F, 0x1550, 0x1551, 0x1552, 0x1553, 0x1554, 0x1555, 0x1556, 0x1557, 0x1558, 0x935BFBC0, 0x935CFBC0, 0x935DFBC0, 0x935EFBC0, 0x935FFBC0, 0x9360FBC0, 0x245, 0x262, 0x246, 0x247, 0x248, 0x249, 0x25A, 0x272, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0xDCC, 0xDCD, 0xDCE, 0xDCF, 0xDD0, 0xDD1, 0xDD2, 0xDD3, 0xDD4, 0xDD5, 0xDD6, 0x937DFBC0, 0x937EFBC0, 0x937FFBC0, /* 128B */
+ 0x9380FBC0, 0x9381FBC0, 0x9382FBC0, 0x9383FBC0, 0x9384FBC0, 0x9385FBC0, 0x9386FBC0, 0x9387FBC0, 0x9388FBC0, 0x9389FBC0, 0x938AFBC0, 0x938BFBC0, 0x938CFBC0, 0x938DFBC0, 0x938EFBC0, 0x938FFBC0, 0x9390FBC0, 0x9391FBC0, 0x9392FBC0, 0x9393FBC0, 0x9394FBC0, 0x9395FBC0, 0x9396FBC0, 0x9397FBC0, 0x9398FBC0, 0x9399FBC0, 0x939AFBC0, 0x939BFBC0, 0x939CFBC0, 0x939DFBC0, 0x939EFBC0, 0x939FFBC0, 0x1A59, 0x1A5A, 0x1A5B, 0x1A5C, 0x1A5D, 0x1A5E, 0x1A5F, 0x1A60, 0x1A61, 0x1A62, 0x1A63, 0x1A64, 0x1A65, 0x1A66, 0x1A67, 0x1A68, 0x1A69, 0x1A6A, 0x1A6B, 0x1A6C, 0x1A6D, 0x1A6E, 0x1A6F, 0x1A70, 0x1A71, 0x1A72, 0x1A73, 0x1A74, 0x1A75, 0x1A76, 0x1A77, 0x1A78, 0x1A79, 0x1A7A, 0x1A7B, 0x1A7C, 0x1A7D, 0x1A7E, 0x1A7F, 0x1A80, 0x1A81, 0x1A82, 0x1A83, 0x1A84, 0x1A85, 0x1A86, 0x1A87, 0x1A88, 0x1A89, 0x1A8A, 0x1A8B, 0x1A8C, 0x1A8D, 0x1A8E, 0x1A8F, 0x1A90, 0x1A91, 0x1A92, 0x1A93, 0x1A94, 0x1A95, 0x1A96, 0x1A97, 0x1A98, 0x1A99, 0x1A9A, 0x1A9B, 0x1A9C, 0x1A9D, 0x1A9E, 0x1A9F, 0x1AA0, 0x1AA1, 0x1AA2, 0x1AA3, 0x1AA4, 0x1AA5, 0x1AA6, 0x1AA7, 0x1AA8, 0x1AA9, 0x1AAA, 0x1AAB, 0x1AAC, 0x1AAD, 0x93F5FBC0, 0x93F6FBC0, 0x93F7FBC0, 0x93F8FBC0, 0x93F9FBC0, 0x93FAFBC0, 0x93FBFBC0, 0x93FCFBC0, 0x93FDFBC0, 0x93FEFBC0, 0x93FFFBC0, 0x9400FBC0, 0x1AAE, 0x1AAF, 0x1AB0, 0x1AB1, 0x1AB2, 0x1AB3, 0x1AB4, 0x1AB5, 0x1AB6, 0x1AB7, 0x1AB8, 0x1AB9, 0x1ABA, 0x1ABB, 0x1ABC, 0x1ABD, 0x1ABE, 0x1ABF, 0x1AC0, 0x1AC1, 0x1AC2, 0x1AC3, 0x1AC4, 0x1AC5, 0x1AC6, 0x1AC7, 0x1AC8, 0x1AC9, 0x1ACA, 0x1ACB, 0x1ACC, 0x1ACD, 0x1ACE, 0x1ACF, 0x1AD0, 0x1AD1, 0x1AD2, 0x1AD3, 0x1AD4, 0x1AD5, 0x1AD6, 0x1AD7, 0x1AD8, 0x1AD9, 0x1ADA, 0x1ADB, 0x1ADC, 0x1ADD, 0x1ADE, 0x1ADF, 0x1AE0, 0x1AE1, 0x1AE2, 0x1AE3, 0x1AE4, 0x1AE5, 0x1AE6, 0x1AE7, 0x1AE8, 0x1AE9, 0x1AEA, 0x1AEB, 0x1AEC, 0x1AED, 0x1AEE, 0x1AEF, 0x1AF0, 0x1AF1, 0x1AF2, 0x1AF3, 0x1AF4, 0x1AF5, 0x1AF6, 0x1AF7, 0x1AF8, 0x1AF9, 0x1AFA, 0x1AFB, 0x1AFC, 0x1AFD, 0x1AFE, 0x1AFF, 0x1B00, 0x1B01, 0x1B02, 0x1B03, 0x1B04, 0x1B05, 0x1B06, 0x1B07, 0x1B08, 0x1B09, 0x1B0A, 0x1B0B, 0x1B0C, 0x1B0D, 0x1B0E, 0x1B0F, 0x1B10, 0x1B11, 0x1B12, 0x1B13, 0x1B14, 0x1B15, 0x1B16, /* 1380 */
+ 0x1B17, 0x1B18, 0x1B19, 0x1B1A, 0x1B1B, 0x1B1C, 0x1B1D, 0x1B1E, 0x1B1F, 0x1B20, 0x1B21, 0x1B22, 0x1B23, 0x1B24, 0x1B25, 0x1B26, 0x1B27, 0x1B28, 0x1B29, 0x1B2A, 0x1B2B, 0x1B2C, 0x1B2D, 0x1B2E, 0x1B2F, 0x1B30, 0x1B31, 0x1B32, 0x1B33, 0x1B34, 0x1B35, 0x1B36, 0x1B37, 0x1B38, 0x1B39, 0x1B3A, 0x1B3B, 0x1B3C, 0x1B3D, 0x1B3E, 0x1B3F, 0x1B40, 0x1B41, 0x1B42, 0x1B43, 0x1B44, 0x1B45, 0x1B46, 0x1B47, 0x1B48, 0x1B49, 0x1B4A, 0x1B4B, 0x1B4C, 0x1B4D, 0x1B4E, 0x1B4F, 0x1B50, 0x1B51, 0x1B52, 0x1B53, 0x1B54, 0x1B55, 0x1B56, 0x1B57, 0x1B58, 0x1B59, 0x1B5A, 0x1B5B, 0x1B5C, 0x1B5D, 0x1B5E, 0x1B5F, 0x1B60, 0x1B61, 0x1B62, 0x1B63, 0x1B64, 0x1B65, 0x1B66, 0x1B67, 0x1B68, 0x1B69, 0x1B6A, 0x1B6B, 0x1B6C, 0x1B6D, 0x1B6E, 0x1B6F, 0x1B70, 0x1B71, 0x1B72, 0x1B73, 0x1B74, 0x1B75, 0x1B76, 0x1B77, 0x1B78, 0x1B79, 0x1B7A, 0x1B7B, 0x1B7C, 0x1B7D, 0x1B7E, 0x1B7F, 0x1B80, 0x1B81, 0x1B82, 0x1B83, 0x1B84, 0x1B85, 0x1B86, 0x1B87, 0x1B88, 0x1B89, 0x1B8A, 0x1B8B, 0x1B8C, 0x1B8D, 0x1B8E, 0x1B8F, 0x1B90, 0x1B91, 0x1B92, 0x1B93, 0x1B94, 0x1B95, 0x1B96, 0x1B97, 0x1B98, 0x1B99, 0x1B9A, 0x1B9B, 0x1B9C, 0x1B9D, 0x1B9E, 0x1B9F, 0x1BA0, 0x1BA1, 0x1BA2, 0x1BA3, 0x1BA4, 0x1BA5, 0x1BA6, 0x1BA7, 0x1BA8, 0x1BA9, 0x1BAA, 0x1BAB, 0x1BAC, 0x1BAD, 0x1BAE, 0x1BAF, 0x1BB0, 0x1BB1, 0x1BB2, 0x1BB3, 0x1BB4, 0x1BB5, 0x1BB6, 0x1BB7, 0x1BB8, 0x1BB9, 0x1BBA, 0x1BBB, 0x1BBC, 0x1BBD, 0x1BBE, 0x1BBF, 0x1BC0, 0x1BC1, 0x1BC2, 0x1BC3, 0x1BC4, 0x1BC5, 0x1BC6, 0x1BC7, 0x1BC8, 0x1BC9, 0x1BCA, 0x1BCB, 0x1BCC, 0x1BCD, 0x1BCE, 0x1BCF, 0x1BD0, 0x1BD1, 0x1BD2, 0x1BD3, 0x1BD4, 0x1BD5, 0x1BD6, 0x1BD7, 0x1BD8, 0x1BD9, 0x1BDA, 0x1BDB, 0x1BDC, 0x1BDD, 0x1BDE, 0x1BDF, 0x1BE0, 0x1BE1, 0x1BE2, 0x1BE3, 0x1BE4, 0x1BE5, 0x1BE6, 0x1BE7, 0x1BE8, 0x1BE9, 0x1BEA, 0x1BEB, 0x1BEC, 0x1BED, 0x1BEE, 0x1BEF, 0x1BF0, 0x1BF1, 0x1BF2, 0x1BF3, 0x1BF4, 0x1BF5, 0x1BF6, 0x1BF7, 0x1BF8, 0x1BF9, 0x1BFA, 0x1BFB, 0x1BFC, 0x1BFD, 0x1BFE, 0x1BFF, 0x1C00, 0x1C01, 0x1C02, 0x1C03, 0x1C04, 0x1C05, 0x1C06, 0x1C07, 0x1C08, 0x1C09, 0x1C0A, 0x1C0B, 0x1C0C, 0x1C0D, 0x1C0E, 0x1C0F, 0x1C10, 0x1C11, 0x1C12, 0x1C13, 0x1C14, 0x1C15, 0x1C16, /* 146A */
+ 0x1C17, 0x1C18, 0x1C19, 0x1C1A, 0x1C1B, 0x1C1C, 0x1C1D, 0x1C1E, 0x1C1F, 0x1C20, 0x1C21, 0x1C22, 0x1C23, 0x1C24, 0x1C25, 0x1C26, 0x1C27, 0x1C28, 0x1C5B, 0x1C29, 0x1C2B, 0x1C2C, 0x1C2D, 0x1C2E, 0x1C2F, 0x1C30, 0x1C31, 0x1C32, 0x1C33, 0x1C34, 0x1C35, 0x1C36, 0x1C37, 0x1C38, 0x1C39, 0x1C3A, 0x1C3C, 0x1C3D, 0x1C3E, 0x1C3F, 0x1C40, 0x1C41, 0x1C42, 0x1C43, 0x1C4A, 0x1C4B, 0x1C4C, 0x1C4D, 0x1C4E, 0x1C4F, 0x1C50, 0x1C51, 0x1C52, 0x1C53, 0x1C54, 0x1C55, 0x1C56, 0x1C57, 0x1C58, 0x1C59, 0x1C5A, 0x1C5C, 0x1C5D, 0x1C5E, 0x1C5F, 0x1C60, 0x1C61, 0x1C62, 0x1C63, 0x1C64, 0x1C65, 0x1C66, 0x1C67, 0x1C68, 0x1C69, 0x1C6A, 0x1C6B, 0x1C6C, 0x1C6D, 0x1C6E, 0x1C6F, 0x1C70, 0x1C71, 0x1C72, 0x1C73, 0x1C74, 0x1C75, 0x1C76, 0x1C77, 0x1C78, 0x1C79, 0x1C7A, 0x1C7B, 0x1C7C, 0x1C7D, 0x1C7E, 0x1C7F, 0x1C80, 0x1C81, 0x1C82, 0x1C83, 0x1C84, 0x1C85, 0x1C86, 0x1C87, 0x1C88, 0x1C89, 0x1C8A, 0x1C8B, 0x1C8C, 0x1C8D, 0x1C8E, 0x1C8F, 0x1C90, 0x1C91, 0x1C92, 0x1C93, 0x1C94, 0x1C95, 0x1C96, 0x1C97, 0x1C98, 0x1C99, 0x1C9A, 0x1C9B, 0x1C9C, 0x1C9D, 0x1C9E, 0x1C9F, 0x1CA0, 0x1CA1, 0x1CA2, 0x1CA3, 0x1CA4, 0x1CA5, 0x1CA6, 0x1CA7, 0x1CA8, 0x1CA9, 0x1CAA, 0x1CAB, 0x1CAC, 0x1CAD, 0x1CAE, 0x1CAF, 0x1CB0, 0x1CB1, 0x1CB2, 0x1CB3, 0x1CB4, 0x1CB5, 0x1CB6, 0x1CB7, 0x1CB8, 0x1CB9, 0x1CBA, 0x1CBB, 0x1CBC, 0x1CBD, 0x1CBE, 0x1CBF, 0x1CC0, 0x1CC1, 0x1CC2, 0x1CC3, 0x1CC4, 0x1CC5, 0x1CC6, 0x1CC7, 0x1CC8, 0x1CC9, 0x1CCA, 0x1CCB, 0x1CCC, 0x1CCD, 0x1CCE, 0x1CCF, 0x1CD0, 0x1CD1, 0x1CD2, 0x1CD3, 0x1CD4, 0x1CD5, 0x1CD6, 0x1CD7, 0x1CD8, 0x1CD9, 0x1CDA, 0x1CDB, 0x1CDC, 0x1CDD, 0x1CDE, 0x1CDF, 0x1CE0, 0x1CE1, 0x1CE2, 0x1CE3, 0x1CE4, 0x1CE5, 0x1CE6, 0x1CE7, 0x1CE8, 0x1CE9, 0x1CEA, 0x1CEB, 0x1CEC, 0x1CED, 0x1CEE, 0x1CEF, 0x1CF0, 0x1CF1, 0x1CF2, 0x1CF3, 0x1CF4, 0x1CF5, 0x1CF6, 0x1CF7, 0x1CF8, 0x1CF9, 0x1CFA, 0x1CFB, 0x1CFC, 0x1CFD, 0x1CFE, 0x1CFF, 0x1D00, 0x1D01, 0x1D02, 0x1D03, 0x1D04, 0x1D05, 0x1D06, 0x1D07, 0x1D08, 0x1D09, 0x1D0A, 0x1D0B, 0x1D0C, 0x1D0D, 0x1D0E, 0x1D0F, 0x1D10, 0x1D11, 0x1D12, 0x1D13, 0x1D14, 0x1D15, 0x1D16, 0x1D17, 0x1D18, 0x1D19, 0x1D1A, 0x1D1B, 0x1D1C, 0x1D1D, 0x1D1E, /* 156A */
+ 0x1D1F, 0x1D20, 0x1D21, 0x316, 0x265, 0x1C2A, 0x1C3B, 0x1C44, 0x1C45, 0x1C46, 0x1C47, 0x1C48, 0x1C49, 0x9677FBC0, 0x9678FBC0, 0x9679FBC0, 0x967AFBC0, 0x967BFBC0, 0x967CFBC0, 0x967DFBC0, 0x967EFBC0, 0x967FFBC0, 0x20A, 0x1D22, 0x1D23, 0x1D24, 0x1D25, 0x1D26, 0x1D27, 0x1D28, 0x1D29, 0x1D2A, 0x1D2B, 0x1D2C, 0x1D2D, 0x1D2E, 0x1D2F, 0x1D30, 0x1D31, 0x1D32, 0x1D33, 0x1D34, 0x1D35, 0x1D36, 0x1D37, 0x1D38, 0x1D39, 0x1D3A, 0x1D3B, 0x292, 0x293, 0x969DFBC0, 0x969EFBC0, 0x969FFBC0, 0x1D3C, 0x1D3C, 0x1D3D, 0x1D59, 0x1D3D, 0x1D3D, 0x1D3E, 0x1D3E, 0x1D3F, 0x1D3F, 0x1D57, 0x1D58, 0x1D3F, 0x1D3F, 0x1D3F, 0x1D40, 0x1D41, 0x1D42, 0x1D43, 0x1D43, 0x1D43, 0x1D43, 0x1D43, 0x1D44, 0x1D5C, 0x1D45, 0x1D46, 0x1D46, 0x1D46, 0x1D46, 0x1D47, 0x1D47, 0x1D47, 0x1D48, 0x1D48, 0x1D49, 0x1D49, 0x1D4A, 0x1D4A, 0x1D4B, 0x1D4C, 0x1D4D, 0x1D4E, 0x1D4E, 0x1D4E, 0x1D4E, 0x1D4E, 0x1D4F, 0x1D4F, 0x1D4F, 0x1D50, 0x1D50, 0x1D50, 0x1D4C, 0x1D51, 0x1D52, 0x1D52, 0x1D52, 0x1D53, 0x1D53, 0x1D54, 0x1D54, 0x1D55, 0x1D56, 0x1D5A, 0x1D5E, 0x1D5F, 0x1D5B, 0x1D5D, 0x1D60, 0x1D61, 0x1D61, 0x1D61, 0x1D45, 0x1D4E, 0x24E, 0x24F, 0x250, 0x1D531D4A, 0x1D521D52, 0x1D3E1D3E, 0x96F1FBC0, 0x96F2FBC0, 0x96F3FBC0, 0x96F4FBC0, 0x96F5FBC0, 0x96F6FBC0, 0x96F7FBC0, 0x96F8FBC0, 0x96F9FBC0, 0x96FAFBC0, 0x96FBFBC0, 0x96FCFBC0, 0x96FDFBC0, 0x96FEFBC0, 0x96FFFBC0, 0x18E2, 0x18E3, 0x18E4, 0x18E5, 0x18E6, 0x18E7, 0x18E8, 0x18E9, 0x18EA, 0x18EB, 0x18EC, 0x18ED, 0x18EE, 0x970DFBC0, 0x18EF, 0x18F0, 0x18F1, 0x18F2, 0x18F3, 0x18F4, 0x18F5, 0x9715FBC0, 0x9716FBC0, 0x9717FBC0, 0x9718FBC0, 0x9719FBC0, 0x971AFBC0, 0x971BFBC0, 0x971CFBC0, 0x971DFBC0, 0x971EFBC0, 0x971FFBC0, 0x18F6, 0x18F7, 0x18F8, 0x18F9, 0x18FA, 0x18FB, 0x18FC, 0x18FD, 0x18FE, 0x18FF, 0x1900, 0x1901, 0x1902, 0x1903, 0x1904, 0x1905, 0x1906, 0x1907, 0x1908, 0x1909, 0x190A, 0x26A, 0x26B, 0x9737FBC0, 0x9738FBC0, 0x9739FBC0, 0x973AFBC0, 0x973BFBC0, 0x973CFBC0, 0x973DFBC0, 0x973EFBC0, 0x973FFBC0, 0x190B, 0x190C, 0x190D, 0x190E, 0x190F, 0x1910, 0x1911, 0x1912, 0x1913, 0x1914, 0x1915, 0x1916, 0x1917, 0x1918, 0x1919, 0x191A, 0x191B, /* 166A */
+ 0x191C, 0x191D, 0x191E, 0x9754FBC0, 0x9755FBC0, 0x9756FBC0, 0x9757FBC0, 0x9758FBC0, 0x9759FBC0, 0x975AFBC0, 0x975BFBC0, 0x975CFBC0, 0x975DFBC0, 0x975EFBC0, 0x975FFBC0, 0x191F, 0x1920, 0x1921, 0x1922, 0x1923, 0x1924, 0x1925, 0x1926, 0x1927, 0x1928, 0x1929, 0x192A, 0x192B, 0x976DFBC0, 0x192C, 0x192D, 0x192E, 0x9771FBC0, 0x192F, 0x1930, 0x9774FBC0, 0x9775FBC0, 0x9776FBC0, 0x9777FBC0, 0x9778FBC0, 0x9779FBC0, 0x977AFBC0, 0x977BFBC0, 0x977CFBC0, 0x977DFBC0, 0x977EFBC0, 0x977FFBC0, 0x196C, 0x196D, 0x196E, 0x196F, 0x1970, 0x1971, 0x1972, 0x1973, 0x1974, 0x1975, 0x1976, 0x1977, 0x1978, 0x1979, 0x197A, 0x197B, 0x197C, 0x197D, 0x197E, 0x197F, 0x1980, 0x1981, 0x1982, 0x1983, 0x1984, 0x1985, 0x1986, 0x1987, 0x1988, 0x1989, 0x198A, 0x198B, 0x198C, 0x198D, 0x198E, 0x1990, 0x1991, 0x1992, 0x1993, 0x1994, 0x1995, 0x1996, 0x1997, 0x1998, 0x1999, 0x199A, 0x199B, 0x199C, 0x199D, 0x199E, 0x199F, 0x19A0, 0x19A1, 0x19A2, 0x19A3, 0x19A4, 0x19A5, 0x19A6, 0x19A7, 0x19A8, 0x19A9, 0x19AA, 0x19AB, 0x19AC, 0x19AD, 0x19AE, 0x19AF, 0x19B0, 0x19B1, 0x19B2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x19B3, 0, 0x26E, 0x26F, 0x24D, 0x312, 0x313, 0x314, 0x315, 0xE17, 0x198F, 0, 0x97DEFBC0, 0x97DFFBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x97EAFBC0, 0x97EBFBC0, 0x97ECFBC0, 0x97EDFBC0, 0x97EEFBC0, 0x97EFFBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x97FAFBC0, 0x97FBFBC0, 0x97FCFBC0, 0x97FDFBC0, 0x97FEFBC0, 0x97FFFBC0, 0x2F8, 0x25E, 0x235, 0x263, 0x24A, 0x24B, 0x223, 0x224, 0x236, 0x264, 0x2F9, 0, 0, 0, 0, 0x980FFBC0, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x981AFBC0, 0x981BFBC0, 0x981CFBC0, 0x981DFBC0, 0x981EFBC0, 0x981FFBC0, 0x19DF, 0x19E1, 0x19E4, 0x19EA, 0x19EC, 0x19EF, 0x19F1, 0x19F4, 0x19F5, 0x19F6, 0x19FB, 0x19FD, 0x1A00, 0x1A02, 0x1A07, 0x1A09, 0x1A0A, 0x1A0B, 0x1A12, 0x1A15, 0x1A18, 0x1A1D, 0x1A21, 0x1A24, 0x1A26, 0x1A28, 0x1A2B, 0x1A30, 0x1A31, 0x1A34, 0x1A38, 0x1A3B, 0x1A3C, 0x1A3D, 0x1A3E, 0x19DE, 0x19E2, 0x19E5, 0x19EB, 0x19ED, 0x19F0, 0x19F2, /* 1751 */
+ 0x19F7, 0x19FC, 0x19FE, 0x1A01, 0x1A03, 0x1A08, 0x1A13, 0x1A16, 0x1A19, 0x1A1E, 0x1A32, 0x1A22, 0x1A27, 0x1A2C, 0x1A36, 0x1A39, 0x1A3F, 0x1A40, 0x1A1B, 0x19E3, 0x19E6, 0x19E9, 0x19F3, 0x19EE, 0x19F8, 0x1A2D, 0x1A04, 0x1A06, 0x19FF, 0x1A0C, 0x1A14, 0x1A17, 0x1A1F, 0x1A29, 0x1A37, 0x1A3A, 0x1A33, 0x1A35, 0x1A41, 0x1A1A, 0x1A23, 0x19E7, 0x1A2E, 0x1A25, 0x1A2A, 0x1A20, 0x9878FBC0, 0x9879FBC0, 0x987AFBC0, 0x987BFBC0, 0x987CFBC0, 0x987DFBC0, 0x987EFBC0, 0x987FFBC0, 0x19D7, 0x19D8, 0x19D9, 0x19DA, 0x19DB, 0x19DC, 0x19DD, 0x19E0, 0x19E8, 0x1A2F, 0x19F9, 0x1A1C, 0x1A42, 0x1A44, 0x1A45, 0x1A47, 0x1A48, 0x1A4B, 0x1A4D, 0x1A4E, 0x1A50, 0x1A52, 0x1A54, 0x1A55, 0x1A49, 0x1A53, 0x1A05, 0x19FA, 0x1A0D, 0x1A0E, 0x1A43, 0x1A46, 0x1A4A, 0x1A4C, 0x1A0F, 0x1A51, 0x1A10, 0x1A11, 0x1A56, 0x1A57, 0x1A4F, 0x1A58, 0x98AAFBC0, 0x98ABFBC0, 0x98ACFBC0, 0x98ADFBC0, 0x98AEFBC0, 0x98AFFBC0, 0x98B0FBC0, 0x98B1FBC0, 0x98B2FBC0, 0x98B3FBC0, 0x98B4FBC0, 0x98B5FBC0, 0x98B6FBC0, 0x98B7FBC0, 0x98B8FBC0, 0x98B9FBC0, 0x98BAFBC0, 0x98BBFBC0, 0x98BCFBC0, 0x98BDFBC0, 0x98BEFBC0, 0x98BFFBC0, 0x98C0FBC0, 0x98C1FBC0, 0x98C2FBC0, 0x98C3FBC0, 0x98C4FBC0, 0x98C5FBC0, 0x98C6FBC0, 0x98C7FBC0, 0x98C8FBC0, 0x98C9FBC0, 0x98CAFBC0, 0x98CBFBC0, 0x98CCFBC0, 0x98CDFBC0, 0x98CEFBC0, 0x98CFFBC0, 0x98D0FBC0, 0x98D1FBC0, 0x98D2FBC0, 0x98D3FBC0, 0x98D4FBC0, 0x98D5FBC0, 0x98D6FBC0, 0x98D7FBC0, 0x98D8FBC0, 0x98D9FBC0, 0x98DAFBC0, 0x98DBFBC0, 0x98DCFBC0, 0x98DDFBC0, 0x98DEFBC0, 0x98DFFBC0, 0x98E0FBC0, 0x98E1FBC0, 0x98E2FBC0, 0x98E3FBC0, 0x98E4FBC0, 0x98E5FBC0, 0x98E6FBC0, 0x98E7FBC0, 0x98E8FBC0, 0x98E9FBC0, 0x98EAFBC0, 0x98EBFBC0, 0x98ECFBC0, 0x98EDFBC0, 0x98EEFBC0, 0x98EFFBC0, 0x98F0FBC0, 0x98F1FBC0, 0x98F2FBC0, 0x98F3FBC0, 0x98F4FBC0, 0x98F5FBC0, 0x98F6FBC0, 0x98F7FBC0, 0x98F8FBC0, 0x98F9FBC0, 0x98FAFBC0, 0x98FBFBC0, 0x98FCFBC0, 0x98FDFBC0, 0x98FEFBC0, 0x98FFFBC0, 0x18B0, 0x18B1, 0x18B2, 0x18B3, 0x18B4, 0x18B5, 0x18B6, 0x18B7, 0x18B8, 0x18B9, 0x18BA, 0x18BB, 0x18BC, 0x18BD, 0x18BE, 0x18BF, 0x18C0, 0x18C1, 0x18C2, 0x18C3, 0x18C4, 0x18C5, 0x18C6, 0x18C7, 0x18C8, 0x18C9, 0x18CA, /* 184A */
+ 0x18CB, 0x18CC, 0x991DFBC0, 0x991EFBC0, 0x991FFBC0, 0x18CD, 0x18CE, 0x18CF, 0x18D0, 0x18D1, 0x18D2, 0x18D3, 0x18D4, 0x18D5, 0x18D6, 0x18D7, 0x18D8, 0x992CFBC0, 0x992DFBC0, 0x992EFBC0, 0x992FFBC0, 0x18D9, 0x18DA, 0x18DB, 0x18DC, 0x18DD, 0x18DE, 0x18DF, 0x18E0, 0x18E1, 0, 0, 0, 0x993CFBC0, 0x993DFBC0, 0x993EFBC0, 0x993FFBC0, 0x30D, 0x9941FBC0, 0x9942FBC0, 0x9943FBC0, 0x254, 0x25B, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x19B4, 0x19B5, 0x19B6, 0x19B7, 0x19B8, 0x19B9, 0x19BA, 0x19BB, 0x19BC, 0x19BD, 0x19BE, 0x19BF, 0x19C0, 0x19C1, 0x19C2, 0x19C3, 0x19C4, 0x19C5, 0x19C6, 0x19C7, 0x19C8, 0x19C9, 0x19CA, 0x19CB, 0x19CC, 0x19CD, 0x19CE, 0x19CF, 0x19D0, 0x19D1, 0x996EFBC0, 0x996FFBC0, 0x19D2, 0x19D3, 0x19D4, 0x19D5, 0x19D6, 0x9975FBC0, 0x9976FBC0, 0x9977FBC0, 0x9978FBC0, 0x9979FBC0, 0x997AFBC0, 0x997BFBC0, 0x997CFBC0, 0x997DFBC0, 0x997EFBC0, 0x997FFBC0, 0x9980FBC0, 0x9981FBC0, 0x9982FBC0, 0x9983FBC0, 0x9984FBC0, 0x9985FBC0, 0x9986FBC0, 0x9987FBC0, 0x9988FBC0, 0x9989FBC0, 0x998AFBC0, 0x998BFBC0, 0x998CFBC0, 0x998DFBC0, 0x998EFBC0, 0x998FFBC0, 0x9990FBC0, 0x9991FBC0, 0x9992FBC0, 0x9993FBC0, 0x9994FBC0, 0x9995FBC0, 0x9996FBC0, 0x9997FBC0, 0x9998FBC0, 0x9999FBC0, 0x999AFBC0, 0x999BFBC0, 0x999CFBC0, 0x999DFBC0, 0x999EFBC0, 0x999FFBC0, 0x99A0FBC0, 0x99A1FBC0, 0x99A2FBC0, 0x99A3FBC0, 0x99A4FBC0, 0x99A5FBC0, 0x99A6FBC0, 0x99A7FBC0, 0x99A8FBC0, 0x99A9FBC0, 0x99AAFBC0, 0x99ABFBC0, 0x99ACFBC0, 0x99ADFBC0, 0x99AEFBC0, 0x99AFFBC0, 0x99B0FBC0, 0x99B1FBC0, 0x99B2FBC0, 0x99B3FBC0, 0x99B4FBC0, 0x99B5FBC0, 0x99B6FBC0, 0x99B7FBC0, 0x99B8FBC0, 0x99B9FBC0, 0x99BAFBC0, 0x99BBFBC0, 0x99BCFBC0, 0x99BDFBC0, 0x99BEFBC0, 0x99BFFBC0, 0x99C0FBC0, 0x99C1FBC0, 0x99C2FBC0, 0x99C3FBC0, 0x99C4FBC0, 0x99C5FBC0, 0x99C6FBC0, 0x99C7FBC0, 0x99C8FBC0, 0x99C9FBC0, 0x99CAFBC0, 0x99CBFBC0, 0x99CCFBC0, 0x99CDFBC0, 0x99CEFBC0, 0x99CFFBC0, 0x99D0FBC0, 0x99D1FBC0, 0x99D2FBC0, 0x99D3FBC0, 0x99D4FBC0, 0x99D5FBC0, 0x99D6FBC0, 0x99D7FBC0, 0x99D8FBC0, 0x99D9FBC0, 0x99DAFBC0, 0x99DBFBC0, 0x99DCFBC0, 0x99DDFBC0, 0x99DEFBC0, 0x99DFFBC0, 0x37B, /* 191B */
+ 0x37C, 0x37D, 0x37E, 0x37F, 0x380, 0x381, 0x382, 0x383, 0x384, 0x385, 0x386, 0x387, 0x388, 0x389, 0x38A, 0x38B, 0x38C, 0x38D, 0x38E, 0x38F, 0x390, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, 0x399, 0x39A, 0x9A00FBC0, 0x9A01FBC0, 0x9A02FBC0, 0x9A03FBC0, 0x9A04FBC0, 0x9A05FBC0, 0x9A06FBC0, 0x9A07FBC0, 0x9A08FBC0, 0x9A09FBC0, 0x9A0AFBC0, 0x9A0BFBC0, 0x9A0CFBC0, 0x9A0DFBC0, 0x9A0EFBC0, 0x9A0FFBC0, 0x9A10FBC0, 0x9A11FBC0, 0x9A12FBC0, 0x9A13FBC0, 0x9A14FBC0, 0x9A15FBC0, 0x9A16FBC0, 0x9A17FBC0, 0x9A18FBC0, 0x9A19FBC0, 0x9A1AFBC0, 0x9A1BFBC0, 0x9A1CFBC0, 0x9A1DFBC0, 0x9A1EFBC0, 0x9A1FFBC0, 0x9A20FBC0, 0x9A21FBC0, 0x9A22FBC0, 0x9A23FBC0, 0x9A24FBC0, 0x9A25FBC0, 0x9A26FBC0, 0x9A27FBC0, 0x9A28FBC0, 0x9A29FBC0, 0x9A2AFBC0, 0x9A2BFBC0, 0x9A2CFBC0, 0x9A2DFBC0, 0x9A2EFBC0, 0x9A2FFBC0, 0x9A30FBC0, 0x9A31FBC0, 0x9A32FBC0, 0x9A33FBC0, 0x9A34FBC0, 0x9A35FBC0, 0x9A36FBC0, 0x9A37FBC0, 0x9A38FBC0, 0x9A39FBC0, 0x9A3AFBC0, 0x9A3BFBC0, 0x9A3CFBC0, 0x9A3DFBC0, 0x9A3EFBC0, 0x9A3FFBC0, 0x9A40FBC0, 0x9A41FBC0, 0x9A42FBC0, 0x9A43FBC0, 0x9A44FBC0, 0x9A45FBC0, 0x9A46FBC0, 0x9A47FBC0, 0x9A48FBC0, 0x9A49FBC0, 0x9A4AFBC0, 0x9A4BFBC0, 0x9A4CFBC0, 0x9A4DFBC0, 0x9A4EFBC0, 0x9A4FFBC0, 0x9A50FBC0, 0x9A51FBC0, 0x9A52FBC0, 0x9A53FBC0, 0x9A54FBC0, 0x9A55FBC0, 0x9A56FBC0, 0x9A57FBC0, 0x9A58FBC0, 0x9A59FBC0, 0x9A5AFBC0, 0x9A5BFBC0, 0x9A5CFBC0, 0x9A5DFBC0, 0x9A5EFBC0, 0x9A5FFBC0, 0x9A60FBC0, 0x9A61FBC0, 0x9A62FBC0, 0x9A63FBC0, 0x9A64FBC0, 0x9A65FBC0, 0x9A66FBC0, 0x9A67FBC0, 0x9A68FBC0, 0x9A69FBC0, 0x9A6AFBC0, 0x9A6BFBC0, 0x9A6CFBC0, 0x9A6DFBC0, 0x9A6EFBC0, 0x9A6FFBC0, 0x9A70FBC0, 0x9A71FBC0, 0x9A72FBC0, 0x9A73FBC0, 0x9A74FBC0, 0x9A75FBC0, 0x9A76FBC0, 0x9A77FBC0, 0x9A78FBC0, 0x9A79FBC0, 0x9A7AFBC0, 0x9A7BFBC0, 0x9A7CFBC0, 0x9A7DFBC0, 0x9A7EFBC0, 0x9A7FFBC0, 0x9A80FBC0, 0x9A81FBC0, 0x9A82FBC0, 0x9A83FBC0, 0x9A84FBC0, 0x9A85FBC0, 0x9A86FBC0, 0x9A87FBC0, 0x9A88FBC0, 0x9A89FBC0, 0x9A8AFBC0, 0x9A8BFBC0, 0x9A8CFBC0, 0x9A8DFBC0, 0x9A8EFBC0, 0x9A8FFBC0, 0x9A90FBC0, 0x9A91FBC0, 0x9A92FBC0, 0x9A93FBC0, 0x9A94FBC0, 0x9A95FBC0, 0x9A96FBC0, 0x9A97FBC0, /* 19E1 */
+ 0x9A98FBC0, 0x9A99FBC0, 0x9A9AFBC0, 0x9A9BFBC0, 0x9A9CFBC0, 0x9A9DFBC0, 0x9A9EFBC0, 0x9A9FFBC0, 0x9AA0FBC0, 0x9AA1FBC0, 0x9AA2FBC0, 0x9AA3FBC0, 0x9AA4FBC0, 0x9AA5FBC0, 0x9AA6FBC0, 0x9AA7FBC0, 0x9AA8FBC0, 0x9AA9FBC0, 0x9AAAFBC0, 0x9AABFBC0, 0x9AACFBC0, 0x9AADFBC0, 0x9AAEFBC0, 0x9AAFFBC0, 0x9AB0FBC0, 0x9AB1FBC0, 0x9AB2FBC0, 0x9AB3FBC0, 0x9AB4FBC0, 0x9AB5FBC0, 0x9AB6FBC0, 0x9AB7FBC0, 0x9AB8FBC0, 0x9AB9FBC0, 0x9ABAFBC0, 0x9ABBFBC0, 0x9ABCFBC0, 0x9ABDFBC0, 0x9ABEFBC0, 0x9ABFFBC0, 0x9AC0FBC0, 0x9AC1FBC0, 0x9AC2FBC0, 0x9AC3FBC0, 0x9AC4FBC0, 0x9AC5FBC0, 0x9AC6FBC0, 0x9AC7FBC0, 0x9AC8FBC0, 0x9AC9FBC0, 0x9ACAFBC0, 0x9ACBFBC0, 0x9ACCFBC0, 0x9ACDFBC0, 0x9ACEFBC0, 0x9ACFFBC0, 0x9AD0FBC0, 0x9AD1FBC0, 0x9AD2FBC0, 0x9AD3FBC0, 0x9AD4FBC0, 0x9AD5FBC0, 0x9AD6FBC0, 0x9AD7FBC0, 0x9AD8FBC0, 0x9AD9FBC0, 0x9ADAFBC0, 0x9ADBFBC0, 0x9ADCFBC0, 0x9ADDFBC0, 0x9ADEFBC0, 0x9ADFFBC0, 0x9AE0FBC0, 0x9AE1FBC0, 0x9AE2FBC0, 0x9AE3FBC0, 0x9AE4FBC0, 0x9AE5FBC0, 0x9AE6FBC0, 0x9AE7FBC0, 0x9AE8FBC0, 0x9AE9FBC0, 0x9AEAFBC0, 0x9AEBFBC0, 0x9AECFBC0, 0x9AEDFBC0, 0x9AEEFBC0, 0x9AEFFBC0, 0x9AF0FBC0, 0x9AF1FBC0, 0x9AF2FBC0, 0x9AF3FBC0, 0x9AF4FBC0, 0x9AF5FBC0, 0x9AF6FBC0, 0x9AF7FBC0, 0x9AF8FBC0, 0x9AF9FBC0, 0x9AFAFBC0, 0x9AFBFBC0, 0x9AFCFBC0, 0x9AFDFBC0, 0x9AFEFBC0, 0x9AFFFBC0, 0x9B00FBC0, 0x9B01FBC0, 0x9B02FBC0, 0x9B03FBC0, 0x9B04FBC0, 0x9B05FBC0, 0x9B06FBC0, 0x9B07FBC0, 0x9B08FBC0, 0x9B09FBC0, 0x9B0AFBC0, 0x9B0BFBC0, 0x9B0CFBC0, 0x9B0DFBC0, 0x9B0EFBC0, 0x9B0FFBC0, 0x9B10FBC0, 0x9B11FBC0, 0x9B12FBC0, 0x9B13FBC0, 0x9B14FBC0, 0x9B15FBC0, 0x9B16FBC0, 0x9B17FBC0, 0x9B18FBC0, 0x9B19FBC0, 0x9B1AFBC0, 0x9B1BFBC0, 0x9B1CFBC0, 0x9B1DFBC0, 0x9B1EFBC0, 0x9B1FFBC0, 0x9B20FBC0, 0x9B21FBC0, 0x9B22FBC0, 0x9B23FBC0, 0x9B24FBC0, 0x9B25FBC0, 0x9B26FBC0, 0x9B27FBC0, 0x9B28FBC0, 0x9B29FBC0, 0x9B2AFBC0, 0x9B2BFBC0, 0x9B2CFBC0, 0x9B2DFBC0, 0x9B2EFBC0, 0x9B2FFBC0, 0x9B30FBC0, 0x9B31FBC0, 0x9B32FBC0, 0x9B33FBC0, 0x9B34FBC0, 0x9B35FBC0, 0x9B36FBC0, 0x9B37FBC0, 0x9B38FBC0, 0x9B39FBC0, 0x9B3AFBC0, 0x9B3BFBC0, 0x9B3CFBC0, 0x9B3DFBC0, 0x9B3EFBC0, 0x9B3FFBC0, 0x9B40FBC0, 0x9B41FBC0, /* 1A98 */
+ 0x9B42FBC0, 0x9B43FBC0, 0x9B44FBC0, 0x9B45FBC0, 0x9B46FBC0, 0x9B47FBC0, 0x9B48FBC0, 0x9B49FBC0, 0x9B4AFBC0, 0x9B4BFBC0, 0x9B4CFBC0, 0x9B4DFBC0, 0x9B4EFBC0, 0x9B4FFBC0, 0x9B50FBC0, 0x9B51FBC0, 0x9B52FBC0, 0x9B53FBC0, 0x9B54FBC0, 0x9B55FBC0, 0x9B56FBC0, 0x9B57FBC0, 0x9B58FBC0, 0x9B59FBC0, 0x9B5AFBC0, 0x9B5BFBC0, 0x9B5CFBC0, 0x9B5DFBC0, 0x9B5EFBC0, 0x9B5FFBC0, 0x9B60FBC0, 0x9B61FBC0, 0x9B62FBC0, 0x9B63FBC0, 0x9B64FBC0, 0x9B65FBC0, 0x9B66FBC0, 0x9B67FBC0, 0x9B68FBC0, 0x9B69FBC0, 0x9B6AFBC0, 0x9B6BFBC0, 0x9B6CFBC0, 0x9B6DFBC0, 0x9B6EFBC0, 0x9B6FFBC0, 0x9B70FBC0, 0x9B71FBC0, 0x9B72FBC0, 0x9B73FBC0, 0x9B74FBC0, 0x9B75FBC0, 0x9B76FBC0, 0x9B77FBC0, 0x9B78FBC0, 0x9B79FBC0, 0x9B7AFBC0, 0x9B7BFBC0, 0x9B7CFBC0, 0x9B7DFBC0, 0x9B7EFBC0, 0x9B7FFBC0, 0x9B80FBC0, 0x9B81FBC0, 0x9B82FBC0, 0x9B83FBC0, 0x9B84FBC0, 0x9B85FBC0, 0x9B86FBC0, 0x9B87FBC0, 0x9B88FBC0, 0x9B89FBC0, 0x9B8AFBC0, 0x9B8BFBC0, 0x9B8CFBC0, 0x9B8DFBC0, 0x9B8EFBC0, 0x9B8FFBC0, 0x9B90FBC0, 0x9B91FBC0, 0x9B92FBC0, 0x9B93FBC0, 0x9B94FBC0, 0x9B95FBC0, 0x9B96FBC0, 0x9B97FBC0, 0x9B98FBC0, 0x9B99FBC0, 0x9B9AFBC0, 0x9B9BFBC0, 0x9B9CFBC0, 0x9B9DFBC0, 0x9B9EFBC0, 0x9B9FFBC0, 0x9BA0FBC0, 0x9BA1FBC0, 0x9BA2FBC0, 0x9BA3FBC0, 0x9BA4FBC0, 0x9BA5FBC0, 0x9BA6FBC0, 0x9BA7FBC0, 0x9BA8FBC0, 0x9BA9FBC0, 0x9BAAFBC0, 0x9BABFBC0, 0x9BACFBC0, 0x9BADFBC0, 0x9BAEFBC0, 0x9BAFFBC0, 0x9BB0FBC0, 0x9BB1FBC0, 0x9BB2FBC0, 0x9BB3FBC0, 0x9BB4FBC0, 0x9BB5FBC0, 0x9BB6FBC0, 0x9BB7FBC0, 0x9BB8FBC0, 0x9BB9FBC0, 0x9BBAFBC0, 0x9BBBFBC0, 0x9BBCFBC0, 0x9BBDFBC0, 0x9BBEFBC0, 0x9BBFFBC0, 0x9BC0FBC0, 0x9BC1FBC0, 0x9BC2FBC0, 0x9BC3FBC0, 0x9BC4FBC0, 0x9BC5FBC0, 0x9BC6FBC0, 0x9BC7FBC0, 0x9BC8FBC0, 0x9BC9FBC0, 0x9BCAFBC0, 0x9BCBFBC0, 0x9BCCFBC0, 0x9BCDFBC0, 0x9BCEFBC0, 0x9BCFFBC0, 0x9BD0FBC0, 0x9BD1FBC0, 0x9BD2FBC0, 0x9BD3FBC0, 0x9BD4FBC0, 0x9BD5FBC0, 0x9BD6FBC0, 0x9BD7FBC0, 0x9BD8FBC0, 0x9BD9FBC0, 0x9BDAFBC0, 0x9BDBFBC0, 0x9BDCFBC0, 0x9BDDFBC0, 0x9BDEFBC0, 0x9BDFFBC0, 0x9BE0FBC0, 0x9BE1FBC0, 0x9BE2FBC0, 0x9BE3FBC0, 0x9BE4FBC0, 0x9BE5FBC0, 0x9BE6FBC0, 0x9BE7FBC0, 0x9BE8FBC0, 0x9BE9FBC0, 0x9BEAFBC0, 0x9BEBFBC0, /* 1B42 */
+ 0x9BECFBC0, 0x9BEDFBC0, 0x9BEEFBC0, 0x9BEFFBC0, 0x9BF0FBC0, 0x9BF1FBC0, 0x9BF2FBC0, 0x9BF3FBC0, 0x9BF4FBC0, 0x9BF5FBC0, 0x9BF6FBC0, 0x9BF7FBC0, 0x9BF8FBC0, 0x9BF9FBC0, 0x9BFAFBC0, 0x9BFBFBC0, 0x9BFCFBC0, 0x9BFDFBC0, 0x9BFEFBC0, 0x9BFFFBC0, 0x9C00FBC0, 0x9C01FBC0, 0x9C02FBC0, 0x9C03FBC0, 0x9C04FBC0, 0x9C05FBC0, 0x9C06FBC0, 0x9C07FBC0, 0x9C08FBC0, 0x9C09FBC0, 0x9C0AFBC0, 0x9C0BFBC0, 0x9C0CFBC0, 0x9C0DFBC0, 0x9C0EFBC0, 0x9C0FFBC0, 0x9C10FBC0, 0x9C11FBC0, 0x9C12FBC0, 0x9C13FBC0, 0x9C14FBC0, 0x9C15FBC0, 0x9C16FBC0, 0x9C17FBC0, 0x9C18FBC0, 0x9C19FBC0, 0x9C1AFBC0, 0x9C1BFBC0, 0x9C1CFBC0, 0x9C1DFBC0, 0x9C1EFBC0, 0x9C1FFBC0, 0x9C20FBC0, 0x9C21FBC0, 0x9C22FBC0, 0x9C23FBC0, 0x9C24FBC0, 0x9C25FBC0, 0x9C26FBC0, 0x9C27FBC0, 0x9C28FBC0, 0x9C29FBC0, 0x9C2AFBC0, 0x9C2BFBC0, 0x9C2CFBC0, 0x9C2DFBC0, 0x9C2EFBC0, 0x9C2FFBC0, 0x9C30FBC0, 0x9C31FBC0, 0x9C32FBC0, 0x9C33FBC0, 0x9C34FBC0, 0x9C35FBC0, 0x9C36FBC0, 0x9C37FBC0, 0x9C38FBC0, 0x9C39FBC0, 0x9C3AFBC0, 0x9C3BFBC0, 0x9C3CFBC0, 0x9C3DFBC0, 0x9C3EFBC0, 0x9C3FFBC0, 0x9C40FBC0, 0x9C41FBC0, 0x9C42FBC0, 0x9C43FBC0, 0x9C44FBC0, 0x9C45FBC0, 0x9C46FBC0, 0x9C47FBC0, 0x9C48FBC0, 0x9C49FBC0, 0x9C4AFBC0, 0x9C4BFBC0, 0x9C4CFBC0, 0x9C4DFBC0, 0x9C4EFBC0, 0x9C4FFBC0, 0x9C50FBC0, 0x9C51FBC0, 0x9C52FBC0, 0x9C53FBC0, 0x9C54FBC0, 0x9C55FBC0, 0x9C56FBC0, 0x9C57FBC0, 0x9C58FBC0, 0x9C59FBC0, 0x9C5AFBC0, 0x9C5BFBC0, 0x9C5CFBC0, 0x9C5DFBC0, 0x9C5EFBC0, 0x9C5FFBC0, 0x9C60FBC0, 0x9C61FBC0, 0x9C62FBC0, 0x9C63FBC0, 0x9C64FBC0, 0x9C65FBC0, 0x9C66FBC0, 0x9C67FBC0, 0x9C68FBC0, 0x9C69FBC0, 0x9C6AFBC0, 0x9C6BFBC0, 0x9C6CFBC0, 0x9C6DFBC0, 0x9C6EFBC0, 0x9C6FFBC0, 0x9C70FBC0, 0x9C71FBC0, 0x9C72FBC0, 0x9C73FBC0, 0x9C74FBC0, 0x9C75FBC0, 0x9C76FBC0, 0x9C77FBC0, 0x9C78FBC0, 0x9C79FBC0, 0x9C7AFBC0, 0x9C7BFBC0, 0x9C7CFBC0, 0x9C7DFBC0, 0x9C7EFBC0, 0x9C7FFBC0, 0x9C80FBC0, 0x9C81FBC0, 0x9C82FBC0, 0x9C83FBC0, 0x9C84FBC0, 0x9C85FBC0, 0x9C86FBC0, 0x9C87FBC0, 0x9C88FBC0, 0x9C89FBC0, 0x9C8AFBC0, 0x9C8BFBC0, 0x9C8CFBC0, 0x9C8DFBC0, 0x9C8EFBC0, 0x9C8FFBC0, 0x9C90FBC0, 0x9C91FBC0, 0x9C92FBC0, 0x9C93FBC0, 0x9C94FBC0, 0x9C95FBC0, /* 1BEC */
+ 0x9C96FBC0, 0x9C97FBC0, 0x9C98FBC0, 0x9C99FBC0, 0x9C9AFBC0, 0x9C9BFBC0, 0x9C9CFBC0, 0x9C9DFBC0, 0x9C9EFBC0, 0x9C9FFBC0, 0x9CA0FBC0, 0x9CA1FBC0, 0x9CA2FBC0, 0x9CA3FBC0, 0x9CA4FBC0, 0x9CA5FBC0, 0x9CA6FBC0, 0x9CA7FBC0, 0x9CA8FBC0, 0x9CA9FBC0, 0x9CAAFBC0, 0x9CABFBC0, 0x9CACFBC0, 0x9CADFBC0, 0x9CAEFBC0, 0x9CAFFBC0, 0x9CB0FBC0, 0x9CB1FBC0, 0x9CB2FBC0, 0x9CB3FBC0, 0x9CB4FBC0, 0x9CB5FBC0, 0x9CB6FBC0, 0x9CB7FBC0, 0x9CB8FBC0, 0x9CB9FBC0, 0x9CBAFBC0, 0x9CBBFBC0, 0x9CBCFBC0, 0x9CBDFBC0, 0x9CBEFBC0, 0x9CBFFBC0, 0x9CC0FBC0, 0x9CC1FBC0, 0x9CC2FBC0, 0x9CC3FBC0, 0x9CC4FBC0, 0x9CC5FBC0, 0x9CC6FBC0, 0x9CC7FBC0, 0x9CC8FBC0, 0x9CC9FBC0, 0x9CCAFBC0, 0x9CCBFBC0, 0x9CCCFBC0, 0x9CCDFBC0, 0x9CCEFBC0, 0x9CCFFBC0, 0x9CD0FBC0, 0x9CD1FBC0, 0x9CD2FBC0, 0x9CD3FBC0, 0x9CD4FBC0, 0x9CD5FBC0, 0x9CD6FBC0, 0x9CD7FBC0, 0x9CD8FBC0, 0x9CD9FBC0, 0x9CDAFBC0, 0x9CDBFBC0, 0x9CDCFBC0, 0x9CDDFBC0, 0x9CDEFBC0, 0x9CDFFBC0, 0x9CE0FBC0, 0x9CE1FBC0, 0x9CE2FBC0, 0x9CE3FBC0, 0x9CE4FBC0, 0x9CE5FBC0, 0x9CE6FBC0, 0x9CE7FBC0, 0x9CE8FBC0, 0x9CE9FBC0, 0x9CEAFBC0, 0x9CEBFBC0, 0x9CECFBC0, 0x9CEDFBC0, 0x9CEEFBC0, 0x9CEFFBC0, 0x9CF0FBC0, 0x9CF1FBC0, 0x9CF2FBC0, 0x9CF3FBC0, 0x9CF4FBC0, 0x9CF5FBC0, 0x9CF6FBC0, 0x9CF7FBC0, 0x9CF8FBC0, 0x9CF9FBC0, 0x9CFAFBC0, 0x9CFBFBC0, 0x9CFCFBC0, 0x9CFDFBC0, 0x9CFEFBC0, 0x9CFFFBC0, 0xE37, 0xE3C, 0xE3D, 0xE57, 0xE64, 0xE71, 0xE8A, 0xE8F, 0xEA8, 0xF07, 0xF14, 0xF25, 0xF3A, 0xF5F, 0xF6D, 0xF86, 0xF96, 0xF87, 0xF97, 0xF91, 0xF8C, 0xFA6, 0xF98, 0xF99, 0xFAB, 0xFC8, 0xFCD, 0x1006, 0x1023, 0x1024, 0x1025, 0x103B, 0x1048, 0x1055, 0x106E, 0x1083, 0x10BA, 0x10BB, 0x10EB, 0x10F7, 0x10FD, 0x1101, 0x1108, 0x11B4, 0xE33, 0xE38, 0xE4A, 0xE56, 0xE6D, 0xE8B, 0xE90, 0xEC1, 0xEE1, 0xEFB, 0xF10, 0xF21, 0xF2E, 0xF5B, 0xF64, 0xF6C, 0xF82, 0xFA2, 0xFA7, 0xFC0, 0x1002, 0x101F, 0x1051, 0xE33, 0xE3E, 0xE42, 0xE3D, 0xE4A, 0xE6D, 0xE8B, 0xE94, 0xE98, 0xEA8, 0xEC1, 0xF07, 0xF21, 0xF5B, 0xF7E, 0xF82, 0xF92, 0xF98, 0xF99, 0xFA7, 0x1002, 0x101F, 0x1024, 0x1037, 0x1044, 0x10BB, 0x10E9, 0x10EA, 0x10EC, 0x1105, 0x1106, 0xEFB, 0xFC0, 0x101F, 0x1044, 0x10E9, 0x10EA, 0x1100, /* 1C96 */
+ 0x1105, 0x1106, 0x1026, 0x9D6CFBC0, 0x9D6DFBC0, 0x9D6EFBC0, 0x9D6FFBC0, 0x9D70FBC0, 0x9D71FBC0, 0x9D72FBC0, 0x9D73FBC0, 0x9D74FBC0, 0x9D75FBC0, 0x9D76FBC0, 0x9D77FBC0, 0x9D78FBC0, 0x9D79FBC0, 0x9D7AFBC0, 0x9D7BFBC0, 0x9D7CFBC0, 0x9D7DFBC0, 0x9D7EFBC0, 0x9D7FFBC0, 0x9D80FBC0, 0x9D81FBC0, 0x9D82FBC0, 0x9D83FBC0, 0x9D84FBC0, 0x9D85FBC0, 0x9D86FBC0, 0x9D87FBC0, 0x9D88FBC0, 0x9D89FBC0, 0x9D8AFBC0, 0x9D8BFBC0, 0x9D8CFBC0, 0x9D8DFBC0, 0x9D8EFBC0, 0x9D8FFBC0, 0x9D90FBC0, 0x9D91FBC0, 0x9D92FBC0, 0x9D93FBC0, 0x9D94FBC0, 0x9D95FBC0, 0x9D96FBC0, 0x9D97FBC0, 0x9D98FBC0, 0x9D99FBC0, 0x9D9AFBC0, 0x9D9BFBC0, 0x9D9CFBC0, 0x9D9DFBC0, 0x9D9EFBC0, 0x9D9FFBC0, 0x9DA0FBC0, 0x9DA1FBC0, 0x9DA2FBC0, 0x9DA3FBC0, 0x9DA4FBC0, 0x9DA5FBC0, 0x9DA6FBC0, 0x9DA7FBC0, 0x9DA8FBC0, 0x9DA9FBC0, 0x9DAAFBC0, 0x9DABFBC0, 0x9DACFBC0, 0x9DADFBC0, 0x9DAEFBC0, 0x9DAFFBC0, 0x9DB0FBC0, 0x9DB1FBC0, 0x9DB2FBC0, 0x9DB3FBC0, 0x9DB4FBC0, 0x9DB5FBC0, 0x9DB6FBC0, 0x9DB7FBC0, 0x9DB8FBC0, 0x9DB9FBC0, 0x9DBAFBC0, 0x9DBBFBC0, 0x9DBCFBC0, 0x9DBDFBC0, 0x9DBEFBC0, 0x9DBFFBC0, 0x9DC0FBC0, 0x9DC1FBC0, 0x9DC2FBC0, 0x9DC3FBC0, 0x9DC4FBC0, 0x9DC5FBC0, 0x9DC6FBC0, 0x9DC7FBC0, 0x9DC8FBC0, 0x9DC9FBC0, 0x9DCAFBC0, 0x9DCBFBC0, 0x9DCCFBC0, 0x9DCDFBC0, 0x9DCEFBC0, 0x9DCFFBC0, 0x9DD0FBC0, 0x9DD1FBC0, 0x9DD2FBC0, 0x9DD3FBC0, 0x9DD4FBC0, 0x9DD5FBC0, 0x9DD6FBC0, 0x9DD7FBC0, 0x9DD8FBC0, 0x9DD9FBC0, 0x9DDAFBC0, 0x9DDBFBC0, 0x9DDCFBC0, 0x9DDDFBC0, 0x9DDEFBC0, 0x9DDFFBC0, 0x9DE0FBC0, 0x9DE1FBC0, 0x9DE2FBC0, 0x9DE3FBC0, 0x9DE4FBC0, 0x9DE5FBC0, 0x9DE6FBC0, 0x9DE7FBC0, 0x9DE8FBC0, 0x9DE9FBC0, 0x9DEAFBC0, 0x9DEBFBC0, 0x9DECFBC0, 0x9DEDFBC0, 0x9DEEFBC0, 0x9DEFFBC0, 0x9DF0FBC0, 0x9DF1FBC0, 0x9DF2FBC0, 0x9DF3FBC0, 0x9DF4FBC0, 0x9DF5FBC0, 0x9DF6FBC0, 0x9DF7FBC0, 0x9DF8FBC0, 0x9DF9FBC0, 0x9DFAFBC0, 0x9DFBFBC0, 0x9DFCFBC0, 0x9DFDFBC0, 0x9DFEFBC0, 0x9DFFFBC0, 0xE33, 0xE33, 0xE4A, 0xE4A, 0xE4A, 0xE4A, 0xE4A, 0xE4A, 0xE60, 0xE60, 0xE6D, 0xE6D, 0xE6D, 0xE6D, 0xE6D, 0xE6D, 0xE6D, 0xE6D, 0xE6D, 0xE6D, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xEB9, 0xEB9, 0xEC1, 0xEC1, 0xEE1, /* 1D69 */
+ 0xEE1, 0xEE1, 0xEE1, 0xEE1, 0xEE1, 0xEE1, 0xEE1, 0xEE1, 0xEE1, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xF21, 0xF21, 0xF21, 0xF21, 0xF21, 0xF21, 0xF2E, 0xF2E, 0xF2E, 0xF2E, 0xF2E, 0xF2E, 0xF2E, 0xF2E, 0xF5B, 0xF5B, 0xF5B, 0xF5B, 0xF5B, 0xF5B, 0xF64, 0xF64, 0xF64, 0xF64, 0xF64, 0xF64, 0xF64, 0xF64, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xFA7, 0xFA7, 0xFA7, 0xFA7, 0xFC0, 0xFC0, 0xFC0, 0xFC0, 0xFC0, 0xFC0, 0xFC0, 0xFC0, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0xFEA, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x1002, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x1044, 0x1044, 0x1044, 0x1044, 0x1051, 0x1051, 0x1051, 0x1051, 0x1051, 0x1051, 0x1051, 0x1051, 0x1051, 0x1051, 0x105A, 0x105A, 0x105A, 0x105A, 0x105E, 0x105E, 0x106A, 0x106A, 0x106A, 0x106A, 0x106A, 0x106A, 0xEE1, 0x1002, 0x1051, 0x105E, 0x10B30E33, 0xFEA, 0x9E9CFBC0, 0x9E9DFBC0, 0x9E9EFBC0, 0x9E9FFBC0, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE33, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xE8B, 0xEFB, 0xEFB, 0xEFB, 0xEFB, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0xF82, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x101F, 0x105E, 0x105E, 0x105E, 0x105E, 0x105E, 0x105E, 0x105E, 0x105E, 0x9EFAFBC0, 0x9EFBFBC0, 0x9EFCFBC0, 0x9EFDFBC0, 0x9EFEFBC0, 0x9EFFFBC0, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10ED, 0x10ED, 0x10ED, 0x10ED, 0x10ED, 0x10ED, 0x9F16FBC0, 0x9F17FBC0, 0x10ED, 0x10ED, 0x10ED, 0x10ED, 0x10ED, 0x10ED, 0x9F1EFBC0, 0x9F1FFBC0, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, /* 1E23 */
+ 0x10F1, 0x10F1, 0x10F1, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10FB, 0x10FB, 0x10FB, 0x10FB, 0x10FB, 0x10FB, 0x9F46FBC0, 0x9F47FBC0, 0x10FB, 0x10FB, 0x10FB, 0x10FB, 0x10FB, 0x10FB, 0x9F4EFBC0, 0x9F4FFBC0, 0x1104, 0x1104, 0x1104, 0x1104, 0x1104, 0x1104, 0x1104, 0x1104, 0x9F58FBC0, 0x1104, 0x9F5AFBC0, 0x1104, 0x9F5CFBC0, 0x1104, 0x9F5EFBC0, 0x1104, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x10E8, 0x10E8, 0x10ED, 0x10ED, 0x10F1, 0x10F1, 0x10F3, 0x10F3, 0x10FB, 0x10FB, 0x1104, 0x1104, 0x1109, 0x1109, 0x9F7EFBC0, 0x9F7FFBC0, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x10F1, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x9FB5FBC0, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x10E8, 0x217, 0x10F3, 0x217, 0x21D, 0x214, 0x10F1, 0x10F1, 0x10F1, 0x9FC5FBC0, 0x10F1, 0x10F1, 0x10ED, 0x10ED, 0x10F1, 0x10F1, 0x10F1, 0x217, 0x217, 0x217, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x9FD4FBC0, 0x9FD5FBC0, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x10F3, 0x9FDCFBC0, 0x218, 0x218, 0x218, 0x1104, 0x1104, 0x1104, 0x1104, 0x1100, 0x1100, 0x1104, 0x1104, 0x1104, 0x1104, 0x1104, 0x1104, 0x1100, 0x214, 0x214, 0x20C, 0x9FF0FBC0, 0x9FF1FBC0, 0x1109, 0x1109, 0x1109, 0x9FF5FBC0, 0x1109, 0x1109, 0x10FB, 0x10FB, 0x1109, 0x1109, 0x1109, 0x20D, 0x218, 0x9FFFFBC0, 0x209, 0x209, 0x209, 0x209, 0x209, 0x209, 0x209, 0x209, 0x209, 0x209, 0x209, 0, 0, 0, 0, 0, 0x225, 0x225, 0x226, 0x227, 0x228, 0x229, 0x432, 0x21C, 0x278, 0x279, 0x27A, 0x27B, 0x27F, 0x280, 0x281, 0x282, 0x2D8, 0x2D9, 0x2DA, 0x2DB, 0x25D, 0x25D025D, 0x25D025D025D, 0x2DC, 0x207, 0x208, 0, 0, 0, 0, /* 1F2D */
+ 0, 0x209, 0x2D5, 0x2D6, 0x2E0, 0x2E002E0, 0x2E002E002E0, 0x2E1, 0x2E102E1, 0x2E102E102E1, 0x2E4, 0x27C, 0x27D, 0x2E5, 0x2510251, 0x25C, 0x211, 0x2E6, 0x2E8, 0x2EA, 0x2EB, 0x2DD, 0x2CD, 0x294, 0x295, 0x2550255, 0x2510255, 0x2550251, 0x2D1, 0x2C4, 0x2DE, 0x2DF, 0x2C9, 0x23C, 0x2E9, 0x2CA, 0x2D7, 0x22A, 0x2E7, 0xA055FBC0, 0xA056FBC0, 0x2E002E002E002E0, 0xA058FBC0, 0xA059FBC0, 0xA05AFBC0, 0xA05BFBC0, 0xA05CFBC0, 0xA05DFBC0, 0xA05EFBC0, 0x209, 0, 0, 0, 0, 0xA064FBC0, 0xA065FBC0, 0xA066FBC0, 0xA067FBC0, 0xA068FBC0, 0xA069FBC0, 0, 0, 0, 0, 0, 0, 0xE29, 0xEFB, 0xA072FBC0, 0xA073FBC0, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x428, 0x434, 0x42D, 0x288, 0x289, 0xF64, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x428, 0x434, 0x42D, 0x288, 0x289, 0xA08FFBC0, 0xA090FBC0, 0xA091FBC0, 0xA092FBC0, 0xA093FBC0, 0xA094FBC0, 0xA095FBC0, 0xA096FBC0, 0xA097FBC0, 0xA098FBC0, 0xA099FBC0, 0xA09AFBC0, 0xA09BFBC0, 0xA09CFBC0, 0xA09DFBC0, 0xA09EFBC0, 0xA09FFBC0, 0xE18, 0xE19, 0xE1A, 0xE1B, 0xE1C, 0xE1D, 0xE1E, 0xE1F, 0xFEA0FC0, 0xE20, 0xE21, 0xE22, 0xE23, 0xE24, 0xE25, 0xE26, 0xE27, 0xE28, 0xA0B2FBC0, 0xA0B3FBC0, 0xA0B4FBC0, 0xA0B5FBC0, 0xA0B6FBC0, 0xA0B7FBC0, 0xA0B8FBC0, 0xA0B9FBC0, 0xA0BAFBC0, 0xA0BBFBC0, 0xA0BCFBC0, 0xA0BDFBC0, 0xA0BEFBC0, 0xA0BFFBC0, 0xA0C0FBC0, 0xA0C1FBC0, 0xA0C2FBC0, 0xA0C3FBC0, 0xA0C4FBC0, 0xA0C5FBC0, 0xA0C6FBC0, 0xA0C7FBC0, 0xA0C8FBC0, 0xA0C9FBC0, 0xA0CAFBC0, 0xA0CBFBC0, 0xA0CCFBC0, 0xA0CDFBC0, 0xA0CEFBC0, 0xA0CFFBC0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xA0EBFBC0, 0xA0ECFBC0, 0xA0EDFBC0, 0xA0EEFBC0, 0xA0EFFBC0, 0xA0F0FBC0, 0xA0F1FBC0, 0xA0F2FBC0, 0xA0F3FBC0, 0xA0F4FBC0, 0xA0F5FBC0, 0xA0F6FBC0, 0xA0F7FBC0, 0xA0F8FBC0, 0xA0F9FBC0, 0xA0FAFBC0, 0xA0FBFBC0, 0xA0FCFBC0, 0xA0FDFBC0, 0xA0FEFBC0, 0xA0FFFBC0, 0xE6002CC0E33, 0xFEA02CC0E33, 0xE60, 0xE60034A, 0x39B, 0xF8202CC0E60, 0x101F02CC0E60, 0xE98, 0x39C, 0xEB9034A, 0xEC1, 0xEE1, 0xEE1, 0xEE1, 0xEE1, 0xEED, 0xEFB, 0xEFB, 0xF2E, 0xF2E, 0x39D, 0xF64, 0xF820F64, 0x39E, 0x39F, 0xFA7, 0xFB4, 0xFC0, 0xFC0, /* 202E */
+ 0xFC0, 0x3A0, 0x3A1, 0xF5B0FEA, 0xF2E0E8B1002, 0xF5B1002, 0x3A2, 0x106A, 0x3A3, 0x1109, 0x3A4, 0x106A, 0x3A5, 0xF21, 0xE33, 0xE4A, 0xE60, 0x3A6, 0xE8B, 0xE8B, 0xEB9, 0x3A7, 0xF5B, 0xF82, 0x1331, 0x1332, 0x1333, 0x1334, 0xEFB, 0x3A8, 0x105A0E330EB9, 0xA13CFBC0, 0x10EA, 0x10EA, 0x10FC, 0x427, 0x3A9, 0x3AA, 0x3AB, 0x3AC, 0xE6D, 0xE6D, 0xE8B, 0xEFB, 0xF10, 0x3AD, 0x2D0, 0xA14CFBC0, 0xA14DFBC0, 0xA14EFBC0, 0xA14FFBC0, 0xA150FBC0, 0xA151FBC0, 0xA152FBC0, 0xE2C02CD0E2A, 0xE2C02CD0E2B, 0xE2E02CD0E2A, 0xE2E02CD0E2B, 0xE2E02CD0E2C, 0xE2E02CD0E2D, 0xE2F02CD0E2A, 0xE2F02CD0E2E, 0xE3102CD0E2A, 0xE3102CD0E2C, 0xE3102CD0E2E, 0xE3102CD0E30, 0x2CD0E2A, 0xEFB, 0xEFB0EFB, 0xEFB0EFB0EFB, 0x10440EFB, 0x1044, 0xEFB1044, 0xEFB0EFB1044, 0xEFB0EFB0EFB1044, 0x105A0EFB, 0x105A, 0xEFB105A, 0xEFB0EFB105A, 0xF2E, 0xE60, 0xE6D, 0xF5B, 0xEFB, 0xEFB0EFB, 0xEFB0EFB0EFB, 0x10440EFB, 0x1044, 0xEFB1044, 0xEFB0EFB1044, 0xEFB0EFB0EFB1044, 0x105A0EFB, 0x105A, 0xEFB105A, 0xEFB0EFB105A, 0xF2E, 0xE60, 0xE6D, 0xF5B, 0xDD7, 0xDD8, 0xDD9, 0xDDA, 0xA184FBC0, 0xA185FBC0, 0xA186FBC0, 0xA187FBC0, 0xA188FBC0, 0xA189FBC0, 0xA18AFBC0, 0xA18BFBC0, 0xA18CFBC0, 0xA18DFBC0, 0xA18EFBC0, 0xA18FFBC0, 0x3AE, 0x3B0, 0x3AF, 0x3B1, 0x3B2, 0x3B3, 0x3B4, 0x3B5, 0x3B6, 0x3B7, 0x3AE, 0x3AF, 0x3B8, 0x3B9, 0x3BA, 0x3BB, 0x3BC, 0x3BD, 0x3BE, 0x3BF, 0x3C0, 0x3C1, 0x3C2, 0x3C3, 0x3C4, 0x3C5, 0x3C6, 0x3C7, 0x3C8, 0x3C9, 0x3B2, 0x3CA, 0x3CB, 0x3CC, 0x3CD, 0x3CE, 0x3CF, 0x3D0, 0x3D1, 0x3D2, 0x3D3, 0x3D4, 0x3D5, 0x3D6, 0x3D7, 0x3D8, 0x3D9, 0x3DA, 0x3DB, 0x3DC, 0x3DD, 0x3DE, 0x3DF, 0x3E0, 0x3E1, 0x3E2, 0x3E3, 0x3E4, 0x3E5, 0x3E6, 0x3E7, 0x3E8, 0x3EC, 0x3EA, 0x3E8, 0x3E9, 0x3EA, 0x3EB, 0x3EC, 0x3ED, 0x3EE, 0x3EF, 0x3F0, 0x3F1, 0x3F2, 0x3F3, 0x3F4, 0x3F5, 0x3F6, 0x3F7, 0x3F8, 0x3F9, 0x3FA, 0x3FB, 0x3FC, 0x3FD, 0x3FE, 0x3FF, 0x400, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407, 0x408, 0x409, 0x40A, 0x40B, 0x40C, 0x40D, 0x40E, 0x40F, 0x410, 0x411, 0x412, 0x413, 0x414, 0x415, 0x416, 0x417, 0x418, 0x419, 0x41A, 0x41B, 0x41B, 0x41C, 0x41D, 0x41E, 0x41F, 0x41F, 0x420, 0x421, 0x421, 0x422, /* 211D */
+ 0x424, 0x425, 0x426, 0x427, 0x434, 0x435, 0x436, 0x437, 0x438, 0x439, 0x43A, 0x43B, 0x43C, 0x43D, 0x43E, 0x43F, 0x440, 0x441, 0x442, 0x443, 0x444, 0x445, 0x445, 0x446, 0x446, 0x447, 0x448, 0x449, 0x44A, 0x44B, 0x44B044B, 0x44B044B044B, 0x44C, 0x44C044C, 0x44C044C044C, 0x44D, 0x44E, 0x44F, 0x450, 0x451, 0x452, 0x453, 0x454, 0x455, 0x456, 0x457, 0x458, 0x459, 0x45A, 0x45B, 0x45C, 0x458, 0x45D, 0x45E, 0x45E, 0x45F, 0x460, 0x45F, 0x461, 0x461, 0x462, 0x463, 0x464, 0x465, 0x466, 0x467, 0x468, 0x469, 0x46A, 0x46B, 0x46C, 0x46D, 0x46E, 0x46F, 0x470, 0x471, 0x472, 0x473, 0x474, 0x475, 0x476, 0x477, 0x42D, 0x478, 0x478, 0x479, 0x47A, 0x47B, 0x47C, 0x47D, 0x47E, 0x47F, 0x480, 0x481, 0x482, 0x465, 0x42C, 0x42E, 0x47A, 0x47B, 0x483, 0x484, 0x483, 0x484, 0x485, 0x486, 0x485, 0x486, 0x487, 0x488, 0x489, 0x48A, 0x48B, 0x48C, 0x487, 0x488, 0x48D, 0x48E, 0x48D, 0x48E, 0x48F, 0x490, 0x48F, 0x490, 0x491, 0x492, 0x493, 0x494, 0x495, 0x496, 0x497, 0x498, 0x499, 0x49A, 0x49B, 0x49C, 0x49D, 0x49E, 0x49F, 0x4A0, 0x4A1, 0x4A2, 0x4A3, 0x4A4, 0x4A5, 0x4A6, 0x4A7, 0x4A8, 0x4A9, 0x4AA, 0x4AB, 0x4AC, 0x4AD, 0x4AE, 0x4AF, 0x4B0, 0x4B1, 0x4B2, 0x4A9, 0x4AF, 0x4B0, 0x4B2, 0x4B3, 0x4B4, 0x4B5, 0x4B6, 0x4B7, 0x4B8, 0x4B9, 0x4BA, 0x4BB, 0x4BC, 0x4BD, 0x4BE, 0x4BF, 0x4C0, 0x4C1, 0x4C2, 0x4C3, 0x4C4, 0x4C5, 0x4C6, 0x4C7, 0x4C8, 0x4C9, 0x4CA, 0x4CB, 0x4CC, 0x4CD, 0x4CE, 0x4CF, 0x4D0, 0x4D1, 0x4D2, 0x4D3, 0x4D4, 0x4D5, 0x4D6, 0x4D7, 0x4D8, 0x4D9, 0x4DA, 0x4DB, 0x4DC, 0x4DD, 0x4DE, 0x4DF, 0x4E0, 0x4E1, 0x4E2, 0x489, 0x48A, 0x498, 0x499, 0x4E3, 0x4E4, 0x4E5, 0x4E6, 0x4E7, 0x4E8, 0x4B5, 0x4B6, 0x4B7, 0x4B8, 0x4E9, 0x4EA, 0x4EB, 0x4EC, 0x4ED, 0x4EE, 0x4EF, 0x4F0, 0x4F1, 0x4F2, 0x4F3, 0x4F4, 0x4F5, 0x4F6, 0x4F7, 0x4F8, 0x4F9, 0x4FA, 0x4FB, 0x4FC, 0x4FD, 0x4FE, 0x4FF, 0x500, 0x501, 0x502, 0x503, 0x504, 0x505, 0x506, 0x507, 0x508, 0x509, 0x50A, 0x50B, 0x50C, 0x50D, 0x50E, 0x50F, 0x510, 0x511, 0x512, 0x513, 0x514, 0x515, 0x516, 0x517, 0x518, 0x519, 0x51A, 0x51B, 0x51C, 0x51D, 0x51E, 0x51F, 0x520, 0x521, 0x522, 0x523, 0x2AE, 0x2AF, 0x524, 0x525, 0x526, 0x527, /* 220E */
+ 0x528, 0x529, 0x52A, 0x52B, 0x52C, 0x52D, 0x52E, 0x52F, 0x530, 0x531, 0x532, 0x533, 0x534, 0x535, 0x536, 0x537, 0x538, 0x539, 0x53A, 0x53B, 0x53C, 0x53D, 0x53E, 0x53F, 0x540, 0x541, 0x542, 0x543, 0x544, 0x545, 0x546, 0x547, 0x548, 0x549, 0x54A, 0x54B, 0x54C, 0x54D, 0x54E, 0x54F, 0x550, 0x551, 0x552, 0x553, 0x554, 0x555, 0x556, 0x557, 0x558, 0x559, 0x55A, 0x55B, 0x55C, 0x55D, 0x55E, 0x55F, 0x560, 0x561, 0x562, 0x563, 0x564, 0x565, 0x566, 0x567, 0x568, 0x569, 0x56A, 0x56B, 0x56C, 0x56D, 0x56E, 0x56F, 0x570, 0x571, 0x572, 0x573, 0x574, 0x575, 0x576, 0x577, 0x578, 0x579, 0x57A, 0x57B, 0x57C, 0x57D, 0x57E, 0x57F, 0x580, 0x581, 0x582, 0x583, 0x584, 0x585, 0x586, 0x587, 0x588, 0x589, 0x58A, 0x58B, 0x58C, 0x58D, 0x58E, 0x58F, 0x590, 0x591, 0x592, 0x593, 0x594, 0x595, 0x596, 0x597, 0x598, 0x599, 0x59A, 0x59B, 0x59C, 0x59D, 0x59E, 0x59F, 0x5A0, 0x5A1, 0x5A2, 0x5A3, 0x5A4, 0x5A5, 0x5A6, 0x5A7, 0x5A8, 0x5A9, 0x5AA, 0x5AB, 0x5AC, 0x5AD, 0x5AE, 0x5AF, 0x5B0, 0x5B1, 0x5B2, 0x5B3, 0x5B4, 0x5B5, 0x5B6, 0x5B7, 0x5B8, 0x5B9, 0x5BA, 0x5BB, 0x5BC, 0x5BD, 0x5BE, 0x5BF, 0x5C0, 0x5C1, 0x5C2, 0x5C3, 0x5C4, 0x5C5, 0x5C6, 0x5C7, 0x5C8, 0x5C9, 0xA3D1FBC0, 0xA3D2FBC0, 0xA3D3FBC0, 0xA3D4FBC0, 0xA3D5FBC0, 0xA3D6FBC0, 0xA3D7FBC0, 0xA3D8FBC0, 0xA3D9FBC0, 0xA3DAFBC0, 0xA3DBFBC0, 0xA3DCFBC0, 0xA3DDFBC0, 0xA3DEFBC0, 0xA3DFFBC0, 0xA3E0FBC0, 0xA3E1FBC0, 0xA3E2FBC0, 0xA3E3FBC0, 0xA3E4FBC0, 0xA3E5FBC0, 0xA3E6FBC0, 0xA3E7FBC0, 0xA3E8FBC0, 0xA3E9FBC0, 0xA3EAFBC0, 0xA3EBFBC0, 0xA3ECFBC0, 0xA3EDFBC0, 0xA3EEFBC0, 0xA3EFFBC0, 0xA3F0FBC0, 0xA3F1FBC0, 0xA3F2FBC0, 0xA3F3FBC0, 0xA3F4FBC0, 0xA3F5FBC0, 0xA3F6FBC0, 0xA3F7FBC0, 0xA3F8FBC0, 0xA3F9FBC0, 0xA3FAFBC0, 0xA3FBFBC0, 0xA3FCFBC0, 0xA3FDFBC0, 0xA3FEFBC0, 0xA3FFFBC0, 0x5CA, 0x5CB, 0x5CC, 0x5CD, 0x5CE, 0x5CF, 0x5D0, 0x5D1, 0x5D2, 0x5D3, 0x5D4, 0x5D5, 0x5D6, 0x5D7, 0x5D8, 0x5D9, 0x5DA, 0x5DB, 0x5DC, 0x5DD, 0x5DE, 0x5DF, 0x5E0, 0x5E1, 0x5E2, 0x5E3, 0x5E4, 0x5E5, 0x5E6, 0x5E7, 0x5E8, 0x5E9, 0x5EA, 0x5EB, 0x5EC, 0x5ED, 0x5EE, 0x5EF, 0x5F0, 0xA427FBC0, 0xA428FBC0, 0xA429FBC0, 0xA42AFBC0, 0xA42BFBC0, 0xA42CFBC0, /* 232F */
+ 0xA42DFBC0, 0xA42EFBC0, 0xA42FFBC0, 0xA430FBC0, 0xA431FBC0, 0xA432FBC0, 0xA433FBC0, 0xA434FBC0, 0xA435FBC0, 0xA436FBC0, 0xA437FBC0, 0xA438FBC0, 0xA439FBC0, 0xA43AFBC0, 0xA43BFBC0, 0xA43CFBC0, 0xA43DFBC0, 0xA43EFBC0, 0xA43FFBC0, 0x5F1, 0x5F2, 0x5F3, 0x5F4, 0x5F5, 0x5F6, 0x5F7, 0x5F8, 0x5F9, 0x5FA, 0x5FB, 0xA44BFBC0, 0xA44CFBC0, 0xA44DFBC0, 0xA44EFBC0, 0xA44FFBC0, 0xA450FBC0, 0xA451FBC0, 0xA452FBC0, 0xA453FBC0, 0xA454FBC0, 0xA455FBC0, 0xA456FBC0, 0xA457FBC0, 0xA458FBC0, 0xA459FBC0, 0xA45AFBC0, 0xA45BFBC0, 0xA45CFBC0, 0xA45DFBC0, 0xA45EFBC0, 0xA45FFBC0, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0xE290E2A, 0xE2A0E2A, 0xE2B0E2A, 0xE2C0E2A, 0xE2D0E2A, 0xE2E0E2A, 0xE2F0E2A, 0xE300E2A, 0xE310E2A, 0xE320E2A, 0xE290E2B, 0x2890E2A0288, 0x2890E2B0288, 0x2890E2C0288, 0x2890E2D0288, 0x2890E2E0288, 0x2890E2F0288, 0x2890E300288, 0x2890E310288, 0x2890E320288, 0x2890E290E2A0288, 0x2890E2A0E2A0288, 0x2890E2B0E2A0288, 0x2890E2C0E2A0288, 0x2890E2D0E2A0288, 0x2890E2E0E2A0288, 0x2890E2F0E2A0288, 0x2890E300E2A0288, 0x2890E310E2A0288, 0x2890E320E2A0288, 0x2890E290E2B0288, 0x25D0E2A, 0x25D0E2B, 0x25D0E2C, 0x25D0E2D, 0x25D0E2E, 0x25D0E2F, 0x25D0E30, 0x25D0E31, 0x25D0E32, 0x25D0E290E2A, 0x25D0E2A0E2A, 0x25D0E2B0E2A, 0x25D0E2C0E2A, 0x25D0E2D0E2A, 0x25D0E2E0E2A, 0x25D0E2F0E2A, 0x25D0E300E2A, 0x25D0E310E2A, 0x25D0E320E2A, 0x25D0E290E2B, 0x2890E330288, 0x2890E4A0288, 0x2890E600288, 0x2890E6D0288, 0x2890E8B0288, 0x2890EB90288, 0x2890EC10288, 0x2890EE10288, 0x2890EFB0288, 0x2890F100288, 0x2890F210288, 0x2890F2E0288, 0x2890F5B0288, 0x2890F640288, 0x2890F820288, 0x2890FA70288, 0x2890FB40288, 0x2890FC00288, 0x2890FEA0288, 0x28910020288, 0x289101F0288, 0x28910440288, 0x28910510288, 0x289105A0288, 0x289105E0288, 0x289106A0288, 0xE33, 0xE4A, 0xE60, 0xE6D, 0xE8B, 0xEB9, 0xEC1, 0xEE1, 0xEFB, 0xF10, 0xF21, 0xF2E, 0xF5B, 0xF64, 0xF82, 0xFA7, 0xFB4, 0xFC0, 0xFEA, 0x1002, 0x101F, 0x1044, 0x1051, 0x105A, 0x105E, 0x106A, 0xE33, 0xE4A, 0xE60, 0xE6D, 0xE8B, 0xEB9, 0xEC1, 0xEE1, 0xEFB, 0xF10, 0xF21, 0xF2E, 0xF5B, 0xF64, 0xF82, 0xFA7, 0xFB4, /* 242D */
+ 0xFC0, 0xFEA, 0x1002, 0x101F, 0x1044, 0x1051, 0x105A, 0x105E, 0x106A, 0xE29, 0xE2A0E2A, 0xE2B0E2A, 0xE2C0E2A, 0xE2D0E2A, 0xE2E0E2A, 0xE2F0E2A, 0xE300E2A, 0xE310E2A, 0xE320E2A, 0xE290E2B, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0xE290E2A, 0xE29, 0x5FC, 0x5FD, 0x5FE, 0x5FF, 0x600, 0x601, 0x602, 0x603, 0x604, 0x605, 0x606, 0x607, 0x608, 0x609, 0x60A, 0x60B, 0x60C, 0x60D, 0x60E, 0x60F, 0x610, 0x611, 0x612, 0x613, 0x614, 0x615, 0x616, 0x617, 0x618, 0x619, 0x61A, 0x61B, 0x61C, 0x61D, 0x61E, 0x61F, 0x620, 0x621, 0x622, 0x623, 0x624, 0x625, 0x626, 0x627, 0x628, 0x629, 0x62A, 0x62B, 0x62C, 0x62D, 0x62E, 0x62F, 0x630, 0x631, 0x632, 0x633, 0x634, 0x635, 0x636, 0x637, 0x638, 0x639, 0x63A, 0x63B, 0x63C, 0x63D, 0x63E, 0x63F, 0x640, 0x641, 0x642, 0x643, 0x644, 0x645, 0x646, 0x647, 0x648, 0x649, 0x64A, 0x64B, 0x64C, 0x64D, 0x64E, 0x64F, 0x650, 0x651, 0x652, 0x653, 0x654, 0x655, 0x656, 0x657, 0x658, 0x659, 0x65A, 0x65B, 0x65C, 0x65D, 0x65E, 0x65F, 0x660, 0x661, 0x662, 0x663, 0x664, 0x665, 0x666, 0x667, 0x668, 0x669, 0x66A, 0x66B, 0x66C, 0x66D, 0x66E, 0x66F, 0x670, 0x671, 0x672, 0x673, 0x674, 0x675, 0x676, 0x677, 0x678, 0x679, 0x67A, 0x67B, 0x67C, 0x67D, 0x67E, 0x67F, 0x680, 0x681, 0x682, 0x683, 0x684, 0x685, 0x686, 0x687, 0x688, 0x689, 0x68A, 0x68B, 0x68C, 0x68D, 0x68E, 0x68F, 0x690, 0x691, 0x692, 0x693, 0x694, 0x695, 0x696, 0x697, 0x698, 0x699, 0x69A, 0x69B, 0x69C, 0x69D, 0x69E, 0x69F, 0x6A0, 0x6A1, 0x6A2, 0x6A3, 0x6A4, 0x6A5, 0x6A6, 0x6A7, 0x6A8, 0x6A9, 0x6AA, 0x6AB, 0x6AC, 0x6AD, 0x6AE, 0x6AF, 0x6B0, 0x6B1, 0x6B2, 0x6B3, 0x6B4, 0x6B5, 0x6B6, 0x6B7, 0x6B8, 0x6B9, 0x6BA, 0x6BB, 0x6BC, 0x6BD, 0x6BE, 0x6BF, 0x6C0, 0x6C1, 0x6C2, 0x6C3, 0x6C4, 0x6C5, 0x6C6, 0x6C7, 0x6C8, 0x6C9, 0x6CA, 0x6CB, 0x6CC, 0x6CD, 0x6CE, 0x6CF, 0x6D0, 0x6D1, 0x6D2, 0x6D3, 0x6D4, 0x6D5, 0x6D6, 0x6D7, 0x6D8, 0x6D9, 0x6DA, 0x6DB, 0x6DC, 0x6DD, 0x6DE, 0x6DF, 0x6E0, 0x6E1, 0x6E2, 0x6E3, 0x6E4, 0x6E5, 0x6E6, 0x6E7, 0x6E8, 0x6E9, 0x6EA, 0x6EB, 0x6EC, 0x6ED, 0x6EE, 0x6EF, 0x6F0, 0x6F1, 0x6F2, 0x6F3, 0x6F4, 0x6F5, 0x6F6, 0x6F7, 0x6F8, 0x6F9, /* 24E1 */
+ 0x6FA, 0x6FB, 0x6FC, 0x6FD, 0x6FE, 0x6FF, 0x700, 0x701, 0x702, 0x703, 0x704, 0x705, 0x706, 0x707, 0x708, 0x709, 0x70A, 0x70B, 0x70C, 0x70D, 0x70E, 0x70F, 0x710, 0x711, 0x712, 0x713, 0xA618FBC0, 0x714, 0x715, 0x716, 0x717, 0x718, 0x719, 0x71A, 0x71B, 0x71C, 0x71D, 0x71E, 0x71F, 0x720, 0x721, 0x722, 0x723, 0x724, 0x725, 0x726, 0x727, 0x728, 0x729, 0x72A, 0xB2F, 0xB30, 0xB31, 0xB32, 0xB33, 0xB34, 0xB35, 0xB36, 0x72B, 0x72C, 0x72D, 0x72E, 0x72F, 0x730, 0x731, 0x732, 0x733, 0x734, 0x735, 0x736, 0x737, 0x738, 0x739, 0x73A, 0x73B, 0x73C, 0x73D, 0x73E, 0x73F, 0x740, 0x741, 0x742, 0x743, 0x744, 0x745, 0x746, 0x747, 0x748, 0x749, 0x74A, 0x74B, 0x74C, 0x74D, 0x74E, 0x74F, 0x750, 0x751, 0x752, 0x753, 0x754, 0x755, 0x756, 0x757, 0x758, 0x759, 0x75A, 0x75B, 0x75C, 0x75D, 0x75E, 0x75F, 0xD2B, 0xD2C, 0xD2D, 0x760, 0x761, 0x762, 0x763, 0x764, 0x765, 0x766, 0x767, 0x768, 0x769, 0x76A, 0x76B, 0x76C, 0x76D, 0xA67EFBC0, 0xA67FFBC0, 0x76E, 0x76F, 0x770, 0x771, 0x772, 0x773, 0x774, 0x775, 0x776, 0x777, 0xB29, 0xB2A, 0xB2B, 0xB2C, 0xB2D, 0xB2E, 0x778, 0x779, 0xA692FBC0, 0xA693FBC0, 0xA694FBC0, 0xA695FBC0, 0xA696FBC0, 0xA697FBC0, 0xA698FBC0, 0xA699FBC0, 0xA69AFBC0, 0xA69BFBC0, 0xA69CFBC0, 0xA69DFBC0, 0xA69EFBC0, 0xA69FFBC0, 0x77A, 0x77B, 0xA6A2FBC0, 0xA6A3FBC0, 0xA6A4FBC0, 0xA6A5FBC0, 0xA6A6FBC0, 0xA6A7FBC0, 0xA6A8FBC0, 0xA6A9FBC0, 0xA6AAFBC0, 0xA6ABFBC0, 0xA6ACFBC0, 0xA6ADFBC0, 0xA6AEFBC0, 0xA6AFFBC0, 0xA6B0FBC0, 0xA6B1FBC0, 0xA6B2FBC0, 0xA6B3FBC0, 0xA6B4FBC0, 0xA6B5FBC0, 0xA6B6FBC0, 0xA6B7FBC0, 0xA6B8FBC0, 0xA6B9FBC0, 0xA6BAFBC0, 0xA6BBFBC0, 0xA6BCFBC0, 0xA6BDFBC0, 0xA6BEFBC0, 0xA6BFFBC0, 0xA6C0FBC0, 0xA6C1FBC0, 0xA6C2FBC0, 0xA6C3FBC0, 0xA6C4FBC0, 0xA6C5FBC0, 0xA6C6FBC0, 0xA6C7FBC0, 0xA6C8FBC0, 0xA6C9FBC0, 0xA6CAFBC0, 0xA6CBFBC0, 0xA6CCFBC0, 0xA6CDFBC0, 0xA6CEFBC0, 0xA6CFFBC0, 0xA6D0FBC0, 0xA6D1FBC0, 0xA6D2FBC0, 0xA6D3FBC0, 0xA6D4FBC0, 0xA6D5FBC0, 0xA6D6FBC0, 0xA6D7FBC0, 0xA6D8FBC0, 0xA6D9FBC0, 0xA6DAFBC0, 0xA6DBFBC0, 0xA6DCFBC0, 0xA6DDFBC0, 0xA6DEFBC0, 0xA6DFFBC0, 0xA6E0FBC0, 0xA6E1FBC0, 0xA6E2FBC0, 0xA6E3FBC0, 0xA6E4FBC0, /* 25FE */
+ 0xA6E5FBC0, 0xA6E6FBC0, 0xA6E7FBC0, 0xA6E8FBC0, 0xA6E9FBC0, 0xA6EAFBC0, 0xA6EBFBC0, 0xA6ECFBC0, 0xA6EDFBC0, 0xA6EEFBC0, 0xA6EFFBC0, 0xA6F0FBC0, 0xA6F1FBC0, 0xA6F2FBC0, 0xA6F3FBC0, 0xA6F4FBC0, 0xA6F5FBC0, 0xA6F6FBC0, 0xA6F7FBC0, 0xA6F8FBC0, 0xA6F9FBC0, 0xA6FAFBC0, 0xA6FBFBC0, 0xA6FCFBC0, 0xA6FDFBC0, 0xA6FEFBC0, 0xA6FFFBC0, 0xA700FBC0, 0x77C, 0x77D, 0x77E, 0x77F, 0xA705FBC0, 0x780, 0x781, 0x782, 0x783, 0xA70AFBC0, 0xA70BFBC0, 0x784, 0x785, 0x786, 0x787, 0x788, 0x789, 0x78A, 0x78B, 0x78C, 0x78D, 0x78E, 0x78F, 0x790, 0x791, 0x792, 0x793, 0x794, 0x795, 0x796, 0x797, 0x798, 0x799, 0x79A, 0x79B, 0x79C, 0x79D, 0x79E, 0x79F, 0xA728FBC0, 0x7A0, 0x7A1, 0x7A2, 0x7A3, 0x7A4, 0x7A5, 0x7A6, 0x7A7, 0x7A8, 0x7A9, 0x7AA, 0x7AB, 0x7AC, 0x7AD, 0x7AE, 0x7AF, 0x7B0, 0x7B1, 0x7B2, 0x7B3, 0x7B4, 0x7B5, 0x7B6, 0x7B7, 0x7B8, 0x7B9, 0x7BA, 0x7BB, 0x7BC, 0x7BD, 0x7BE, 0x7BF, 0x7C0, 0x7C1, 0x7C2, 0xA74CFBC0, 0x7C3, 0xA74EFBC0, 0x7C4, 0x7C5, 0x7C6, 0x7C7, 0xA753FBC0, 0xA754FBC0, 0xA755FBC0, 0x7C8, 0xA757FBC0, 0x7C9, 0x7CA, 0x7CB, 0x7CC, 0x7CD, 0x7CE, 0x7CF, 0xA75FFBC0, 0xA760FBC0, 0x7D0, 0x7D1, 0x7D2, 0x7D3, 0x7D4, 0x7D5, 0x7D6, 0x7D7, 0x7D8, 0x7D9, 0x7DA, 0x7DB, 0x7DC, 0x7DD, 0x7DE, 0x7DF, 0x7E0, 0x7E1, 0x7E2, 0x7E3, 0x7E4, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0xE290E2A, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0xE290E2A, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0xE290E2A, 0x7E5, 0xA795FBC0, 0xA796FBC0, 0xA797FBC0, 0x7E6, 0x7E7, 0x7E8, 0x7E9, 0x7EA, 0x7EB, 0x7EC, 0x7ED, 0x7EE, 0x7EF, 0x7F0, 0x7F1, 0x7F2, 0x7F3, 0x7F4, 0x7F5, 0x7F6, 0x7F7, 0x7F8, 0x7F9, 0x7FA, 0x7FB, 0x7FC, 0x7FD, 0xA7B0FBC0, 0x7FE, 0x7FF, 0x800, 0x801, 0x802, 0x803, 0x804, 0x805, 0x806, 0x807, 0x808, 0x809, 0x80A, 0x80B, 0xA7BFFBC0, 0xA7C0FBC0, 0xA7C1FBC0, 0xA7C2FBC0, 0xA7C3FBC0, 0xA7C4FBC0, 0xA7C5FBC0, 0xA7C6FBC0, 0xA7C7FBC0, 0xA7C8FBC0, 0xA7C9FBC0, 0xA7CAFBC0, 0xA7CBFBC0, 0xA7CCFBC0, 0xA7CDFBC0, 0xA7CEFBC0, 0xA7CFFBC0, 0x80C, 0x80D, 0x80E, 0x80F, 0x810, 0x811, 0x812, 0x813, 0x814, 0x815, 0x816, 0x817, /* 26E5 */
+ 0x818, 0x819, 0x81A, 0x81B, 0x81C, 0x81D, 0x81E, 0x81F, 0x820, 0x821, 0x822, 0x823, 0x824, 0x825, 0x826, 0x827, 0xA7ECFBC0, 0xA7EDFBC0, 0xA7EEFBC0, 0xA7EFFBC0, 0x828, 0x829, 0x82A, 0x82B, 0x82C, 0x82D, 0x82E, 0x82F, 0x830, 0x831, 0x832, 0x833, 0x834, 0x835, 0x836, 0x837, 0xA29, 0xA2A, 0xA2B, 0xA2C, 0xA2D, 0xA2E, 0xA2F, 0xA30, 0xA31, 0xA32, 0xA33, 0xA34, 0xA35, 0xA36, 0xA37, 0xA38, 0xA39, 0xA3A, 0xA3B, 0xA3C, 0xA3D, 0xA3E, 0xA3F, 0xA40, 0xA41, 0xA42, 0xA43, 0xA44, 0xA45, 0xA46, 0xA47, 0xA48, 0xA49, 0xA4A, 0xA4B, 0xA4C, 0xA4D, 0xA4E, 0xA4F, 0xA50, 0xA51, 0xA52, 0xA53, 0xA54, 0xA55, 0xA56, 0xA57, 0xA58, 0xA59, 0xA5A, 0xA5B, 0xA5C, 0xA5D, 0xA5E, 0xA5F, 0xA60, 0xA61, 0xA62, 0xA63, 0xA64, 0xA65, 0xA66, 0xA67, 0xA68, 0xA69, 0xA6A, 0xA6B, 0xA6C, 0xA6D, 0xA6E, 0xA6F, 0xA70, 0xA71, 0xA72, 0xA73, 0xA74, 0xA75, 0xA76, 0xA77, 0xA78, 0xA79, 0xA7A, 0xA7B, 0xA7C, 0xA7D, 0xA7E, 0xA7F, 0xA80, 0xA81, 0xA82, 0xA83, 0xA84, 0xA85, 0xA86, 0xA87, 0xA88, 0xA89, 0xA8A, 0xA8B, 0xA8C, 0xA8D, 0xA8E, 0xA8F, 0xA90, 0xA91, 0xA92, 0xA93, 0xA94, 0xA95, 0xA96, 0xA97, 0xA98, 0xA99, 0xA9A, 0xA9B, 0xA9C, 0xA9D, 0xA9E, 0xA9F, 0xAA0, 0xAA1, 0xAA2, 0xAA3, 0xAA4, 0xAA5, 0xAA6, 0xAA7, 0xAA8, 0xAA9, 0xAAA, 0xAAB, 0xAAC, 0xAAD, 0xAAE, 0xAAF, 0xAB0, 0xAB1, 0xAB2, 0xAB3, 0xAB4, 0xAB5, 0xAB6, 0xAB7, 0xAB8, 0xAB9, 0xABA, 0xABB, 0xABC, 0xABD, 0xABE, 0xABF, 0xAC0, 0xAC1, 0xAC2, 0xAC3, 0xAC4, 0xAC5, 0xAC6, 0xAC7, 0xAC8, 0xAC9, 0xACA, 0xACB, 0xACC, 0xACD, 0xACE, 0xACF, 0xAD0, 0xAD1, 0xAD2, 0xAD3, 0xAD4, 0xAD5, 0xAD6, 0xAD7, 0xAD8, 0xAD9, 0xADA, 0xADB, 0xADC, 0xADD, 0xADE, 0xADF, 0xAE0, 0xAE1, 0xAE2, 0xAE3, 0xAE4, 0xAE5, 0xAE6, 0xAE7, 0xAE8, 0xAE9, 0xAEA, 0xAEB, 0xAEC, 0xAED, 0xAEE, 0xAEF, 0xAF0, 0xAF1, 0xAF2, 0xAF3, 0xAF4, 0xAF5, 0xAF6, 0xAF7, 0xAF8, 0xAF9, 0xAFA, 0xAFB, 0xAFC, 0xAFD, 0xAFE, 0xAFF, 0xB00, 0xB01, 0xB02, 0xB03, 0xB04, 0xB05, 0xB06, 0xB07, 0xB08, 0xB09, 0xB0A, 0xB0B, 0xB0C, 0xB0D, 0xB0E, 0xB0F, 0xB10, 0xB11, 0xB12, 0xB13, 0xB14, 0xB15, 0xB16, 0xB17, 0xB18, 0xB19, 0xB1A, 0xB1B, 0xB1C, 0xB1D, 0xB1E, 0xB1F, 0xB20, 0xB21, 0xB22, 0xB23, 0xB24, 0xB25, /* 27DC */
+ 0xB26, 0xB27, 0xB28, 0x838, 0x839, 0x83A, 0x83B, 0x83C, 0x83D, 0x83E, 0x83F, 0x840, 0x841, 0x842, 0x843, 0x844, 0x845, 0x846, 0x847, 0x848, 0x849, 0x84A, 0x84B, 0x84C, 0x84D, 0x84E, 0x84F, 0x850, 0x851, 0x852, 0x853, 0x854, 0x855, 0x856, 0x857, 0x858, 0x859, 0x85A, 0x85B, 0x85C, 0x85D, 0x85E, 0x85F, 0x860, 0x861, 0x862, 0x863, 0x864, 0x865, 0x866, 0x867, 0x868, 0x869, 0x86A, 0x86B, 0x86C, 0x86D, 0x86E, 0x86F, 0x870, 0x871, 0x872, 0x873, 0x874, 0x875, 0x876, 0x877, 0x878, 0x879, 0x87A, 0x87B, 0x87C, 0x87D, 0x87E, 0x87F, 0x880, 0x881, 0x882, 0x883, 0x884, 0x885, 0x886, 0x887, 0x888, 0x889, 0x88A, 0x88B, 0x88C, 0x88D, 0x88E, 0x88F, 0x890, 0x891, 0x892, 0x893, 0x894, 0x895, 0x896, 0x897, 0x898, 0x899, 0x89A, 0x89B, 0x89C, 0x89D, 0x89E, 0x89F, 0x8A0, 0x8A1, 0x8A2, 0x8A3, 0x8A4, 0x8A5, 0x8A6, 0x8A7, 0x8A8, 0x8A9, 0x8AA, 0x8AB, 0x8AC, 0x8AD, 0x8AE, 0x8AF, 0x8B0, 0x8B1, 0x8B2, 0x8B3, 0x8B4, 0x8B5, 0x8B6, 0x8B7, 0x8B8, 0x8B9, 0x8BA, 0x298, 0x299, 0x29A, 0x29B, 0x29C, 0x29D, 0x29E, 0x29F, 0x2A0, 0x2A1, 0x2A2, 0x2A3, 0x2A4, 0x2A5, 0x2A6, 0x2A7, 0x2A8, 0x2A9, 0x2AA, 0x2AB, 0x2AC, 0x2AD, 0x8BB, 0x8BC, 0x8BD, 0x8BE, 0x8BF, 0x8C0, 0x8C1, 0x8C2, 0x8C3, 0x8C4, 0x8C5, 0x8C6, 0x8C7, 0x8C8, 0x8C9, 0x8CA, 0x8CB, 0x8CC, 0x8CD, 0x8CE, 0x8CF, 0x8D0, 0x8D1, 0x8D2, 0x8D3, 0x8D4, 0x8D5, 0x8D6, 0x8D7, 0x8D8, 0x8D9, 0x8DA, 0x8DB, 0x8DC, 0x8DD, 0x8DE, 0x8DF, 0x8E0, 0x8E1, 0x8E2, 0x8E3, 0x8E4, 0x8E5, 0x8E6, 0x8E7, 0x8E8, 0x8E9, 0x8EA, 0x8EB, 0x8EC, 0x8ED, 0x8EE, 0x8EF, 0x8F0, 0x8F1, 0x8F2, 0x8F3, 0x8F4, 0x8F5, 0x8F6, 0x8F7, 0x8F8, 0x8F9, 0x8FA, 0x8FB, 0x8FC, 0x8FD, 0x8FE, 0x8FF, 0x900, 0x901, 0x902, 0x903, 0x904, 0x905, 0x906, 0x907, 0x908, 0x909, 0x90A, 0x90B, 0x90C, 0x90D, 0x90E, 0x90F, 0x910, 0x911, 0x912, 0x913, 0x914, 0x915, 0x916, 0x917, 0x918, 0x919, 0x91A, 0x91B, 0x91C, 0x91D, 0x296, 0x297, 0x91E, 0x91F, 0x920, 0x921, 0x922, 0x923, 0x924, 0x925, 0x926, 0x927, 0x928, 0x929, 0x92A, 0x92B, 0x44B044B044B044B, 0x92C, 0x92D, 0x92E, 0x92F, 0x930, 0x931, 0x932, 0x933, 0x934, 0x935, 0x936, 0x937, 0x938, 0x939, 0x93A, 0x93B, 0x93C, 0x93D, /* 28FD */
+ 0x93E, 0x93F, 0x940, 0x941, 0x942, 0x943, 0x944, 0x945, 0x946, 0x947, 0x948, 0x949, 0x94A, 0x94B, 0x94C, 0x94D, 0x94E, 0x94F, 0x950, 0x951, 0x952, 0x953, 0x954, 0x955, 0x956, 0x957, 0x958, 0x959, 0x95A, 0x95B, 0x95C, 0x95D, 0x95E, 0x95F, 0x960, 0x961, 0x962, 0x963, 0x964, 0x965, 0x966, 0x967, 0x968, 0x969, 0x96A, 0x96B, 0x96C, 0x96D, 0x96E, 0x96F, 0x970, 0x971, 0x972, 0x973, 0x974, 0x975, 0x976, 0x977, 0x978, 0x979, 0x97A, 0x97B, 0x97C, 0x97D, 0x97E, 0x97F, 0x980, 0x981, 0x982, 0x983, 0x984, 0x985, 0x986, 0x987, 0x988, 0x989, 0x98A, 0x98B, 0x98C, 0x98D, 0x98E, 0x98F, 0x990, 0x991, 0x992, 0x42D023D023D, 0x42D042D, 0x42D042D042D, 0x993, 0x994, 0x995, 0x996, 0x997, 0x998, 0x999, 0x99A, 0x99B, 0x99C, 0x99D, 0x99E, 0x99F, 0x9A0, 0x9A1, 0x9A2, 0x9A3, 0x9A4, 0x9A5, 0x9A6, 0x9A7, 0x9A8, 0x9A9, 0x9AA, 0x9AB, 0x9AC, 0x9AD, 0x9AE, 0x9AF, 0x9B0, 0x9B1, 0x9B2, 0x9B3, 0x9B4, 0x9B5, 0x9B6, 0x9B7, 0x9B8, 0x9B9, 0x9BA, 0x9BB, 0x9BC, 0x9BD, 0x9BE, 0x9BF, 0x9C0, 0x9C1, 0x9C2, 0x9C3, 0x9C4, 0x9C5, 0x9C6, 0x9C7, 0x9C8, 0x9C9, 0x9CA, 0x9CB, 0x9CC, 0x9CD, 0x9CE, 0x9CF, 0x9D0, 0x9D1, 0x9D2, 0x9D3, 0x9D4, 0x9D5, 0x9D6, 0x9D7, 0x9D8, 0x9D9, 0x9DA, 0x9DB, 0x9DC, 0x9DD, 0x9DE, 0x9DF, 0x9E0, 0x9E1, 0x9E2, 0x9E3, 0x9E4, 0x9E5, 0x9E6, 0x9E7, 0x9E8, 0x9E9, 0x9EA, 0x9EB, 0x9EC, 0x9ED, 0x9EE, 0x9EF, 0x9F0, 0x9F1, 0x9F2, 0x9F3, 0x9F4, 0x9F5, 0x9F6, 0x9F7, 0x9F8, 0x9F8, 0x9F9, 0x9FA, 0x9FB, 0x9FC, 0x9FD, 0x9FE, 0x9FF, 0xA00, 0xA01, 0xA02, 0xA03, 0xA04, 0xA05, 0xA06, 0xA07, 0xA08, 0xA09, 0xA0A, 0xA0B, 0xA0C, 0xA0D, 0xA0E, 0xA0F, 0xA10, 0xA11, 0xA12, 0xA13, 0xA14, 0xA15, 0xA16, 0xA17, 0xA18, 0xA19, 0xA1A, 0xA1B, 0xA1C, 0xA1D, 0xA1E, 0xA1F, 0xA20, 0xA21, 0xA22, 0xA23, 0xA24, 0xA25, 0xA26, 0xA27, 0xA28, 0xAB0EFBC0, 0xAB0FFBC0, 0xAB10FBC0, 0xAB11FBC0, 0xAB12FBC0, 0xAB13FBC0, 0xAB14FBC0, 0xAB15FBC0, 0xAB16FBC0, 0xAB17FBC0, 0xAB18FBC0, 0xAB19FBC0, 0xAB1AFBC0, 0xAB1BFBC0, 0xAB1CFBC0, 0xAB1DFBC0, 0xAB1EFBC0, 0xAB1FFBC0, 0xAB20FBC0, 0xAB21FBC0, 0xAB22FBC0, 0xAB23FBC0, 0xAB24FBC0, 0xAB25FBC0, 0xAB26FBC0, 0xAB27FBC0, 0xAB28FBC0, 0xAB29FBC0, 0xAB2AFBC0, /* 2A1F */
+ 0xAB2BFBC0, 0xAB2CFBC0, 0xAB2DFBC0, 0xAB2EFBC0, 0xAB2FFBC0, 0xAB30FBC0, 0xAB31FBC0, 0xAB32FBC0, 0xAB33FBC0, 0xAB34FBC0, 0xAB35FBC0, 0xAB36FBC0, 0xAB37FBC0, 0xAB38FBC0, 0xAB39FBC0, 0xAB3AFBC0, 0xAB3BFBC0, 0xAB3CFBC0, 0xAB3DFBC0, 0xAB3EFBC0, 0xAB3FFBC0, 0xAB40FBC0, 0xAB41FBC0, 0xAB42FBC0, 0xAB43FBC0, 0xAB44FBC0, 0xAB45FBC0, 0xAB46FBC0, 0xAB47FBC0, 0xAB48FBC0, 0xAB49FBC0, 0xAB4AFBC0, 0xAB4BFBC0, 0xAB4CFBC0, 0xAB4DFBC0, 0xAB4EFBC0, 0xAB4FFBC0, 0xAB50FBC0, 0xAB51FBC0, 0xAB52FBC0, 0xAB53FBC0, 0xAB54FBC0, 0xAB55FBC0, 0xAB56FBC0, 0xAB57FBC0, 0xAB58FBC0, 0xAB59FBC0, 0xAB5AFBC0, 0xAB5BFBC0, 0xAB5CFBC0, 0xAB5DFBC0, 0xAB5EFBC0, 0xAB5FFBC0, 0xAB60FBC0, 0xAB61FBC0, 0xAB62FBC0, 0xAB63FBC0, 0xAB64FBC0, 0xAB65FBC0, 0xAB66FBC0, 0xAB67FBC0, 0xAB68FBC0, 0xAB69FBC0, 0xAB6AFBC0, 0xAB6BFBC0, 0xAB6CFBC0, 0xAB6DFBC0, 0xAB6EFBC0, 0xAB6FFBC0, 0xAB70FBC0, 0xAB71FBC0, 0xAB72FBC0, 0xAB73FBC0, 0xAB74FBC0, 0xAB75FBC0, 0xAB76FBC0, 0xAB77FBC0, 0xAB78FBC0, 0xAB79FBC0, 0xAB7AFBC0, 0xAB7BFBC0, 0xAB7CFBC0, 0xAB7DFBC0, 0xAB7EFBC0, 0xAB7FFBC0, 0xAB80FBC0, 0xAB81FBC0, 0xAB82FBC0, 0xAB83FBC0, 0xAB84FBC0, 0xAB85FBC0, 0xAB86FBC0, 0xAB87FBC0, 0xAB88FBC0, 0xAB89FBC0, 0xAB8AFBC0, 0xAB8BFBC0, 0xAB8CFBC0, 0xAB8DFBC0, 0xAB8EFBC0, 0xAB8FFBC0, 0xAB90FBC0, 0xAB91FBC0, 0xAB92FBC0, 0xAB93FBC0, 0xAB94FBC0, 0xAB95FBC0, 0xAB96FBC0, 0xAB97FBC0, 0xAB98FBC0, 0xAB99FBC0, 0xAB9AFBC0, 0xAB9BFBC0, 0xAB9CFBC0, 0xAB9DFBC0, 0xAB9EFBC0, 0xAB9FFBC0, 0xABA0FBC0, 0xABA1FBC0, 0xABA2FBC0, 0xABA3FBC0, 0xABA4FBC0, 0xABA5FBC0, 0xABA6FBC0, 0xABA7FBC0, 0xABA8FBC0, 0xABA9FBC0, 0xABAAFBC0, 0xABABFBC0, 0xABACFBC0, 0xABADFBC0, 0xABAEFBC0, 0xABAFFBC0, 0xABB0FBC0, 0xABB1FBC0, 0xABB2FBC0, 0xABB3FBC0, 0xABB4FBC0, 0xABB5FBC0, 0xABB6FBC0, 0xABB7FBC0, 0xABB8FBC0, 0xABB9FBC0, 0xABBAFBC0, 0xABBBFBC0, 0xABBCFBC0, 0xABBDFBC0, 0xABBEFBC0, 0xABBFFBC0, 0xABC0FBC0, 0xABC1FBC0, 0xABC2FBC0, 0xABC3FBC0, 0xABC4FBC0, 0xABC5FBC0, 0xABC6FBC0, 0xABC7FBC0, 0xABC8FBC0, 0xABC9FBC0, 0xABCAFBC0, 0xABCBFBC0, 0xABCCFBC0, 0xABCDFBC0, 0xABCEFBC0, 0xABCFFBC0, 0xABD0FBC0, 0xABD1FBC0, 0xABD2FBC0, 0xABD3FBC0, 0xABD4FBC0, /* 2B2B */
+ 0xABD5FBC0, 0xABD6FBC0, 0xABD7FBC0, 0xABD8FBC0, 0xABD9FBC0, 0xABDAFBC0, 0xABDBFBC0, 0xABDCFBC0, 0xABDDFBC0, 0xABDEFBC0, 0xABDFFBC0, 0xABE0FBC0, 0xABE1FBC0, 0xABE2FBC0, 0xABE3FBC0, 0xABE4FBC0, 0xABE5FBC0, 0xABE6FBC0, 0xABE7FBC0, 0xABE8FBC0, 0xABE9FBC0, 0xABEAFBC0, 0xABEBFBC0, 0xABECFBC0, 0xABEDFBC0, 0xABEEFBC0, 0xABEFFBC0, 0xABF0FBC0, 0xABF1FBC0, 0xABF2FBC0, 0xABF3FBC0, 0xABF4FBC0, 0xABF5FBC0, 0xABF6FBC0, 0xABF7FBC0, 0xABF8FBC0, 0xABF9FBC0, 0xABFAFBC0, 0xABFBFBC0, 0xABFCFBC0, 0xABFDFBC0, 0xABFEFBC0, 0xABFFFBC0, 0xAC00FBC0, 0xAC01FBC0, 0xAC02FBC0, 0xAC03FBC0, 0xAC04FBC0, 0xAC05FBC0, 0xAC06FBC0, 0xAC07FBC0, 0xAC08FBC0, 0xAC09FBC0, 0xAC0AFBC0, 0xAC0BFBC0, 0xAC0CFBC0, 0xAC0DFBC0, 0xAC0EFBC0, 0xAC0FFBC0, 0xAC10FBC0, 0xAC11FBC0, 0xAC12FBC0, 0xAC13FBC0, 0xAC14FBC0, 0xAC15FBC0, 0xAC16FBC0, 0xAC17FBC0, 0xAC18FBC0, 0xAC19FBC0, 0xAC1AFBC0, 0xAC1BFBC0, 0xAC1CFBC0, 0xAC1DFBC0, 0xAC1EFBC0, 0xAC1FFBC0, 0xAC20FBC0, 0xAC21FBC0, 0xAC22FBC0, 0xAC23FBC0, 0xAC24FBC0, 0xAC25FBC0, 0xAC26FBC0, 0xAC27FBC0, 0xAC28FBC0, 0xAC29FBC0, 0xAC2AFBC0, 0xAC2BFBC0, 0xAC2CFBC0, 0xAC2DFBC0, 0xAC2EFBC0, 0xAC2FFBC0, 0xAC30FBC0, 0xAC31FBC0, 0xAC32FBC0, 0xAC33FBC0, 0xAC34FBC0, 0xAC35FBC0, 0xAC36FBC0, 0xAC37FBC0, 0xAC38FBC0, 0xAC39FBC0, 0xAC3AFBC0, 0xAC3BFBC0, 0xAC3CFBC0, 0xAC3DFBC0, 0xAC3EFBC0, 0xAC3FFBC0, 0xAC40FBC0, 0xAC41FBC0, 0xAC42FBC0, 0xAC43FBC0, 0xAC44FBC0, 0xAC45FBC0, 0xAC46FBC0, 0xAC47FBC0, 0xAC48FBC0, 0xAC49FBC0, 0xAC4AFBC0, 0xAC4BFBC0, 0xAC4CFBC0, 0xAC4DFBC0, 0xAC4EFBC0, 0xAC4FFBC0, 0xAC50FBC0, 0xAC51FBC0, 0xAC52FBC0, 0xAC53FBC0, 0xAC54FBC0, 0xAC55FBC0, 0xAC56FBC0, 0xAC57FBC0, 0xAC58FBC0, 0xAC59FBC0, 0xAC5AFBC0, 0xAC5BFBC0, 0xAC5CFBC0, 0xAC5DFBC0, 0xAC5EFBC0, 0xAC5FFBC0, 0xAC60FBC0, 0xAC61FBC0, 0xAC62FBC0, 0xAC63FBC0, 0xAC64FBC0, 0xAC65FBC0, 0xAC66FBC0, 0xAC67FBC0, 0xAC68FBC0, 0xAC69FBC0, 0xAC6AFBC0, 0xAC6BFBC0, 0xAC6CFBC0, 0xAC6DFBC0, 0xAC6EFBC0, 0xAC6FFBC0, 0xAC70FBC0, 0xAC71FBC0, 0xAC72FBC0, 0xAC73FBC0, 0xAC74FBC0, 0xAC75FBC0, 0xAC76FBC0, 0xAC77FBC0, 0xAC78FBC0, 0xAC79FBC0, 0xAC7AFBC0, 0xAC7BFBC0, 0xAC7CFBC0, 0xAC7DFBC0, 0xAC7EFBC0, /* 2BD5 */
+ 0xAC7FFBC0, 0xAC80FBC0, 0xAC81FBC0, 0xAC82FBC0, 0xAC83FBC0, 0xAC84FBC0, 0xAC85FBC0, 0xAC86FBC0, 0xAC87FBC0, 0xAC88FBC0, 0xAC89FBC0, 0xAC8AFBC0, 0xAC8BFBC0, 0xAC8CFBC0, 0xAC8DFBC0, 0xAC8EFBC0, 0xAC8FFBC0, 0xAC90FBC0, 0xAC91FBC0, 0xAC92FBC0, 0xAC93FBC0, 0xAC94FBC0, 0xAC95FBC0, 0xAC96FBC0, 0xAC97FBC0, 0xAC98FBC0, 0xAC99FBC0, 0xAC9AFBC0, 0xAC9BFBC0, 0xAC9CFBC0, 0xAC9DFBC0, 0xAC9EFBC0, 0xAC9FFBC0, 0xACA0FBC0, 0xACA1FBC0, 0xACA2FBC0, 0xACA3FBC0, 0xACA4FBC0, 0xACA5FBC0, 0xACA6FBC0, 0xACA7FBC0, 0xACA8FBC0, 0xACA9FBC0, 0xACAAFBC0, 0xACABFBC0, 0xACACFBC0, 0xACADFBC0, 0xACAEFBC0, 0xACAFFBC0, 0xACB0FBC0, 0xACB1FBC0, 0xACB2FBC0, 0xACB3FBC0, 0xACB4FBC0, 0xACB5FBC0, 0xACB6FBC0, 0xACB7FBC0, 0xACB8FBC0, 0xACB9FBC0, 0xACBAFBC0, 0xACBBFBC0, 0xACBCFBC0, 0xACBDFBC0, 0xACBEFBC0, 0xACBFFBC0, 0xACC0FBC0, 0xACC1FBC0, 0xACC2FBC0, 0xACC3FBC0, 0xACC4FBC0, 0xACC5FBC0, 0xACC6FBC0, 0xACC7FBC0, 0xACC8FBC0, 0xACC9FBC0, 0xACCAFBC0, 0xACCBFBC0, 0xACCCFBC0, 0xACCDFBC0, 0xACCEFBC0, 0xACCFFBC0, 0xACD0FBC0, 0xACD1FBC0, 0xACD2FBC0, 0xACD3FBC0, 0xACD4FBC0, 0xACD5FBC0, 0xACD6FBC0, 0xACD7FBC0, 0xACD8FBC0, 0xACD9FBC0, 0xACDAFBC0, 0xACDBFBC0, 0xACDCFBC0, 0xACDDFBC0, 0xACDEFBC0, 0xACDFFBC0, 0xACE0FBC0, 0xACE1FBC0, 0xACE2FBC0, 0xACE3FBC0, 0xACE4FBC0, 0xACE5FBC0, 0xACE6FBC0, 0xACE7FBC0, 0xACE8FBC0, 0xACE9FBC0, 0xACEAFBC0, 0xACEBFBC0, 0xACECFBC0, 0xACEDFBC0, 0xACEEFBC0, 0xACEFFBC0, 0xACF0FBC0, 0xACF1FBC0, 0xACF2FBC0, 0xACF3FBC0, 0xACF4FBC0, 0xACF5FBC0, 0xACF6FBC0, 0xACF7FBC0, 0xACF8FBC0, 0xACF9FBC0, 0xACFAFBC0, 0xACFBFBC0, 0xACFCFBC0, 0xACFDFBC0, 0xACFEFBC0, 0xACFFFBC0, 0xAD00FBC0, 0xAD01FBC0, 0xAD02FBC0, 0xAD03FBC0, 0xAD04FBC0, 0xAD05FBC0, 0xAD06FBC0, 0xAD07FBC0, 0xAD08FBC0, 0xAD09FBC0, 0xAD0AFBC0, 0xAD0BFBC0, 0xAD0CFBC0, 0xAD0DFBC0, 0xAD0EFBC0, 0xAD0FFBC0, 0xAD10FBC0, 0xAD11FBC0, 0xAD12FBC0, 0xAD13FBC0, 0xAD14FBC0, 0xAD15FBC0, 0xAD16FBC0, 0xAD17FBC0, 0xAD18FBC0, 0xAD19FBC0, 0xAD1AFBC0, 0xAD1BFBC0, 0xAD1CFBC0, 0xAD1DFBC0, 0xAD1EFBC0, 0xAD1FFBC0, 0xAD20FBC0, 0xAD21FBC0, 0xAD22FBC0, 0xAD23FBC0, 0xAD24FBC0, 0xAD25FBC0, 0xAD26FBC0, 0xAD27FBC0, 0xAD28FBC0, /* 2C7F */
+ 0xAD29FBC0, 0xAD2AFBC0, 0xAD2BFBC0, 0xAD2CFBC0, 0xAD2DFBC0, 0xAD2EFBC0, 0xAD2FFBC0, 0xAD30FBC0, 0xAD31FBC0, 0xAD32FBC0, 0xAD33FBC0, 0xAD34FBC0, 0xAD35FBC0, 0xAD36FBC0, 0xAD37FBC0, 0xAD38FBC0, 0xAD39FBC0, 0xAD3AFBC0, 0xAD3BFBC0, 0xAD3CFBC0, 0xAD3DFBC0, 0xAD3EFBC0, 0xAD3FFBC0, 0xAD40FBC0, 0xAD41FBC0, 0xAD42FBC0, 0xAD43FBC0, 0xAD44FBC0, 0xAD45FBC0, 0xAD46FBC0, 0xAD47FBC0, 0xAD48FBC0, 0xAD49FBC0, 0xAD4AFBC0, 0xAD4BFBC0, 0xAD4CFBC0, 0xAD4DFBC0, 0xAD4EFBC0, 0xAD4FFBC0, 0xAD50FBC0, 0xAD51FBC0, 0xAD52FBC0, 0xAD53FBC0, 0xAD54FBC0, 0xAD55FBC0, 0xAD56FBC0, 0xAD57FBC0, 0xAD58FBC0, 0xAD59FBC0, 0xAD5AFBC0, 0xAD5BFBC0, 0xAD5CFBC0, 0xAD5DFBC0, 0xAD5EFBC0, 0xAD5FFBC0, 0xAD60FBC0, 0xAD61FBC0, 0xAD62FBC0, 0xAD63FBC0, 0xAD64FBC0, 0xAD65FBC0, 0xAD66FBC0, 0xAD67FBC0, 0xAD68FBC0, 0xAD69FBC0, 0xAD6AFBC0, 0xAD6BFBC0, 0xAD6CFBC0, 0xAD6DFBC0, 0xAD6EFBC0, 0xAD6FFBC0, 0xAD70FBC0, 0xAD71FBC0, 0xAD72FBC0, 0xAD73FBC0, 0xAD74FBC0, 0xAD75FBC0, 0xAD76FBC0, 0xAD77FBC0, 0xAD78FBC0, 0xAD79FBC0, 0xAD7AFBC0, 0xAD7BFBC0, 0xAD7CFBC0, 0xAD7DFBC0, 0xAD7EFBC0, 0xAD7FFBC0, 0xAD80FBC0, 0xAD81FBC0, 0xAD82FBC0, 0xAD83FBC0, 0xAD84FBC0, 0xAD85FBC0, 0xAD86FBC0, 0xAD87FBC0, 0xAD88FBC0, 0xAD89FBC0, 0xAD8AFBC0, 0xAD8BFBC0, 0xAD8CFBC0, 0xAD8DFBC0, 0xAD8EFBC0, 0xAD8FFBC0, 0xAD90FBC0, 0xAD91FBC0, 0xAD92FBC0, 0xAD93FBC0, 0xAD94FBC0, 0xAD95FBC0, 0xAD96FBC0, 0xAD97FBC0, 0xAD98FBC0, 0xAD99FBC0, 0xAD9AFBC0, 0xAD9BFBC0, 0xAD9CFBC0, 0xAD9DFBC0, 0xAD9EFBC0, 0xAD9FFBC0, 0xADA0FBC0, 0xADA1FBC0, 0xADA2FBC0, 0xADA3FBC0, 0xADA4FBC0, 0xADA5FBC0, 0xADA6FBC0, 0xADA7FBC0, 0xADA8FBC0, 0xADA9FBC0, 0xADAAFBC0, 0xADABFBC0, 0xADACFBC0, 0xADADFBC0, 0xADAEFBC0, 0xADAFFBC0, 0xADB0FBC0, 0xADB1FBC0, 0xADB2FBC0, 0xADB3FBC0, 0xADB4FBC0, 0xADB5FBC0, 0xADB6FBC0, 0xADB7FBC0, 0xADB8FBC0, 0xADB9FBC0, 0xADBAFBC0, 0xADBBFBC0, 0xADBCFBC0, 0xADBDFBC0, 0xADBEFBC0, 0xADBFFBC0, 0xADC0FBC0, 0xADC1FBC0, 0xADC2FBC0, 0xADC3FBC0, 0xADC4FBC0, 0xADC5FBC0, 0xADC6FBC0, 0xADC7FBC0, 0xADC8FBC0, 0xADC9FBC0, 0xADCAFBC0, 0xADCBFBC0, 0xADCCFBC0, 0xADCDFBC0, 0xADCEFBC0, 0xADCFFBC0, 0xADD0FBC0, 0xADD1FBC0, 0xADD2FBC0, /* 2D29 */
+ 0xADD3FBC0, 0xADD4FBC0, 0xADD5FBC0, 0xADD6FBC0, 0xADD7FBC0, 0xADD8FBC0, 0xADD9FBC0, 0xADDAFBC0, 0xADDBFBC0, 0xADDCFBC0, 0xADDDFBC0, 0xADDEFBC0, 0xADDFFBC0, 0xADE0FBC0, 0xADE1FBC0, 0xADE2FBC0, 0xADE3FBC0, 0xADE4FBC0, 0xADE5FBC0, 0xADE6FBC0, 0xADE7FBC0, 0xADE8FBC0, 0xADE9FBC0, 0xADEAFBC0, 0xADEBFBC0, 0xADECFBC0, 0xADEDFBC0, 0xADEEFBC0, 0xADEFFBC0, 0xADF0FBC0, 0xADF1FBC0, 0xADF2FBC0, 0xADF3FBC0, 0xADF4FBC0, 0xADF5FBC0, 0xADF6FBC0, 0xADF7FBC0, 0xADF8FBC0, 0xADF9FBC0, 0xADFAFBC0, 0xADFBFBC0, 0xADFCFBC0, 0xADFDFBC0, 0xADFEFBC0, 0xADFFFBC0, 0xAE00FBC0, 0xAE01FBC0, 0xAE02FBC0, 0xAE03FBC0, 0xAE04FBC0, 0xAE05FBC0, 0xAE06FBC0, 0xAE07FBC0, 0xAE08FBC0, 0xAE09FBC0, 0xAE0AFBC0, 0xAE0BFBC0, 0xAE0CFBC0, 0xAE0DFBC0, 0xAE0EFBC0, 0xAE0FFBC0, 0xAE10FBC0, 0xAE11FBC0, 0xAE12FBC0, 0xAE13FBC0, 0xAE14FBC0, 0xAE15FBC0, 0xAE16FBC0, 0xAE17FBC0, 0xAE18FBC0, 0xAE19FBC0, 0xAE1AFBC0, 0xAE1BFBC0, 0xAE1CFBC0, 0xAE1DFBC0, 0xAE1EFBC0, 0xAE1FFBC0, 0xAE20FBC0, 0xAE21FBC0, 0xAE22FBC0, 0xAE23FBC0, 0xAE24FBC0, 0xAE25FBC0, 0xAE26FBC0, 0xAE27FBC0, 0xAE28FBC0, 0xAE29FBC0, 0xAE2AFBC0, 0xAE2BFBC0, 0xAE2CFBC0, 0xAE2DFBC0, 0xAE2EFBC0, 0xAE2FFBC0, 0xAE30FBC0, 0xAE31FBC0, 0xAE32FBC0, 0xAE33FBC0, 0xAE34FBC0, 0xAE35FBC0, 0xAE36FBC0, 0xAE37FBC0, 0xAE38FBC0, 0xAE39FBC0, 0xAE3AFBC0, 0xAE3BFBC0, 0xAE3CFBC0, 0xAE3DFBC0, 0xAE3EFBC0, 0xAE3FFBC0, 0xAE40FBC0, 0xAE41FBC0, 0xAE42FBC0, 0xAE43FBC0, 0xAE44FBC0, 0xAE45FBC0, 0xAE46FBC0, 0xAE47FBC0, 0xAE48FBC0, 0xAE49FBC0, 0xAE4AFBC0, 0xAE4BFBC0, 0xAE4CFBC0, 0xAE4DFBC0, 0xAE4EFBC0, 0xAE4FFBC0, 0xAE50FBC0, 0xAE51FBC0, 0xAE52FBC0, 0xAE53FBC0, 0xAE54FBC0, 0xAE55FBC0, 0xAE56FBC0, 0xAE57FBC0, 0xAE58FBC0, 0xAE59FBC0, 0xAE5AFBC0, 0xAE5BFBC0, 0xAE5CFBC0, 0xAE5DFBC0, 0xAE5EFBC0, 0xAE5FFBC0, 0xAE60FBC0, 0xAE61FBC0, 0xAE62FBC0, 0xAE63FBC0, 0xAE64FBC0, 0xAE65FBC0, 0xAE66FBC0, 0xAE67FBC0, 0xAE68FBC0, 0xAE69FBC0, 0xAE6AFBC0, 0xAE6BFBC0, 0xAE6CFBC0, 0xAE6DFBC0, 0xAE6EFBC0, 0xAE6FFBC0, 0xAE70FBC0, 0xAE71FBC0, 0xAE72FBC0, 0xAE73FBC0, 0xAE74FBC0, 0xAE75FBC0, 0xAE76FBC0, 0xAE77FBC0, 0xAE78FBC0, 0xAE79FBC0, 0xAE7AFBC0, 0xAE7BFBC0, 0xAE7CFBC0, /* 2DD3 */
+ 0xAE7DFBC0, 0xAE7EFBC0, 0xAE7FFBC0, 0xCE36FB40, 0xD382FB40, 0xCE5BFB40, 0xCE5AFB40, 0xCE59FB40, 0xCEBBFB40, 0xD182FB40, 0xD1E0FB40, 0xD200FB40, 0xD202FB40, 0xD35CFB40, 0xD369FB40, 0xDC0FFB40, 0xDC0FFB40, 0xDC22FB40, 0xDC23FB40, 0xDC22FB40, 0xDC23FB40, 0xDDF3FB40, 0xDE7AFB40, 0xDF51FB40, 0xDF50FB40, 0xDFC4FB40, 0xDFC3FB40, 0xE24CFB40, 0xE535FB40, 0xAE9AFBC0, 0xE5E1FB40, 0xE5E5FB40, 0xE708FB40, 0xEB7AFB40, 0xEBCDFB40, 0xEC11FB40, 0xEC35FB40, 0xEC3AFB40, 0xF06CFB40, 0xF22BFB40, 0xF22BFB40, 0xCE2CFB40, 0xF25BFB40, 0xF2ADFB40, 0xF38BFB40, 0xF58BFB40, 0xF6EEFB40, 0xF93AFB40, 0xF93BFB40, 0xFAF9FB40, 0xFCF9FB40, 0xFE9FFB40, 0xFF53FB40, 0xFF52FB40, 0xFF53FB40, 0xFF53FB40, 0xFF52FB40, 0xFF8AFB40, 0xFF8AFB40, 0xFF8BFB40, 0x8002FB41, 0x8080FB41, 0x807FFB41, 0x8089FB41, 0x81FCFB41, 0x8279FB41, 0x8279FB41, 0x8279FB41, 0x864EFB41, 0x8864FB41, 0x8980FB41, 0x897FFB41, 0x89C1FB41, 0x89D2FB41, 0x89D2FB41, 0x8BA0FB41, 0x8D1DFB41, 0x8DB3FB41, 0x8F66FB41, 0x8FB6FB41, 0x8FB6FB41, 0x8FB6FB41, 0x9091FB41, 0x9485FB41, 0x9577FB41, 0x9578FB41, 0x957FFB41, 0x95E8FB41, 0x961CFB41, 0x961DFB41, 0x96E8FB41, 0x9752FB41, 0x97E6FB41, 0x9875FB41, 0x98CEFB41, 0x98DEFB41, 0x98DFFB41, 0x98E0FB41, 0x98E0FB41, 0x9963FB41, 0x9996FB41, 0x9A6CFB41, 0x9AA8FB41, 0x9B3CFB41, 0x9C7CFB41, 0x9E1FFB41, 0x9E75FB41, 0x9EA6FB41, 0x9EC4FB41, 0x9EFEFB41, 0x9F4AFB41, 0x9F50FB41, 0x9F52FB41, 0x9F7FFB41, 0x9F8DFB41, 0x9F99FB41, 0x9F9CFB41, 0x9F9CFB41, 0x9F9FFB41, 0xAEF4FBC0, 0xAEF5FBC0, 0xAEF6FBC0, 0xAEF7FBC0, 0xAEF8FBC0, 0xAEF9FBC0, 0xAEFAFBC0, 0xAEFBFBC0, 0xAEFCFBC0, 0xAEFDFBC0, 0xAEFEFBC0, 0xAEFFFBC0, 0xCE00FB40, 0xCE28FB40, 0xCE36FB40, 0xCE3FFB40, 0xCE59FB40, 0xCE85FB40, 0xCE8CFB40, 0xCEA0FB40, 0xCEBAFB40, 0xD13FFB40, 0xD165FB40, 0xD16BFB40, 0xD182FB40, 0xD196FB40, 0xD1ABFB40, 0xD1E0FB40, 0xD1F5FB40, 0xD200FB40, 0xD29BFB40, 0xD2F9FB40, 0xD315FB40, 0xD31AFB40, 0xD338FB40, 0xD341FB40, 0xD35CFB40, 0xD369FB40, 0xD382FB40, 0xD3B6FB40, 0xD3C8FB40, 0xD3E3FB40, 0xD6D7FB40, 0xD71FFB40, 0xD8EBFB40, 0xD902FB40, 0xD90AFB40, 0xD915FB40, 0xD927FB40, 0xD973FB40, 0xDB50FB40, /* 2E7D */
+ 0xDB80FB40, 0xDBF8FB40, 0xDC0FFB40, 0xDC22FB40, 0xDC38FB40, 0xDC6EFB40, 0xDC71FB40, 0xDDDBFB40, 0xDDE5FB40, 0xDDF1FB40, 0xDDFEFB40, 0xDE72FB40, 0xDE7AFB40, 0xDE7FFB40, 0xDEF4FB40, 0xDEFEFB40, 0xDF0BFB40, 0xDF13FB40, 0xDF50FB40, 0xDF61FB40, 0xDF73FB40, 0xDFC3FB40, 0xE208FB40, 0xE236FB40, 0xE24BFB40, 0xE52FFB40, 0xE534FB40, 0xE587FB40, 0xE597FB40, 0xE5A4FB40, 0xE5B9FB40, 0xE5E0FB40, 0xE5E5FB40, 0xE6F0FB40, 0xE708FB40, 0xE728FB40, 0xEB20FB40, 0xEB62FB40, 0xEB79FB40, 0xEBB3FB40, 0xEBCBFB40, 0xEBD4FB40, 0xEBDBFB40, 0xEC0FFB40, 0xEC14FB40, 0xEC34FB40, 0xF06BFB40, 0xF22AFB40, 0xF236FB40, 0xF23BFB40, 0xF23FFB40, 0xF247FB40, 0xF259FB40, 0xF25BFB40, 0xF2ACFB40, 0xF384FB40, 0xF389FB40, 0xF4DCFB40, 0xF4E6FB40, 0xF518FB40, 0xF51FFB40, 0xF528FB40, 0xF530FB40, 0xF58BFB40, 0xF592FB40, 0xF676FB40, 0xF67DFB40, 0xF6AEFB40, 0xF6BFFB40, 0xF6EEFB40, 0xF7DBFB40, 0xF7E2FB40, 0xF7F3FB40, 0xF93AFB40, 0xF9B8FB40, 0xF9BEFB40, 0xFA74FB40, 0xFACBFB40, 0xFAF9FB40, 0xFC73FB40, 0xFCF8FB40, 0xFF36FB40, 0xFF51FB40, 0xFF8AFB40, 0xFFBDFB40, 0x8001FB41, 0x800CFB41, 0x8012FB41, 0x8033FB41, 0x807FFB41, 0x8089FB41, 0x81E3FB41, 0x81EAFB41, 0x81F3FB41, 0x81FCFB41, 0x820CFB41, 0x821BFB41, 0x821FFB41, 0x826EFB41, 0x8272FB41, 0x8278FB41, 0x864DFB41, 0x866BFB41, 0x8840FB41, 0x884CFB41, 0x8863FB41, 0x897EFB41, 0x898BFB41, 0x89D2FB41, 0x8A00FB41, 0x8C37FB41, 0x8C46FB41, 0x8C55FB41, 0x8C78FB41, 0x8C9DFB41, 0x8D64FB41, 0x8D70FB41, 0x8DB3FB41, 0x8EABFB41, 0x8ECAFB41, 0x8F9BFB41, 0x8FB0FB41, 0x8FB5FB41, 0x9091FB41, 0x9149FB41, 0x91C6FB41, 0x91CCFB41, 0x91D1FB41, 0x9577FB41, 0x9580FB41, 0x961CFB41, 0x96B6FB41, 0x96B9FB41, 0x96E8FB41, 0x9751FB41, 0x975EFB41, 0x9762FB41, 0x9769FB41, 0x97CBFB41, 0x97EDFB41, 0x97F3FB41, 0x9801FB41, 0x98A8FB41, 0x98DBFB41, 0x98DFFB41, 0x9996FB41, 0x9999FB41, 0x99ACFB41, 0x9AA8FB41, 0x9AD8FB41, 0x9ADFFB41, 0x9B25FB41, 0x9B2FFB41, 0x9B32FB41, 0x9B3CFB41, 0x9B5AFB41, 0x9CE5FB41, 0x9E75FB41, 0x9E7FFB41, 0x9EA5FB41, 0x9EBBFB41, 0x9EC3FB41, 0x9ECDFB41, 0x9ED1FB41, 0x9EF9FB41, 0x9EFDFB41, 0x9F0EFB41, 0x9F13FB41, 0x9F20FB41, 0x9F3BFB41, /* 2F27 */
+ 0x9F4AFB41, 0x9F52FB41, 0x9F8DFB41, 0x9F9CFB41, 0x9FA0FB41, 0xAFD6FBC0, 0xAFD7FBC0, 0xAFD8FBC0, 0xAFD9FBC0, 0xAFDAFBC0, 0xAFDBFBC0, 0xAFDCFBC0, 0xAFDDFBC0, 0xAFDEFBC0, 0xAFDFFBC0, 0xAFE0FBC0, 0xAFE1FBC0, 0xAFE2FBC0, 0xAFE3FBC0, 0xAFE4FBC0, 0xAFE5FBC0, 0xAFE6FBC0, 0xAFE7FBC0, 0xAFE8FBC0, 0xAFE9FBC0, 0xAFEAFBC0, 0xAFEBFBC0, 0xAFECFBC0, 0xAFEDFBC0, 0xAFEEFBC0, 0xAFEFFBC0, 0xDAF, 0xDB0, 0xDB1, 0xDB2, 0xDB3, 0xDB4, 0xDB5, 0xDB6, 0xDB7, 0xDB8, 0xDB9, 0xDBA, 0xAFFCFBC0, 0xAFFDFBC0, 0xAFFEFBC0, 0xAFFFFBC0, 0x209, 0x237, 0x266, 0x2E2, 0xDBB, 0xE05, 0x1E731E5D, 0xE29, 0x2AE, 0x2AF, 0x2B0, 0x2B1, 0x2B2, 0x2B3, 0x2B4, 0x2B5, 0x2B6, 0x2B7, 0xDBC, 0xDBD, 0x2B8, 0x2B9, 0x2BA, 0x2BB, 0x2BC, 0x2BD, 0x2BE, 0x2BF, 0x22B, 0x283, 0x284, 0x285, 0xDBE, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0, 0, 0, 0, 0, 0, 0x22C, 0xE07, 0xE07, 0xE08, 0xE08, 0xE09, 0xDBC, 0xDBF, 0xD341FB40, 0xD344FB40, 0xD345FB40, 0xE06, 0x1E5E1E70, 0x2E3, 0xDC0, 0xDC1, 0xB040FBC0, 0x1E52, 0x1E52, 0x1E53, 0x1E53, 0x1E54, 0x1E54, 0x1E55, 0x1E55, 0x1E56, 0x1E56, 0x1E57, 0x1E57, 0x1E58, 0x1E58, 0x1E59, 0x1E59, 0x1E5A, 0x1E5A, 0x1E5B, 0x1E5B, 0x1E5C, 0x1E5C, 0x1E5D, 0x1E5D, 0x1E5E, 0x1E5E, 0x1E5F, 0x1E5F, 0x1E60, 0x1E60, 0x1E61, 0x1E61, 0x1E62, 0x1E62, 0x1E63, 0x1E63, 0x1E63, 0x1E64, 0x1E64, 0x1E65, 0x1E65, 0x1E66, 0x1E67, 0x1E68, 0x1E69, 0x1E6A, 0x1E6B, 0x1E6B, 0x1E6B, 0x1E6C, 0x1E6C, 0x1E6C, 0x1E6D, 0x1E6D, 0x1E6D, 0x1E6E, 0x1E6E, 0x1E6E, 0x1E6F, 0x1E6F, 0x1E6F, 0x1E70, 0x1E71, 0x1E72, 0x1E73, 0x1E74, 0x1E75, 0x1E75, 0x1E76, 0x1E76, 0x1E77, 0x1E77, 0x1E78, 0x1E79, 0x1E7A, 0x1E7B, 0x1E7C, 0x1E7D, 0x1E7D, 0x1E7E, 0x1E7F, 0x1E80, 0x1E81, 0x1E54, 0x1E57, 0x1E5A, 0xB097FBC0, 0xB098FBC0, 0, 0, 0x21E, 0x21F, 0xE0A, 0xE0A, 0x1E791E77, 0x22D, 0x1E52, 0x1E52, 0x1E53, 0x1E53, 0x1E54, 0x1E54, 0x1E55, 0x1E55, 0x1E56, 0x1E56, 0x1E57, 0x1E57, 0x1E58, 0x1E58, 0x1E59, 0x1E59, 0x1E5A, 0x1E5A, 0x1E5B, 0x1E5B, 0x1E5C, 0x1E5C, 0x1E5D, 0x1E5D, 0x1E5E, 0x1E5E, 0x1E5F, 0x1E5F, 0x1E60, 0x1E60, 0x1E61, 0x1E61, 0x1E62, 0x1E62, 0x1E63, 0x1E63, 0x1E63, 0x1E64, 0x1E64, /* 2FD1 */
+ 0x1E65, 0x1E65, 0x1E66, 0x1E67, 0x1E68, 0x1E69, 0x1E6A, 0x1E6B, 0x1E6B, 0x1E6B, 0x1E6C, 0x1E6C, 0x1E6C, 0x1E6D, 0x1E6D, 0x1E6D, 0x1E6E, 0x1E6E, 0x1E6E, 0x1E6F, 0x1E6F, 0x1E6F, 0x1E70, 0x1E71, 0x1E72, 0x1E73, 0x1E74, 0x1E75, 0x1E75, 0x1E76, 0x1E76, 0x1E77, 0x1E77, 0x1E78, 0x1E79, 0x1E7A, 0x1E7B, 0x1E7C, 0x1E7D, 0x1E7D, 0x1E7E, 0x1E7F, 0x1E80, 0x1E81, 0x1E54, 0x1E57, 0x1E5A, 0x1E7D, 0x1E7E, 0x1E7F, 0x1E80, 0x22E, 0xE0B, 0xE0C, 0xE0C, 0x1E651E5B, 0xB100FBC0, 0xB101FBC0, 0xB102FBC0, 0xB103FBC0, 0xB104FBC0, 0x1E82, 0x1E83, 0x1E84, 0x1E85, 0x1E87, 0x1E88, 0x1E89, 0x1E8A, 0x1E8B, 0x1E8C, 0x1E8F, 0x1E90, 0x1E91, 0x1E92, 0x1E94, 0x1E95, 0x1E96, 0x1E97, 0x1E98, 0x1E99, 0x1E9A, 0x1E9B, 0x1E9C, 0x1E9E, 0x1E9F, 0x1EA1, 0x1EA2, 0x1EA3, 0x1EA4, 0x1EA5, 0x1EA6, 0x1EA7, 0x1EA9, 0x1EAD, 0x1EAE, 0x1EAF, 0x1EB0, 0x1E86, 0x1E8D, 0x1E93, 0xB12DFBC0, 0xB12EFBC0, 0xB12FFBC0, 0xB130FBC0, 0x1D62, 0x1D63, 0x1E02, 0x1D64, 0x1E04, 0x1E05, 0x1D65, 0x1D66, 0x1D67, 0x1E08, 0x1E09, 0x1E0A, 0x1E0B, 0x1E0C, 0x1E0D, 0x1D7C, 0x1D68, 0x1D69, 0x1D6A, 0x1D83, 0x1D6B, 0x1D6C, 0x1D6D, 0x1D6E, 0x1D6F, 0x1D70, 0x1D71, 0x1D72, 0x1D73, 0x1D74, 0x1DBE, 0x1DBF, 0x1DC0, 0x1DC1, 0x1DC2, 0x1DC3, 0x1DC4, 0x1DC5, 0x1DC6, 0x1DC7, 0x1DC8, 0x1DC9, 0x1DCA, 0x1DCB, 0x1DCC, 0x1DCD, 0x1DCE, 0x1DCF, 0x1DD0, 0x1DD1, 0x1DD2, 0x1DBD, 0x1D76, 0x1D77, 0x1E1F, 0x1E20, 0x1E24, 0x1E26, 0x1E2B, 0x1E2F, 0x1E31, 0x1D7E, 0x1E35, 0x1E37, 0x1D7F, 0x1D80, 0x1D82, 0x1D84, 0x1D85, 0x1D89, 0x1D8B, 0x1D8D, 0x1D8E, 0x1D8F, 0x1D90, 0x1D91, 0x1D94, 0x1D98, 0x1DA2, 0x1DA9, 0x1DAE, 0x1E49, 0x1E4A, 0x1DB9, 0x1DBA, 0x1DBB, 0x1DE1, 0x1DE2, 0x1DE5, 0x1DEE, 0x1DEF, 0x1DF1, 0x1DFB, 0x1DFE, 0xB18FFBC0, 0xDC2, 0xDC3, 0xCE00FB40, 0xCE8CFB40, 0xCE09FB40, 0xD6DBFB40, 0xCE0AFB40, 0xCE2DFB40, 0xCE0BFB40, 0xF532FB40, 0xCE59FB40, 0xCE19FB40, 0xCE01FB40, 0xD929FB40, 0xD730FB40, 0xCEBAFB40, 0x1E82, 0x1E98, 0x1E90, 0x1E8B, 0x1EA0, 0x1EA0, 0x1E9D, 0x1E9C, 0x1EAF, 0x1E9B, 0x1EAE, 0x1EAF, 0x1EAC, 0x1E8E, 0x1EA1, 0x1EA3, 0x1EAA, 0x1EAB, 0x1EA8, 0x1EAE, 0x1E83, 0x1E88, 0x1E8C, 0x1E8F, 0xB1B8FBC0, 0xB1B9FBC0, /* 30C8 */
+ 0xB1BAFBC0, 0xB1BBFBC0, 0xB1BCFBC0, 0xB1BDFBC0, 0xB1BEFBC0, 0xB1BFFBC0, 0xB1C0FBC0, 0xB1C1FBC0, 0xB1C2FBC0, 0xB1C3FBC0, 0xB1C4FBC0, 0xB1C5FBC0, 0xB1C6FBC0, 0xB1C7FBC0, 0xB1C8FBC0, 0xB1C9FBC0, 0xB1CAFBC0, 0xB1CBFBC0, 0xB1CCFBC0, 0xB1CDFBC0, 0xB1CEFBC0, 0xB1CFFBC0, 0xB1D0FBC0, 0xB1D1FBC0, 0xB1D2FBC0, 0xB1D3FBC0, 0xB1D4FBC0, 0xB1D5FBC0, 0xB1D6FBC0, 0xB1D7FBC0, 0xB1D8FBC0, 0xB1D9FBC0, 0xB1DAFBC0, 0xB1DBFBC0, 0xB1DCFBC0, 0xB1DDFBC0, 0xB1DEFBC0, 0xB1DFFBC0, 0xB1E0FBC0, 0xB1E1FBC0, 0xB1E2FBC0, 0xB1E3FBC0, 0xB1E4FBC0, 0xB1E5FBC0, 0xB1E6FBC0, 0xB1E7FBC0, 0xB1E8FBC0, 0xB1E9FBC0, 0xB1EAFBC0, 0xB1EBFBC0, 0xB1ECFBC0, 0xB1EDFBC0, 0xB1EEFBC0, 0xB1EFFBC0, 0x1E59, 0x1E5D, 0x1E5E, 0x1E65, 0x1E68, 0x1E6B, 0x1E6C, 0x1E6D, 0x1E6E, 0x1E6F, 0x1E72, 0x1E78, 0x1E79, 0x1E7A, 0x1E7B, 0x1E7C, 0x2891D620288, 0x2891D640288, 0x2891D650288, 0x2891D670288, 0x2891D680288, 0x2891D690288, 0x2891D6B0288, 0x2891D6D0288, 0x2891D6E0288, 0x2891D700288, 0x2891D710288, 0x2891D720288, 0x2891D730288, 0x2891D740288, 0x2891DBE1D620288, 0x2891DBE1D640288, 0x2891DBE1D650288, 0x2891DBE1D670288, 0x2891DBE1D680288, 0x2891DBE1D690288, 0x2891DBE1D6B0288, 0x2891DBE1D6D0288, 0x2891DBE1D6E0288, 0x2891DBE1D700288, 0x2891DBE1D710288, 0x2891DBE1D720288, 0x2891DBE1D730288, 0x2891DBE1D740288, 0x2891DCB1D6E0288, 0xFFFD, 0xFFFD, 0xB21FFBC0, 0x289CE00FB400288, 0x289CE8CFB400288, 0x289CE09FB400288, 0x289D6DBFB400288, 0x289CE94FB400288, 0x289D16DFB400288, 0x289CE03FB400288, 0x289D16BFB400288, 0x289CE5DFB400288, 0x289D341FB400288, 0x289E708FB400288, 0x289F06BFB400288, 0x289EC34FB400288, 0x289E728FB400288, 0x28991D1FB410288, 0x289D71FFB400288, 0x289E5E5FB400288, 0x289E82AFB400288, 0x289E709FB400288, 0x289F93EFB400288, 0x289D40DFB400288, 0x289F279FB400288, 0x2898CA1FB410288, 0x289F95DFB400288, 0x289D2B4FB400288, 0x289CEE3FB400288, 0x289D47CFB400288, 0x289DB66FB400288, 0x289F6E3FB400288, 0x289CF01FB400288, 0x2898CC7FB410288, 0x289D354FB400288, 0x289F96DFB400288, 0x289CF11FB400288, 0x28981EAFB410288, 0x28981F3FB410288, 0xB244FBC0, 0xB245FBC0, 0xB246FBC0, 0xB247FBC0, 0xB248FBC0, /* 31BA */
+ 0xB249FBC0, 0xB24AFBC0, 0xB24BFBC0, 0xB24CFBC0, 0xB24DFBC0, 0xB24EFBC0, 0xB24FFBC0, 0xE8B10020FA7, 0xE2A0E2B, 0xE2B0E2B, 0xE2C0E2B, 0xE2D0E2B, 0xE2E0E2B, 0xE2F0E2B, 0xE300E2B, 0xE310E2B, 0xE320E2B, 0xE290E2C, 0xE2A0E2C, 0xE2B0E2C, 0xE2C0E2C, 0xE2D0E2C, 0xE2E0E2C, 0x1D62, 0x1D64, 0x1D65, 0x1D67, 0x1D68, 0x1D69, 0x1D6B, 0x1D6D, 0x1D6E, 0x1D70, 0x1D71, 0x1D72, 0x1D73, 0x1D74, 0x1DBE1D62, 0x1DBE1D64, 0x1DBE1D65, 0x1DBE1D67, 0x1DBE1D68, 0x1DBE1D69, 0x1DBE1D6B, 0x1DBE1D6D, 0x1DBE1D6E, 0x1DBE1D70, 0x1DBE1D71, 0x1DBE1D72, 0x1DBE1D73, 0x1DBE1D74, 0xFFFD, 0x1DD11D6D1DCB1D6E, 0xB27EFBC0, 0xDC4, 0xCE00FB40, 0xCE8CFB40, 0xCE09FB40, 0xD6DBFB40, 0xCE94FB40, 0xD16DFB40, 0xCE03FB40, 0xD16BFB40, 0xCE5DFB40, 0xD341FB40, 0xE708FB40, 0xF06BFB40, 0xEC34FB40, 0xE728FB40, 0x91D1FB41, 0xD71FFB40, 0xE5E5FB40, 0xE82AFB40, 0xE709FB40, 0xF93EFB40, 0xD40DFB40, 0xF279FB40, 0x8CA1FB41, 0xF95DFB40, 0xD2B4FB40, 0xF9D8FB40, 0xF537FB40, 0xD973FB40, 0x9069FB41, 0xD12AFB40, 0xD370FB40, 0xECE8FB40, 0x9805FB41, 0xCF11FB40, 0xD199FB40, 0xEB63FB40, 0xCE0AFB40, 0xCE2DFB40, 0xCE0BFB40, 0xDDE6FB40, 0xD3F3FB40, 0xD33BFB40, 0xDB97FB40, 0xDB66FB40, 0xF6E3FB40, 0xCF01FB40, 0x8CC7FB41, 0xD354FB40, 0xD91CFB40, 0xE2F0E2C, 0xE300E2C, 0xE310E2C, 0xE320E2C, 0xE290E2D, 0xE2A0E2D, 0xE2B0E2D, 0xE2C0E2D, 0xE2D0E2D, 0xE2E0E2D, 0xE2F0E2D, 0xE300E2D, 0xE310E2D, 0xE320E2D, 0xE290E2E, 0xE708FB400E2A, 0xE708FB400E2B, 0xE708FB400E2C, 0xE708FB400E2D, 0xE708FB400E2E, 0xE708FB400E2F, 0xE708FB400E30, 0xE708FB400E31, 0xE708FB400E32, 0xE708FB400E290E2A, 0xE708FB400E2A0E2A, 0xE708FB400E2B0E2A, 0xEC10EE1, 0xEC10FC00E8B, 0x10440E8B, 0xE6D10020F2E, 0x1E52, 0x1E53, 0x1E54, 0x1E55, 0x1E56, 0x1E57, 0x1E58, 0x1E59, 0x1E5A, 0x1E5B, 0x1E5C, 0x1E5D, 0x1E5E, 0x1E5F, 0x1E60, 0x1E61, 0x1E62, 0x1E63, 0x1E64, 0x1E65, 0x1E66, 0x1E67, 0x1E68, 0x1E69, 0x1E6A, 0x1E6B, 0x1E6C, 0x1E6D, 0x1E6E, 0x1E6F, 0x1E70, 0x1E71, 0x1E72, 0x1E73, 0x1E74, 0x1E75, 0x1E76, 0x1E77, 0x1E78, 0x1E79, 0x1E7A, 0x1E7B, 0x1E7C, 0x1E7D, 0x1E7E, 0x1E7F, 0x1E80, 0xB2FFFBC0, 0x1E650E0B1E6B1E52, 0x1E521E6D1E7A1E52, /* 3249 */
+ 0x1E521E6E1E811E52, 0x1E7A0E0B1E52, 0x1E591E811E671E53, 0x1E621E811E53, 0x1E811E561E54, 0xFFFD, 0xE0B1E570E0B1E55, 0x1E5E1E811E56, 0x1E720E0B1E56, 0x1E791E531E57, 0x1E651E631E781E57, 0xE0B1E791E7C1E57, 0x1E811E7C1E57, 0x1E701E811E57, 0x1E571E58, 0xE0B1E671E58, 0xE0B1E791E761E58, 0xE0B1E611E7A1E58, 0x1E7C1E58, 0xFFFD, 0xFFFD, 0xFFFD, 0x1E721E781E59, 0xFFFD, 0xFFFD, 0x1E690E0B1E7C1E59, 0x1E5E0E0B1E5A, 0x1E661E7A1E5B, 0x1E6F0E0B1E5B, 0x1E7A1E591E531E5C, 0xFFFD, 0x1E591E811E791E5D, 0x1E621E811E5F, 0x1E651E811E5F, 0x1E5E0E0B1E61, 0x1E5D1E64, 0x1E7A1E65, 0x1E811E65, 0x1E6A1E66, 0x1E651E631E6A, 0x1E631E531E6B, 0xFFFD, 0x1E630E0B1E6B, 0x1E7A1E7B0E0B1E6B, 0xFFFD, 0x1E7A1E591E6C, 0x1E5B1E6C, 0x1E7A1E6C, 0xFFFD, 0x1E650E0B1E531E6D, 0xFFFD, 0x1E811E781E6D, 0xFFFD, 0x1E601E6E, 0x1E6C1E671E6E, 0x1E631E7A1E6E, 0x1E5E1E811E6E, 0x1E5D0E0B1E6E, 0x1E610E0B1E6E, 0x1E651E811E531E6F, 0x1E651E7A1E6F, 0x1E811E6F, 0x1E651E811E6F, 0x1E7A0E0B1E6F, 0x1E810E0B1E6F, 0x1E7C1E591E531E70, 0x1E7A1E531E70, 0x1E6B1E631E70, 0x1E591E7A1E70, 0xFFFD, 0x1E811E7C1E591E71, 0x1E791E71, 0xFFFD, 0x1E571E73, 0x1E811E651E571E73, 0x1E7A1E650E0B1E73, 0x1E650E0B1E75, 0x1E7A0E0B1E75, 0x1E811E521E76, 0x1E7A1E651E631E79, 0x1E781E79, 0xE0B1E6C1E7A, 0x1E7A1E6D0E0B1E7A, 0x1E721E7B, 0xFFFD, 0x1E651E631E7D, 0xF0B9FB400E29, 0xF0B9FB400E2A, 0xF0B9FB400E2B, 0xF0B9FB400E2C, 0xF0B9FB400E2D, 0xF0B9FB400E2E, 0xF0B9FB400E2F, 0xF0B9FB400E30, 0xF0B9FB400E31, 0xF0B9FB400E32, 0xF0B9FB400E290E2A, 0xF0B9FB400E2A0E2A, 0xF0B9FB400E2B0E2A, 0xF0B9FB400E2C0E2A, 0xF0B9FB400E2D0E2A, 0xF0B9FB400E2E0E2A, 0xF0B9FB400E2F0E2A, 0xF0B9FB400E300E2A, 0xF0B9FB400E310E2A, 0xF0B9FB400E320E2A, 0xF0B9FB400E290E2B, 0xF0B9FB400E2A0E2B, 0xF0B9FB400E2B0E2B, 0xF0B9FB400E2C0E2B, 0xF0B9FB400E2D0E2B, 0xE330FA70EE1, 0xE330E6D, 0x101F0E33, 0xFC00E330E4A, 0x10440F82, 0xE600FA7, 0xF5B0E6D, 0xE2B0F5B0E6D, 0xE2C0F5B0E6D, 0x101F0EFB, 0xE210FB40DE73FB40, 0xD48CFB40E62DFB40, 0xEB63FB40D927FB40, 0xECBBFB40E60EFB40, 0xFFFD, 0xE330FA7, 0xE330F64, 0xE3310F8, 0xE330F5B, 0xE330F21, 0xE4A0F21, 0xE4A0F5B, 0xE4A0EC1, /* 3302 */
+ 0xF2E0E330E60, 0xF2E0E330E600F21, 0xEB90FA7, 0xEB90F64, 0xEB910F8, 0xEC110F8, 0xEC10F5B, 0xEC10F21, 0x106A0EE1, 0x106A0EE10F21, 0x106A0EE10F5B, 0x106A0EE10EC1, 0x106A0EE11002, 0xF2E10F8, 0xF2E0F5B, 0xF2E0E6D, 0xF2E0F21, 0xF5B0EB9, 0xF5B0F64, 0xF5B10F8, 0xF5B0F5B, 0xF5B0E60, 0xF5B0F21, 0xE2B0F5B0F5B, 0xE2B0F5B0E60, 0xE2B0F5B, 0xE2B0F5B0F21, 0xE2C0F5B0F5B, 0xE2C0F5B0E60, 0xE2C0F5B, 0xE2C0F5B0F21, 0xFEA04370F5B, 0xE2B0FEA04370F5B, 0xE330FA7, 0xE330FA70F21, 0xE330FA70F5B, 0xE330FA70EC1, 0xE6D0E330FC0, 0xFFFD, 0xFFFD, 0xFEA0FA7, 0xFEA0F64, 0xFEA10F8, 0xFEA0F5B, 0x10440FA7, 0x10440F64, 0x104410F8, 0x10440F5B, 0x10440F21, 0x10440F5B, 0x10510FA7, 0x10510F64, 0x105110F8, 0x10510F5B, 0x10510F21, 0x10510F5B, 0x11090F21, 0x11090F5B, 0x25D0F5B025D0E33, 0xFB40E4A, 0xE600E60, 0xE6D0E60, 0xEC10F2104370E60, 0x25D0F820E60, 0xE4A0E6D, 0x105E0EC1, 0xE330EE1, 0xFA70EE1, 0xF640EFB, 0xF210F21, 0xF5B0F21, 0x10020F21, 0xF5B0F2E, 0xF640F2E, 0xEC10F820F2E, 0x105A0F2E, 0xE4A0F5B, 0xF2E0EFB0F5B, 0xF2E0F820F5B, 0xEE10FA7, 0x25D0F5B025D0FA7, 0xF5B0FA70FA7, 0xFC00FA7, 0xFC00FEA, 0x10440FEA, 0xE4A1051, 0xF5B04371044, 0xF5B04370E33, 0xE5E5FB400E2A, 0xE5E5FB400E2B, 0xE5E5FB400E2C, 0xE5E5FB400E2D, 0xE5E5FB400E2E, 0xE5E5FB400E2F, 0xE5E5FB400E30, 0xE5E5FB400E31, 0xE5E5FB400E32, 0xE5E5FB400E290E2A, 0xE5E5FB400E2A0E2A, 0xE5E5FB400E2B0E2A, 0xE5E5FB400E2C0E2A, 0xE5E5FB400E2D0E2A, 0xE5E5FB400E2E0E2A, 0xE5E5FB400E2F0E2A, 0xE5E5FB400E300E2A, 0xE5E5FB400E310E2A, 0xE5E5FB400E320E2A, 0xE5E5FB400E290E2B, 0xE5E5FB400E2A0E2B, 0xE5E5FB400E2B0E2B, 0xE5E5FB400E2C0E2B, 0xE5E5FB400E2D0E2B, 0xE5E5FB400E2E0E2B, 0xE5E5FB400E2F0E2B, 0xE5E5FB400E300E2B, 0xE5E5FB400E310E2B, 0xE5E5FB400E320E2B, 0xE5E5FB400E290E2C, 0xE5E5FB400E2A0E2C, 0xF2E0E330EC1, 0xB400FB80, 0xB401FB80, 0xB402FB80, 0xB403FB80, 0xB404FB80, 0xB405FB80, 0xB406FB80, 0xB407FB80, 0xB408FB80, 0xB409FB80, 0xB40AFB80, 0xB40BFB80, 0xB40CFB80, 0xB40DFB80, 0xB40EFB80, 0xB40FFB80, 0xB410FB80, 0xB411FB80, 0xB412FB80, 0xB413FB80, 0xB414FB80, 0xB415FB80, 0xB416FB80, 0xB417FB80, 0xB418FB80, 0xB419FB80, 0xB41AFB80, /* 3388 */
+ 0xB41BFB80, 0xB41CFB80, 0xB41DFB80, 0xB41EFB80, 0xB41FFB80, 0xB420FB80, 0xB421FB80, 0xB422FB80, 0xB423FB80, 0xB424FB80, 0xB425FB80, 0xB426FB80, 0xB427FB80, 0xB428FB80, 0xB429FB80, 0xB42AFB80, 0xB42BFB80, 0xB42CFB80, 0xB42DFB80, 0xB42EFB80, 0xB42FFB80, 0xB430FB80, 0xB431FB80, 0xB432FB80, 0xB433FB80, 0xB434FB80, 0xB435FB80, 0xB436FB80, 0xB437FB80, 0xB438FB80, 0xB439FB80, 0xB43AFB80, 0xB43BFB80, 0xB43CFB80, 0xB43DFB80, 0xB43EFB80, 0xB43FFB80, 0xB440FB80, 0xB441FB80, 0xB442FB80, 0xB443FB80, 0xB444FB80, 0xB445FB80, 0xB446FB80, 0xB447FB80, 0xB448FB80, 0xB449FB80, 0xB44AFB80, 0xB44BFB80, 0xB44CFB80, 0xB44DFB80, 0xB44EFB80, 0xB44FFB80, 0xB450FB80, 0xB451FB80, 0xB452FB80, 0xB453FB80, 0xB454FB80, 0xB455FB80, 0xB456FB80, 0xB457FB80, 0xB458FB80, 0xB459FB80, 0xB45AFB80, 0xB45BFB80, 0xB45CFB80, 0xB45DFB80, 0xB45EFB80, 0xB45FFB80, 0xB460FB80, 0xB461FB80, 0xB462FB80, 0xB463FB80, 0xB464FB80, 0xB465FB80, 0xB466FB80, 0xB467FB80, 0xB468FB80, 0xB469FB80, 0xB46AFB80, 0xB46BFB80, 0xB46CFB80, 0xB46DFB80, 0xB46EFB80, 0xB46FFB80, 0xB470FB80, 0xB471FB80, 0xB472FB80, 0xB473FB80, 0xB474FB80, 0xB475FB80, 0xB476FB80, 0xB477FB80, 0xB478FB80, 0xB479FB80, 0xB47AFB80, 0xB47BFB80, 0xB47CFB80, 0xB47DFB80, 0xB47EFB80, 0xB47FFB80, 0xB480FB80, 0xB481FB80, 0xB482FB80, 0xB483FB80, 0xB484FB80, 0xB485FB80, 0xB486FB80, 0xB487FB80, 0xB488FB80, 0xB489FB80, 0xB48AFB80, 0xB48BFB80, 0xB48CFB80, 0xB48DFB80, 0xB48EFB80, 0xB48FFB80, 0xB490FB80, 0xB491FB80, 0xB492FB80, 0xB493FB80, 0xB494FB80, 0xB495FB80, 0xB496FB80, 0xB497FB80, 0xB498FB80, 0xB499FB80, 0xB49AFB80, 0xB49BFB80, 0xB49CFB80, 0xB49DFB80, 0xB49EFB80, 0xB49FFB80, 0xB4A0FB80, 0xB4A1FB80, 0xB4A2FB80, 0xB4A3FB80, 0xB4A4FB80, 0xB4A5FB80, 0xB4A6FB80, 0xB4A7FB80, 0xB4A8FB80, 0xB4A9FB80, 0xB4AAFB80, 0xB4ABFB80, 0xB4ACFB80, 0xB4ADFB80, 0xB4AEFB80, 0xB4AFFB80, 0xB4B0FB80, 0xB4B1FB80, 0xB4B2FB80, 0xB4B3FB80, 0xB4B4FB80, 0xB4B5FB80, 0xB4B6FB80, 0xB4B7FB80, 0xB4B8FB80, 0xB4B9FB80, 0xB4BAFB80, 0xB4BBFB80, 0xB4BCFB80, 0xB4BDFB80, 0xB4BEFB80, 0xB4BFFB80, 0xB4C0FB80, 0xB4C1FB80, 0xB4C2FB80, 0xB4C3FB80, 0xB4C4FB80, /* 341B */
+ 0xB4C5FB80, 0xB4C6FB80, 0xB4C7FB80, 0xB4C8FB80, 0xB4C9FB80, 0xB4CAFB80, 0xB4CBFB80, 0xB4CCFB80, 0xB4CDFB80, 0xB4CEFB80, 0xB4CFFB80, 0xB4D0FB80, 0xB4D1FB80, 0xB4D2FB80, 0xB4D3FB80, 0xB4D4FB80, 0xB4D5FB80, 0xB4D6FB80, 0xB4D7FB80, 0xB4D8FB80, 0xB4D9FB80, 0xB4DAFB80, 0xB4DBFB80, 0xB4DCFB80, 0xB4DDFB80, 0xB4DEFB80, 0xB4DFFB80, 0xB4E0FB80, 0xB4E1FB80, 0xB4E2FB80, 0xB4E3FB80, 0xB4E4FB80, 0xB4E5FB80, 0xB4E6FB80, 0xB4E7FB80, 0xB4E8FB80, 0xB4E9FB80, 0xB4EAFB80, 0xB4EBFB80, 0xB4ECFB80, 0xB4EDFB80, 0xB4EEFB80, 0xB4EFFB80, 0xB4F0FB80, 0xB4F1FB80, 0xB4F2FB80, 0xB4F3FB80, 0xB4F4FB80, 0xB4F5FB80, 0xB4F6FB80, 0xB4F7FB80, 0xB4F8FB80, 0xB4F9FB80, 0xB4FAFB80, 0xB4FBFB80, 0xB4FCFB80, 0xB4FDFB80, 0xB4FEFB80, 0xB4FFFB80, 0xB500FB80, 0xB501FB80, 0xB502FB80, 0xB503FB80, 0xB504FB80, 0xB505FB80, 0xB506FB80, 0xB507FB80, 0xB508FB80, 0xB509FB80, 0xB50AFB80, 0xB50BFB80, 0xB50CFB80, 0xB50DFB80, 0xB50EFB80, 0xB50FFB80, 0xB510FB80, 0xB511FB80, 0xB512FB80, 0xB513FB80, 0xB514FB80, 0xB515FB80, 0xB516FB80, 0xB517FB80, 0xB518FB80, 0xB519FB80, 0xB51AFB80, 0xB51BFB80, 0xB51CFB80, 0xB51DFB80, 0xB51EFB80, 0xB51FFB80, 0xB520FB80, 0xB521FB80, 0xB522FB80, 0xB523FB80, 0xB524FB80, 0xB525FB80, 0xB526FB80, 0xB527FB80, 0xB528FB80, 0xB529FB80, 0xB52AFB80, 0xB52BFB80, 0xB52CFB80, 0xB52DFB80, 0xB52EFB80, 0xB52FFB80, 0xB530FB80, 0xB531FB80, 0xB532FB80, 0xB533FB80, 0xB534FB80, 0xB535FB80, 0xB536FB80, 0xB537FB80, 0xB538FB80, 0xB539FB80, 0xB53AFB80, 0xB53BFB80, 0xB53CFB80, 0xB53DFB80, 0xB53EFB80, 0xB53FFB80, 0xB540FB80, 0xB541FB80, 0xB542FB80, 0xB543FB80, 0xB544FB80, 0xB545FB80, 0xB546FB80, 0xB547FB80, 0xB548FB80, 0xB549FB80, 0xB54AFB80, 0xB54BFB80, 0xB54CFB80, 0xB54DFB80, 0xB54EFB80, 0xB54FFB80, 0xB550FB80, 0xB551FB80, 0xB552FB80, 0xB553FB80, 0xB554FB80, 0xB555FB80, 0xB556FB80, 0xB557FB80, 0xB558FB80, 0xB559FB80, 0xB55AFB80, 0xB55BFB80, 0xB55CFB80, 0xB55DFB80, 0xB55EFB80, 0xB55FFB80, 0xB560FB80, 0xB561FB80, 0xB562FB80, 0xB563FB80, 0xB564FB80, 0xB565FB80, 0xB566FB80, 0xB567FB80, 0xB568FB80, 0xB569FB80, 0xB56AFB80, 0xB56BFB80, 0xB56CFB80, 0xB56DFB80, 0xB56EFB80, /* 34C5 */
+ 0xB56FFB80, 0xB570FB80, 0xB571FB80, 0xB572FB80, 0xB573FB80, 0xB574FB80, 0xB575FB80, 0xB576FB80, 0xB577FB80, 0xB578FB80, 0xB579FB80, 0xB57AFB80, 0xB57BFB80, 0xB57CFB80, 0xB57DFB80, 0xB57EFB80, 0xB57FFB80, 0xB580FB80, 0xB581FB80, 0xB582FB80, 0xB583FB80, 0xB584FB80, 0xB585FB80, 0xB586FB80, 0xB587FB80, 0xB588FB80, 0xB589FB80, 0xB58AFB80, 0xB58BFB80, 0xB58CFB80, 0xB58DFB80, 0xB58EFB80, 0xB58FFB80, 0xB590FB80, 0xB591FB80, 0xB592FB80, 0xB593FB80, 0xB594FB80, 0xB595FB80, 0xB596FB80, 0xB597FB80, 0xB598FB80, 0xB599FB80, 0xB59AFB80, 0xB59BFB80, 0xB59CFB80, 0xB59DFB80, 0xB59EFB80, 0xB59FFB80, 0xB5A0FB80, 0xB5A1FB80, 0xB5A2FB80, 0xB5A3FB80, 0xB5A4FB80, 0xB5A5FB80, 0xB5A6FB80, 0xB5A7FB80, 0xB5A8FB80, 0xB5A9FB80, 0xB5AAFB80, 0xB5ABFB80, 0xB5ACFB80, 0xB5ADFB80, 0xB5AEFB80, 0xB5AFFB80, 0xB5B0FB80, 0xB5B1FB80, 0xB5B2FB80, 0xB5B3FB80, 0xB5B4FB80, 0xB5B5FB80, 0xB5B6FB80, 0xB5B7FB80, 0xB5B8FB80, 0xB5B9FB80, 0xB5BAFB80, 0xB5BBFB80, 0xB5BCFB80, 0xB5BDFB80, 0xB5BEFB80, 0xB5BFFB80, 0xB5C0FB80, 0xB5C1FB80, 0xB5C2FB80, 0xB5C3FB80, 0xB5C4FB80, 0xB5C5FB80, 0xB5C6FB80, 0xB5C7FB80, 0xB5C8FB80, 0xB5C9FB80, 0xB5CAFB80, 0xB5CBFB80, 0xB5CCFB80, 0xB5CDFB80, 0xB5CEFB80, 0xB5CFFB80, 0xB5D0FB80, 0xB5D1FB80, 0xB5D2FB80, 0xB5D3FB80, 0xB5D4FB80, 0xB5D5FB80, 0xB5D6FB80, 0xB5D7FB80, 0xB5D8FB80, 0xB5D9FB80, 0xB5DAFB80, 0xB5DBFB80, 0xB5DCFB80, 0xB5DDFB80, 0xB5DEFB80, 0xB5DFFB80, 0xB5E0FB80, 0xB5E1FB80, 0xB5E2FB80, 0xB5E3FB80, 0xB5E4FB80, 0xB5E5FB80, 0xB5E6FB80, 0xB5E7FB80, 0xB5E8FB80, 0xB5E9FB80, 0xB5EAFB80, 0xB5EBFB80, 0xB5ECFB80, 0xB5EDFB80, 0xB5EEFB80, 0xB5EFFB80, 0xB5F0FB80, 0xB5F1FB80, 0xB5F2FB80, 0xB5F3FB80, 0xB5F4FB80, 0xB5F5FB80, 0xB5F6FB80, 0xB5F7FB80, 0xB5F8FB80, 0xB5F9FB80, 0xB5FAFB80, 0xB5FBFB80, 0xB5FCFB80, 0xB5FDFB80, 0xB5FEFB80, 0xB5FFFB80, 0xB600FB80, 0xB601FB80, 0xB602FB80, 0xB603FB80, 0xB604FB80, 0xB605FB80, 0xB606FB80, 0xB607FB80, 0xB608FB80, 0xB609FB80, 0xB60AFB80, 0xB60BFB80, 0xB60CFB80, 0xB60DFB80, 0xB60EFB80, 0xB60FFB80, 0xB610FB80, 0xB611FB80, 0xB612FB80, 0xB613FB80, 0xB614FB80, 0xB615FB80, 0xB616FB80, 0xB617FB80, 0xB618FB80, /* 356F */
+ 0xB619FB80, 0xB61AFB80, 0xB61BFB80, 0xB61CFB80, 0xB61DFB80, 0xB61EFB80, 0xB61FFB80, 0xB620FB80, 0xB621FB80, 0xB622FB80, 0xB623FB80, 0xB624FB80, 0xB625FB80, 0xB626FB80, 0xB627FB80, 0xB628FB80, 0xB629FB80, 0xB62AFB80, 0xB62BFB80, 0xB62CFB80, 0xB62DFB80, 0xB62EFB80, 0xB62FFB80, 0xB630FB80, 0xB631FB80, 0xB632FB80, 0xB633FB80, 0xB634FB80, 0xB635FB80, 0xB636FB80, 0xB637FB80, 0xB638FB80, 0xB639FB80, 0xB63AFB80, 0xB63BFB80, 0xB63CFB80, 0xB63DFB80, 0xB63EFB80, 0xB63FFB80, 0xB640FB80, 0xB641FB80, 0xB642FB80, 0xB643FB80, 0xB644FB80, 0xB645FB80, 0xB646FB80, 0xB647FB80, 0xB648FB80, 0xB649FB80, 0xB64AFB80, 0xB64BFB80, 0xB64CFB80, 0xB64DFB80, 0xB64EFB80, 0xB64FFB80, 0xB650FB80, 0xB651FB80, 0xB652FB80, 0xB653FB80, 0xB654FB80, 0xB655FB80, 0xB656FB80, 0xB657FB80, 0xB658FB80, 0xB659FB80, 0xB65AFB80, 0xB65BFB80, 0xB65CFB80, 0xB65DFB80, 0xB65EFB80, 0xB65FFB80, 0xB660FB80, 0xB661FB80, 0xB662FB80, 0xB663FB80, 0xB664FB80, 0xB665FB80, 0xB666FB80, 0xB667FB80, 0xB668FB80, 0xB669FB80, 0xB66AFB80, 0xB66BFB80, 0xB66CFB80, 0xB66DFB80, 0xB66EFB80, 0xB66FFB80, 0xB670FB80, 0xB671FB80, 0xB672FB80, 0xB673FB80, 0xB674FB80, 0xB675FB80, 0xB676FB80, 0xB677FB80, 0xB678FB80, 0xB679FB80, 0xB67AFB80, 0xB67BFB80, 0xB67CFB80, 0xB67DFB80, 0xB67EFB80, 0xB67FFB80, 0xB680FB80, 0xB681FB80, 0xB682FB80, 0xB683FB80, 0xB684FB80, 0xB685FB80, 0xB686FB80, 0xB687FB80, 0xB688FB80, 0xB689FB80, 0xB68AFB80, 0xB68BFB80, 0xB68CFB80, 0xB68DFB80, 0xB68EFB80, 0xB68FFB80, 0xB690FB80, 0xB691FB80, 0xB692FB80, 0xB693FB80, 0xB694FB80, 0xB695FB80, 0xB696FB80, 0xB697FB80, 0xB698FB80, 0xB699FB80, 0xB69AFB80, 0xB69BFB80, 0xB69CFB80, 0xB69DFB80, 0xB69EFB80, 0xB69FFB80, 0xB6A0FB80, 0xB6A1FB80, 0xB6A2FB80, 0xB6A3FB80, 0xB6A4FB80, 0xB6A5FB80, 0xB6A6FB80, 0xB6A7FB80, 0xB6A8FB80, 0xB6A9FB80, 0xB6AAFB80, 0xB6ABFB80, 0xB6ACFB80, 0xB6ADFB80, 0xB6AEFB80, 0xB6AFFB80, 0xB6B0FB80, 0xB6B1FB80, 0xB6B2FB80, 0xB6B3FB80, 0xB6B4FB80, 0xB6B5FB80, 0xB6B6FB80, 0xB6B7FB80, 0xB6B8FB80, 0xB6B9FB80, 0xB6BAFB80, 0xB6BBFB80, 0xB6BCFB80, 0xB6BDFB80, 0xB6BEFB80, 0xB6BFFB80, 0xB6C0FB80, 0xB6C1FB80, 0xB6C2FB80, /* 3619 */
+ 0xB6C3FB80, 0xB6C4FB80, 0xB6C5FB80, 0xB6C6FB80, 0xB6C7FB80, 0xB6C8FB80, 0xB6C9FB80, 0xB6CAFB80, 0xB6CBFB80, 0xB6CCFB80, 0xB6CDFB80, 0xB6CEFB80, 0xB6CFFB80, 0xB6D0FB80, 0xB6D1FB80, 0xB6D2FB80, 0xB6D3FB80, 0xB6D4FB80, 0xB6D5FB80, 0xB6D6FB80, 0xB6D7FB80, 0xB6D8FB80, 0xB6D9FB80, 0xB6DAFB80, 0xB6DBFB80, 0xB6DCFB80, 0xB6DDFB80, 0xB6DEFB80, 0xB6DFFB80, 0xB6E0FB80, 0xB6E1FB80, 0xB6E2FB80, 0xB6E3FB80, 0xB6E4FB80, 0xB6E5FB80, 0xB6E6FB80, 0xB6E7FB80, 0xB6E8FB80, 0xB6E9FB80, 0xB6EAFB80, 0xB6EBFB80, 0xB6ECFB80, 0xB6EDFB80, 0xB6EEFB80, 0xB6EFFB80, 0xB6F0FB80, 0xB6F1FB80, 0xB6F2FB80, 0xB6F3FB80, 0xB6F4FB80, 0xB6F5FB80, 0xB6F6FB80, 0xB6F7FB80, 0xB6F8FB80, 0xB6F9FB80, 0xB6FAFB80, 0xB6FBFB80, 0xB6FCFB80, 0xB6FDFB80, 0xB6FEFB80, 0xB6FFFB80, 0xB700FB80, 0xB701FB80, 0xB702FB80, 0xB703FB80, 0xB704FB80, 0xB705FB80, 0xB706FB80, 0xB707FB80, 0xB708FB80, 0xB709FB80, 0xB70AFB80, 0xB70BFB80, 0xB70CFB80, 0xB70DFB80, 0xB70EFB80, 0xB70FFB80, 0xB710FB80, 0xB711FB80, 0xB712FB80, 0xB713FB80, 0xB714FB80, 0xB715FB80, 0xB716FB80, 0xB717FB80, 0xB718FB80, 0xB719FB80, 0xB71AFB80, 0xB71BFB80, 0xB71CFB80, 0xB71DFB80, 0xB71EFB80, 0xB71FFB80, 0xB720FB80, 0xB721FB80, 0xB722FB80, 0xB723FB80, 0xB724FB80, 0xB725FB80, 0xB726FB80, 0xB727FB80, 0xB728FB80, 0xB729FB80, 0xB72AFB80, 0xB72BFB80, 0xB72CFB80, 0xB72DFB80, 0xB72EFB80, 0xB72FFB80, 0xB730FB80, 0xB731FB80, 0xB732FB80, 0xB733FB80, 0xB734FB80, 0xB735FB80, 0xB736FB80, 0xB737FB80, 0xB738FB80, 0xB739FB80, 0xB73AFB80, 0xB73BFB80, 0xB73CFB80, 0xB73DFB80, 0xB73EFB80, 0xB73FFB80, 0xB740FB80, 0xB741FB80, 0xB742FB80, 0xB743FB80, 0xB744FB80, 0xB745FB80, 0xB746FB80, 0xB747FB80, 0xB748FB80, 0xB749FB80, 0xB74AFB80, 0xB74BFB80, 0xB74CFB80, 0xB74DFB80, 0xB74EFB80, 0xB74FFB80, 0xB750FB80, 0xB751FB80, 0xB752FB80, 0xB753FB80, 0xB754FB80, 0xB755FB80, 0xB756FB80, 0xB757FB80, 0xB758FB80, 0xB759FB80, 0xB75AFB80, 0xB75BFB80, 0xB75CFB80, 0xB75DFB80, 0xB75EFB80, 0xB75FFB80, 0xB760FB80, 0xB761FB80, 0xB762FB80, 0xB763FB80, 0xB764FB80, 0xB765FB80, 0xB766FB80, 0xB767FB80, 0xB768FB80, 0xB769FB80, 0xB76AFB80, 0xB76BFB80, 0xB76CFB80, /* 36C3 */
+ 0xB76DFB80, 0xB76EFB80, 0xB76FFB80, 0xB770FB80, 0xB771FB80, 0xB772FB80, 0xB773FB80, 0xB774FB80, 0xB775FB80, 0xB776FB80, 0xB777FB80, 0xB778FB80, 0xB779FB80, 0xB77AFB80, 0xB77BFB80, 0xB77CFB80, 0xB77DFB80, 0xB77EFB80, 0xB77FFB80, 0xB780FB80, 0xB781FB80, 0xB782FB80, 0xB783FB80, 0xB784FB80, 0xB785FB80, 0xB786FB80, 0xB787FB80, 0xB788FB80, 0xB789FB80, 0xB78AFB80, 0xB78BFB80, 0xB78CFB80, 0xB78DFB80, 0xB78EFB80, 0xB78FFB80, 0xB790FB80, 0xB791FB80, 0xB792FB80, 0xB793FB80, 0xB794FB80, 0xB795FB80, 0xB796FB80, 0xB797FB80, 0xB798FB80, 0xB799FB80, 0xB79AFB80, 0xB79BFB80, 0xB79CFB80, 0xB79DFB80, 0xB79EFB80, 0xB79FFB80, 0xB7A0FB80, 0xB7A1FB80, 0xB7A2FB80, 0xB7A3FB80, 0xB7A4FB80, 0xB7A5FB80, 0xB7A6FB80, 0xB7A7FB80, 0xB7A8FB80, 0xB7A9FB80, 0xB7AAFB80, 0xB7ABFB80, 0xB7ACFB80, 0xB7ADFB80, 0xB7AEFB80, 0xB7AFFB80, 0xB7B0FB80, 0xB7B1FB80, 0xB7B2FB80, 0xB7B3FB80, 0xB7B4FB80, 0xB7B5FB80, 0xB7B6FB80, 0xB7B7FB80, 0xB7B8FB80, 0xB7B9FB80, 0xB7BAFB80, 0xB7BBFB80, 0xB7BCFB80, 0xB7BDFB80, 0xB7BEFB80, 0xB7BFFB80, 0xB7C0FB80, 0xB7C1FB80, 0xB7C2FB80, 0xB7C3FB80, 0xB7C4FB80, 0xB7C5FB80, 0xB7C6FB80, 0xB7C7FB80, 0xB7C8FB80, 0xB7C9FB80, 0xB7CAFB80, 0xB7CBFB80, 0xB7CCFB80, 0xB7CDFB80, 0xB7CEFB80, 0xB7CFFB80, 0xB7D0FB80, 0xB7D1FB80, 0xB7D2FB80, 0xB7D3FB80, 0xB7D4FB80, 0xB7D5FB80, 0xB7D6FB80, 0xB7D7FB80, 0xB7D8FB80, 0xB7D9FB80, 0xB7DAFB80, 0xB7DBFB80, 0xB7DCFB80, 0xB7DDFB80, 0xB7DEFB80, 0xB7DFFB80, 0xB7E0FB80, 0xB7E1FB80, 0xB7E2FB80, 0xB7E3FB80, 0xB7E4FB80, 0xB7E5FB80, 0xB7E6FB80, 0xB7E7FB80, 0xB7E8FB80, 0xB7E9FB80, 0xB7EAFB80, 0xB7EBFB80, 0xB7ECFB80, 0xB7EDFB80, 0xB7EEFB80, 0xB7EFFB80, 0xB7F0FB80, 0xB7F1FB80, 0xB7F2FB80, 0xB7F3FB80, 0xB7F4FB80, 0xB7F5FB80, 0xB7F6FB80, 0xB7F7FB80, 0xB7F8FB80, 0xB7F9FB80, 0xB7FAFB80, 0xB7FBFB80, 0xB7FCFB80, 0xB7FDFB80, 0xB7FEFB80, 0xB7FFFB80, 0xB800FB80, 0xB801FB80, 0xB802FB80, 0xB803FB80, 0xB804FB80, 0xB805FB80, 0xB806FB80, 0xB807FB80, 0xB808FB80, 0xB809FB80, 0xB80AFB80, 0xB80BFB80, 0xB80CFB80, 0xB80DFB80, 0xB80EFB80, 0xB80FFB80, 0xB810FB80, 0xB811FB80, 0xB812FB80, 0xB813FB80, 0xB814FB80, 0xB815FB80, 0xB816FB80, /* 376D */
+ 0xB817FB80, 0xB818FB80, 0xB819FB80, 0xB81AFB80, 0xB81BFB80, 0xB81CFB80, 0xB81DFB80, 0xB81EFB80, 0xB81FFB80, 0xB820FB80, 0xB821FB80, 0xB822FB80, 0xB823FB80, 0xB824FB80, 0xB825FB80, 0xB826FB80, 0xB827FB80, 0xB828FB80, 0xB829FB80, 0xB82AFB80, 0xB82BFB80, 0xB82CFB80, 0xB82DFB80, 0xB82EFB80, 0xB82FFB80, 0xB830FB80, 0xB831FB80, 0xB832FB80, 0xB833FB80, 0xB834FB80, 0xB835FB80, 0xB836FB80, 0xB837FB80, 0xB838FB80, 0xB839FB80, 0xB83AFB80, 0xB83BFB80, 0xB83CFB80, 0xB83DFB80, 0xB83EFB80, 0xB83FFB80, 0xB840FB80, 0xB841FB80, 0xB842FB80, 0xB843FB80, 0xB844FB80, 0xB845FB80, 0xB846FB80, 0xB847FB80, 0xB848FB80, 0xB849FB80, 0xB84AFB80, 0xB84BFB80, 0xB84CFB80, 0xB84DFB80, 0xB84EFB80, 0xB84FFB80, 0xB850FB80, 0xB851FB80, 0xB852FB80, 0xB853FB80, 0xB854FB80, 0xB855FB80, 0xB856FB80, 0xB857FB80, 0xB858FB80, 0xB859FB80, 0xB85AFB80, 0xB85BFB80, 0xB85CFB80, 0xB85DFB80, 0xB85EFB80, 0xB85FFB80, 0xB860FB80, 0xB861FB80, 0xB862FB80, 0xB863FB80, 0xB864FB80, 0xB865FB80, 0xB866FB80, 0xB867FB80, 0xB868FB80, 0xB869FB80, 0xB86AFB80, 0xB86BFB80, 0xB86CFB80, 0xB86DFB80, 0xB86EFB80, 0xB86FFB80, 0xB870FB80, 0xB871FB80, 0xB872FB80, 0xB873FB80, 0xB874FB80, 0xB875FB80, 0xB876FB80, 0xB877FB80, 0xB878FB80, 0xB879FB80, 0xB87AFB80, 0xB87BFB80, 0xB87CFB80, 0xB87DFB80, 0xB87EFB80, 0xB87FFB80, 0xB880FB80, 0xB881FB80, 0xB882FB80, 0xB883FB80, 0xB884FB80, 0xB885FB80, 0xB886FB80, 0xB887FB80, 0xB888FB80, 0xB889FB80, 0xB88AFB80, 0xB88BFB80, 0xB88CFB80, 0xB88DFB80, 0xB88EFB80, 0xB88FFB80, 0xB890FB80, 0xB891FB80, 0xB892FB80, 0xB893FB80, 0xB894FB80, 0xB895FB80, 0xB896FB80, 0xB897FB80, 0xB898FB80, 0xB899FB80, 0xB89AFB80, 0xB89BFB80, 0xB89CFB80, 0xB89DFB80, 0xB89EFB80, 0xB89FFB80, 0xB8A0FB80, 0xB8A1FB80, 0xB8A2FB80, 0xB8A3FB80, 0xB8A4FB80, 0xB8A5FB80, 0xB8A6FB80, 0xB8A7FB80, 0xB8A8FB80, 0xB8A9FB80, 0xB8AAFB80, 0xB8ABFB80, 0xB8ACFB80, 0xB8ADFB80, 0xB8AEFB80, 0xB8AFFB80, 0xB8B0FB80, 0xB8B1FB80, 0xB8B2FB80, 0xB8B3FB80, 0xB8B4FB80, 0xB8B5FB80, 0xB8B6FB80, 0xB8B7FB80, 0xB8B8FB80, 0xB8B9FB80, 0xB8BAFB80, 0xB8BBFB80, 0xB8BCFB80, 0xB8BDFB80, 0xB8BEFB80, 0xB8BFFB80, 0xB8C0FB80, /* 3817 */
+ 0xB8C1FB80, 0xB8C2FB80, 0xB8C3FB80, 0xB8C4FB80, 0xB8C5FB80, 0xB8C6FB80, 0xB8C7FB80, 0xB8C8FB80, 0xB8C9FB80, 0xB8CAFB80, 0xB8CBFB80, 0xB8CCFB80, 0xB8CDFB80, 0xB8CEFB80, 0xB8CFFB80, 0xB8D0FB80, 0xB8D1FB80, 0xB8D2FB80, 0xB8D3FB80, 0xB8D4FB80, 0xB8D5FB80, 0xB8D6FB80, 0xB8D7FB80, 0xB8D8FB80, 0xB8D9FB80, 0xB8DAFB80, 0xB8DBFB80, 0xB8DCFB80, 0xB8DDFB80, 0xB8DEFB80, 0xB8DFFB80, 0xB8E0FB80, 0xB8E1FB80, 0xB8E2FB80, 0xB8E3FB80, 0xB8E4FB80, 0xB8E5FB80, 0xB8E6FB80, 0xB8E7FB80, 0xB8E8FB80, 0xB8E9FB80, 0xB8EAFB80, 0xB8EBFB80, 0xB8ECFB80, 0xB8EDFB80, 0xB8EEFB80, 0xB8EFFB80, 0xB8F0FB80, 0xB8F1FB80, 0xB8F2FB80, 0xB8F3FB80, 0xB8F4FB80, 0xB8F5FB80, 0xB8F6FB80, 0xB8F7FB80, 0xB8F8FB80, 0xB8F9FB80, 0xB8FAFB80, 0xB8FBFB80, 0xB8FCFB80, 0xB8FDFB80, 0xB8FEFB80, 0xB8FFFB80, 0xB900FB80, 0xB901FB80, 0xB902FB80, 0xB903FB80, 0xB904FB80, 0xB905FB80, 0xB906FB80, 0xB907FB80, 0xB908FB80, 0xB909FB80, 0xB90AFB80, 0xB90BFB80, 0xB90CFB80, 0xB90DFB80, 0xB90EFB80, 0xB90FFB80, 0xB910FB80, 0xB911FB80, 0xB912FB80, 0xB913FB80, 0xB914FB80, 0xB915FB80, 0xB916FB80, 0xB917FB80, 0xB918FB80, 0xB919FB80, 0xB91AFB80, 0xB91BFB80, 0xB91CFB80, 0xB91DFB80, 0xB91EFB80, 0xB91FFB80, 0xB920FB80, 0xB921FB80, 0xB922FB80, 0xB923FB80, 0xB924FB80, 0xB925FB80, 0xB926FB80, 0xB927FB80, 0xB928FB80, 0xB929FB80, 0xB92AFB80, 0xB92BFB80, 0xB92CFB80, 0xB92DFB80, 0xB92EFB80, 0xB92FFB80, 0xB930FB80, 0xB931FB80, 0xB932FB80, 0xB933FB80, 0xB934FB80, 0xB935FB80, 0xB936FB80, 0xB937FB80, 0xB938FB80, 0xB939FB80, 0xB93AFB80, 0xB93BFB80, 0xB93CFB80, 0xB93DFB80, 0xB93EFB80, 0xB93FFB80, 0xB940FB80, 0xB941FB80, 0xB942FB80, 0xB943FB80, 0xB944FB80, 0xB945FB80, 0xB946FB80, 0xB947FB80, 0xB948FB80, 0xB949FB80, 0xB94AFB80, 0xB94BFB80, 0xB94CFB80, 0xB94DFB80, 0xB94EFB80, 0xB94FFB80, 0xB950FB80, 0xB951FB80, 0xB952FB80, 0xB953FB80, 0xB954FB80, 0xB955FB80, 0xB956FB80, 0xB957FB80, 0xB958FB80, 0xB959FB80, 0xB95AFB80, 0xB95BFB80, 0xB95CFB80, 0xB95DFB80, 0xB95EFB80, 0xB95FFB80, 0xB960FB80, 0xB961FB80, 0xB962FB80, 0xB963FB80, 0xB964FB80, 0xB965FB80, 0xB966FB80, 0xB967FB80, 0xB968FB80, 0xB969FB80, 0xB96AFB80, /* 38C1 */
+ 0xB96BFB80, 0xB96CFB80, 0xB96DFB80, 0xB96EFB80, 0xB96FFB80, 0xB970FB80, 0xB971FB80, 0xB972FB80, 0xB973FB80, 0xB974FB80, 0xB975FB80, 0xB976FB80, 0xB977FB80, 0xB978FB80, 0xB979FB80, 0xB97AFB80, 0xB97BFB80, 0xB97CFB80, 0xB97DFB80, 0xB97EFB80, 0xB97FFB80, 0xB980FB80, 0xB981FB80, 0xB982FB80, 0xB983FB80, 0xB984FB80, 0xB985FB80, 0xB986FB80, 0xB987FB80, 0xB988FB80, 0xB989FB80, 0xB98AFB80, 0xB98BFB80, 0xB98CFB80, 0xB98DFB80, 0xB98EFB80, 0xB98FFB80, 0xB990FB80, 0xB991FB80, 0xB992FB80, 0xB993FB80, 0xB994FB80, 0xB995FB80, 0xB996FB80, 0xB997FB80, 0xB998FB80, 0xB999FB80, 0xB99AFB80, 0xB99BFB80, 0xB99CFB80, 0xB99DFB80, 0xB99EFB80, 0xB99FFB80, 0xB9A0FB80, 0xB9A1FB80, 0xB9A2FB80, 0xB9A3FB80, 0xB9A4FB80, 0xB9A5FB80, 0xB9A6FB80, 0xB9A7FB80, 0xB9A8FB80, 0xB9A9FB80, 0xB9AAFB80, 0xB9ABFB80, 0xB9ACFB80, 0xB9ADFB80, 0xB9AEFB80, 0xB9AFFB80, 0xB9B0FB80, 0xB9B1FB80, 0xB9B2FB80, 0xB9B3FB80, 0xB9B4FB80, 0xB9B5FB80, 0xB9B6FB80, 0xB9B7FB80, 0xB9B8FB80, 0xB9B9FB80, 0xB9BAFB80, 0xB9BBFB80, 0xB9BCFB80, 0xB9BDFB80, 0xB9BEFB80, 0xB9BFFB80, 0xB9C0FB80, 0xB9C1FB80, 0xB9C2FB80, 0xB9C3FB80, 0xB9C4FB80, 0xB9C5FB80, 0xB9C6FB80, 0xB9C7FB80, 0xB9C8FB80, 0xB9C9FB80, 0xB9CAFB80, 0xB9CBFB80, 0xB9CCFB80, 0xB9CDFB80, 0xB9CEFB80, 0xB9CFFB80, 0xB9D0FB80, 0xB9D1FB80, 0xB9D2FB80, 0xB9D3FB80, 0xB9D4FB80, 0xB9D5FB80, 0xB9D6FB80, 0xB9D7FB80, 0xB9D8FB80, 0xB9D9FB80, 0xB9DAFB80, 0xB9DBFB80, 0xB9DCFB80, 0xB9DDFB80, 0xB9DEFB80, 0xB9DFFB80, 0xB9E0FB80, 0xB9E1FB80, 0xB9E2FB80, 0xB9E3FB80, 0xB9E4FB80, 0xB9E5FB80, 0xB9E6FB80, 0xB9E7FB80, 0xB9E8FB80, 0xB9E9FB80, 0xB9EAFB80, 0xB9EBFB80, 0xB9ECFB80, 0xB9EDFB80, 0xB9EEFB80, 0xB9EFFB80, 0xB9F0FB80, 0xB9F1FB80, 0xB9F2FB80, 0xB9F3FB80, 0xB9F4FB80, 0xB9F5FB80, 0xB9F6FB80, 0xB9F7FB80, 0xB9F8FB80, 0xB9F9FB80, 0xB9FAFB80, 0xB9FBFB80, 0xB9FCFB80, 0xB9FDFB80, 0xB9FEFB80, 0xB9FFFB80, 0xBA00FB80, 0xBA01FB80, 0xBA02FB80, 0xBA03FB80, 0xBA04FB80, 0xBA05FB80, 0xBA06FB80, 0xBA07FB80, 0xBA08FB80, 0xBA09FB80, 0xBA0AFB80, 0xBA0BFB80, 0xBA0CFB80, 0xBA0DFB80, 0xBA0EFB80, 0xBA0FFB80, 0xBA10FB80, 0xBA11FB80, 0xBA12FB80, 0xBA13FB80, 0xBA14FB80, /* 396B */
+ 0xBA15FB80, 0xBA16FB80, 0xBA17FB80, 0xBA18FB80, 0xBA19FB80, 0xBA1AFB80, 0xBA1BFB80, 0xBA1CFB80, 0xBA1DFB80, 0xBA1EFB80, 0xBA1FFB80, 0xBA20FB80, 0xBA21FB80, 0xBA22FB80, 0xBA23FB80, 0xBA24FB80, 0xBA25FB80, 0xBA26FB80, 0xBA27FB80, 0xBA28FB80, 0xBA29FB80, 0xBA2AFB80, 0xBA2BFB80, 0xBA2CFB80, 0xBA2DFB80, 0xBA2EFB80, 0xBA2FFB80, 0xBA30FB80, 0xBA31FB80, 0xBA32FB80, 0xBA33FB80, 0xBA34FB80, 0xBA35FB80, 0xBA36FB80, 0xBA37FB80, 0xBA38FB80, 0xBA39FB80, 0xBA3AFB80, 0xBA3BFB80, 0xBA3CFB80, 0xBA3DFB80, 0xBA3EFB80, 0xBA3FFB80, 0xBA40FB80, 0xBA41FB80, 0xBA42FB80, 0xBA43FB80, 0xBA44FB80, 0xBA45FB80, 0xBA46FB80, 0xBA47FB80, 0xBA48FB80, 0xBA49FB80, 0xBA4AFB80, 0xBA4BFB80, 0xBA4CFB80, 0xBA4DFB80, 0xBA4EFB80, 0xBA4FFB80, 0xBA50FB80, 0xBA51FB80, 0xBA52FB80, 0xBA53FB80, 0xBA54FB80, 0xBA55FB80, 0xBA56FB80, 0xBA57FB80, 0xBA58FB80, 0xBA59FB80, 0xBA5AFB80, 0xBA5BFB80, 0xBA5CFB80, 0xBA5DFB80, 0xBA5EFB80, 0xBA5FFB80, 0xBA60FB80, 0xBA61FB80, 0xBA62FB80, 0xBA63FB80, 0xBA64FB80, 0xBA65FB80, 0xBA66FB80, 0xBA67FB80, 0xBA68FB80, 0xBA69FB80, 0xBA6AFB80, 0xBA6BFB80, 0xBA6CFB80, 0xBA6DFB80, 0xBA6EFB80, 0xBA6FFB80, 0xBA70FB80, 0xBA71FB80, 0xBA72FB80, 0xBA73FB80, 0xBA74FB80, 0xBA75FB80, 0xBA76FB80, 0xBA77FB80, 0xBA78FB80, 0xBA79FB80, 0xBA7AFB80, 0xBA7BFB80, 0xBA7CFB80, 0xBA7DFB80, 0xBA7EFB80, 0xBA7FFB80, 0xBA80FB80, 0xBA81FB80, 0xBA82FB80, 0xBA83FB80, 0xBA84FB80, 0xBA85FB80, 0xBA86FB80, 0xBA87FB80, 0xBA88FB80, 0xBA89FB80, 0xBA8AFB80, 0xBA8BFB80, 0xBA8CFB80, 0xBA8DFB80, 0xBA8EFB80, 0xBA8FFB80, 0xBA90FB80, 0xBA91FB80, 0xBA92FB80, 0xBA93FB80, 0xBA94FB80, 0xBA95FB80, 0xBA96FB80, 0xBA97FB80, 0xBA98FB80, 0xBA99FB80, 0xBA9AFB80, 0xBA9BFB80, 0xBA9CFB80, 0xBA9DFB80, 0xBA9EFB80, 0xBA9FFB80, 0xBAA0FB80, 0xBAA1FB80, 0xBAA2FB80, 0xBAA3FB80, 0xBAA4FB80, 0xBAA5FB80, 0xBAA6FB80, 0xBAA7FB80, 0xBAA8FB80, 0xBAA9FB80, 0xBAAAFB80, 0xBAABFB80, 0xBAACFB80, 0xBAADFB80, 0xBAAEFB80, 0xBAAFFB80, 0xBAB0FB80, 0xBAB1FB80, 0xBAB2FB80, 0xBAB3FB80, 0xBAB4FB80, 0xBAB5FB80, 0xBAB6FB80, 0xBAB7FB80, 0xBAB8FB80, 0xBAB9FB80, 0xBABAFB80, 0xBABBFB80, 0xBABCFB80, 0xBABDFB80, 0xBABEFB80, /* 3A15 */
+ 0xBABFFB80, 0xBAC0FB80, 0xBAC1FB80, 0xBAC2FB80, 0xBAC3FB80, 0xBAC4FB80, 0xBAC5FB80, 0xBAC6FB80, 0xBAC7FB80, 0xBAC8FB80, 0xBAC9FB80, 0xBACAFB80, 0xBACBFB80, 0xBACCFB80, 0xBACDFB80, 0xBACEFB80, 0xBACFFB80, 0xBAD0FB80, 0xBAD1FB80, 0xBAD2FB80, 0xBAD3FB80, 0xBAD4FB80, 0xBAD5FB80, 0xBAD6FB80, 0xBAD7FB80, 0xBAD8FB80, 0xBAD9FB80, 0xBADAFB80, 0xBADBFB80, 0xBADCFB80, 0xBADDFB80, 0xBADEFB80, 0xBADFFB80, 0xBAE0FB80, 0xBAE1FB80, 0xBAE2FB80, 0xBAE3FB80, 0xBAE4FB80, 0xBAE5FB80, 0xBAE6FB80, 0xBAE7FB80, 0xBAE8FB80, 0xBAE9FB80, 0xBAEAFB80, 0xBAEBFB80, 0xBAECFB80, 0xBAEDFB80, 0xBAEEFB80, 0xBAEFFB80, 0xBAF0FB80, 0xBAF1FB80, 0xBAF2FB80, 0xBAF3FB80, 0xBAF4FB80, 0xBAF5FB80, 0xBAF6FB80, 0xBAF7FB80, 0xBAF8FB80, 0xBAF9FB80, 0xBAFAFB80, 0xBAFBFB80, 0xBAFCFB80, 0xBAFDFB80, 0xBAFEFB80, 0xBAFFFB80, 0xBB00FB80, 0xBB01FB80, 0xBB02FB80, 0xBB03FB80, 0xBB04FB80, 0xBB05FB80, 0xBB06FB80, 0xBB07FB80, 0xBB08FB80, 0xBB09FB80, 0xBB0AFB80, 0xBB0BFB80, 0xBB0CFB80, 0xBB0DFB80, 0xBB0EFB80, 0xBB0FFB80, 0xBB10FB80, 0xBB11FB80, 0xBB12FB80, 0xBB13FB80, 0xBB14FB80, 0xBB15FB80, 0xBB16FB80, 0xBB17FB80, 0xBB18FB80, 0xBB19FB80, 0xBB1AFB80, 0xBB1BFB80, 0xBB1CFB80, 0xBB1DFB80, 0xBB1EFB80, 0xBB1FFB80, 0xBB20FB80, 0xBB21FB80, 0xBB22FB80, 0xBB23FB80, 0xBB24FB80, 0xBB25FB80, 0xBB26FB80, 0xBB27FB80, 0xBB28FB80, 0xBB29FB80, 0xBB2AFB80, 0xBB2BFB80, 0xBB2CFB80, 0xBB2DFB80, 0xBB2EFB80, 0xBB2FFB80, 0xBB30FB80, 0xBB31FB80, 0xBB32FB80, 0xBB33FB80, 0xBB34FB80, 0xBB35FB80, 0xBB36FB80, 0xBB37FB80, 0xBB38FB80, 0xBB39FB80, 0xBB3AFB80, 0xBB3BFB80, 0xBB3CFB80, 0xBB3DFB80, 0xBB3EFB80, 0xBB3FFB80, 0xBB40FB80, 0xBB41FB80, 0xBB42FB80, 0xBB43FB80, 0xBB44FB80, 0xBB45FB80, 0xBB46FB80, 0xBB47FB80, 0xBB48FB80, 0xBB49FB80, 0xBB4AFB80, 0xBB4BFB80, 0xBB4CFB80, 0xBB4DFB80, 0xBB4EFB80, 0xBB4FFB80, 0xBB50FB80, 0xBB51FB80, 0xBB52FB80, 0xBB53FB80, 0xBB54FB80, 0xBB55FB80, 0xBB56FB80, 0xBB57FB80, 0xBB58FB80, 0xBB59FB80, 0xBB5AFB80, 0xBB5BFB80, 0xBB5CFB80, 0xBB5DFB80, 0xBB5EFB80, 0xBB5FFB80, 0xBB60FB80, 0xBB61FB80, 0xBB62FB80, 0xBB63FB80, 0xBB64FB80, 0xBB65FB80, 0xBB66FB80, 0xBB67FB80, 0xBB68FB80, /* 3ABF */
+ 0xBB69FB80, 0xBB6AFB80, 0xBB6BFB80, 0xBB6CFB80, 0xBB6DFB80, 0xBB6EFB80, 0xBB6FFB80, 0xBB70FB80, 0xBB71FB80, 0xBB72FB80, 0xBB73FB80, 0xBB74FB80, 0xBB75FB80, 0xBB76FB80, 0xBB77FB80, 0xBB78FB80, 0xBB79FB80, 0xBB7AFB80, 0xBB7BFB80, 0xBB7CFB80, 0xBB7DFB80, 0xBB7EFB80, 0xBB7FFB80, 0xBB80FB80, 0xBB81FB80, 0xBB82FB80, 0xBB83FB80, 0xBB84FB80, 0xBB85FB80, 0xBB86FB80, 0xBB87FB80, 0xBB88FB80, 0xBB89FB80, 0xBB8AFB80, 0xBB8BFB80, 0xBB8CFB80, 0xBB8DFB80, 0xBB8EFB80, 0xBB8FFB80, 0xBB90FB80, 0xBB91FB80, 0xBB92FB80, 0xBB93FB80, 0xBB94FB80, 0xBB95FB80, 0xBB96FB80, 0xBB97FB80, 0xBB98FB80, 0xBB99FB80, 0xBB9AFB80, 0xBB9BFB80, 0xBB9CFB80, 0xBB9DFB80, 0xBB9EFB80, 0xBB9FFB80, 0xBBA0FB80, 0xBBA1FB80, 0xBBA2FB80, 0xBBA3FB80, 0xBBA4FB80, 0xBBA5FB80, 0xBBA6FB80, 0xBBA7FB80, 0xBBA8FB80, 0xBBA9FB80, 0xBBAAFB80, 0xBBABFB80, 0xBBACFB80, 0xBBADFB80, 0xBBAEFB80, 0xBBAFFB80, 0xBBB0FB80, 0xBBB1FB80, 0xBBB2FB80, 0xBBB3FB80, 0xBBB4FB80, 0xBBB5FB80, 0xBBB6FB80, 0xBBB7FB80, 0xBBB8FB80, 0xBBB9FB80, 0xBBBAFB80, 0xBBBBFB80, 0xBBBCFB80, 0xBBBDFB80, 0xBBBEFB80, 0xBBBFFB80, 0xBBC0FB80, 0xBBC1FB80, 0xBBC2FB80, 0xBBC3FB80, 0xBBC4FB80, 0xBBC5FB80, 0xBBC6FB80, 0xBBC7FB80, 0xBBC8FB80, 0xBBC9FB80, 0xBBCAFB80, 0xBBCBFB80, 0xBBCCFB80, 0xBBCDFB80, 0xBBCEFB80, 0xBBCFFB80, 0xBBD0FB80, 0xBBD1FB80, 0xBBD2FB80, 0xBBD3FB80, 0xBBD4FB80, 0xBBD5FB80, 0xBBD6FB80, 0xBBD7FB80, 0xBBD8FB80, 0xBBD9FB80, 0xBBDAFB80, 0xBBDBFB80, 0xBBDCFB80, 0xBBDDFB80, 0xBBDEFB80, 0xBBDFFB80, 0xBBE0FB80, 0xBBE1FB80, 0xBBE2FB80, 0xBBE3FB80, 0xBBE4FB80, 0xBBE5FB80, 0xBBE6FB80, 0xBBE7FB80, 0xBBE8FB80, 0xBBE9FB80, 0xBBEAFB80, 0xBBEBFB80, 0xBBECFB80, 0xBBEDFB80, 0xBBEEFB80, 0xBBEFFB80, 0xBBF0FB80, 0xBBF1FB80, 0xBBF2FB80, 0xBBF3FB80, 0xBBF4FB80, 0xBBF5FB80, 0xBBF6FB80, 0xBBF7FB80, 0xBBF8FB80, 0xBBF9FB80, 0xBBFAFB80, 0xBBFBFB80, 0xBBFCFB80, 0xBBFDFB80, 0xBBFEFB80, 0xBBFFFB80, 0xBC00FB80, 0xBC01FB80, 0xBC02FB80, 0xBC03FB80, 0xBC04FB80, 0xBC05FB80, 0xBC06FB80, 0xBC07FB80, 0xBC08FB80, 0xBC09FB80, 0xBC0AFB80, 0xBC0BFB80, 0xBC0CFB80, 0xBC0DFB80, 0xBC0EFB80, 0xBC0FFB80, 0xBC10FB80, 0xBC11FB80, 0xBC12FB80, /* 3B69 */
+ 0xBC13FB80, 0xBC14FB80, 0xBC15FB80, 0xBC16FB80, 0xBC17FB80, 0xBC18FB80, 0xBC19FB80, 0xBC1AFB80, 0xBC1BFB80, 0xBC1CFB80, 0xBC1DFB80, 0xBC1EFB80, 0xBC1FFB80, 0xBC20FB80, 0xBC21FB80, 0xBC22FB80, 0xBC23FB80, 0xBC24FB80, 0xBC25FB80, 0xBC26FB80, 0xBC27FB80, 0xBC28FB80, 0xBC29FB80, 0xBC2AFB80, 0xBC2BFB80, 0xBC2CFB80, 0xBC2DFB80, 0xBC2EFB80, 0xBC2FFB80, 0xBC30FB80, 0xBC31FB80, 0xBC32FB80, 0xBC33FB80, 0xBC34FB80, 0xBC35FB80, 0xBC36FB80, 0xBC37FB80, 0xBC38FB80, 0xBC39FB80, 0xBC3AFB80, 0xBC3BFB80, 0xBC3CFB80, 0xBC3DFB80, 0xBC3EFB80, 0xBC3FFB80, 0xBC40FB80, 0xBC41FB80, 0xBC42FB80, 0xBC43FB80, 0xBC44FB80, 0xBC45FB80, 0xBC46FB80, 0xBC47FB80, 0xBC48FB80, 0xBC49FB80, 0xBC4AFB80, 0xBC4BFB80, 0xBC4CFB80, 0xBC4DFB80, 0xBC4EFB80, 0xBC4FFB80, 0xBC50FB80, 0xBC51FB80, 0xBC52FB80, 0xBC53FB80, 0xBC54FB80, 0xBC55FB80, 0xBC56FB80, 0xBC57FB80, 0xBC58FB80, 0xBC59FB80, 0xBC5AFB80, 0xBC5BFB80, 0xBC5CFB80, 0xBC5DFB80, 0xBC5EFB80, 0xBC5FFB80, 0xBC60FB80, 0xBC61FB80, 0xBC62FB80, 0xBC63FB80, 0xBC64FB80, 0xBC65FB80, 0xBC66FB80, 0xBC67FB80, 0xBC68FB80, 0xBC69FB80, 0xBC6AFB80, 0xBC6BFB80, 0xBC6CFB80, 0xBC6DFB80, 0xBC6EFB80, 0xBC6FFB80, 0xBC70FB80, 0xBC71FB80, 0xBC72FB80, 0xBC73FB80, 0xBC74FB80, 0xBC75FB80, 0xBC76FB80, 0xBC77FB80, 0xBC78FB80, 0xBC79FB80, 0xBC7AFB80, 0xBC7BFB80, 0xBC7CFB80, 0xBC7DFB80, 0xBC7EFB80, 0xBC7FFB80, 0xBC80FB80, 0xBC81FB80, 0xBC82FB80, 0xBC83FB80, 0xBC84FB80, 0xBC85FB80, 0xBC86FB80, 0xBC87FB80, 0xBC88FB80, 0xBC89FB80, 0xBC8AFB80, 0xBC8BFB80, 0xBC8CFB80, 0xBC8DFB80, 0xBC8EFB80, 0xBC8FFB80, 0xBC90FB80, 0xBC91FB80, 0xBC92FB80, 0xBC93FB80, 0xBC94FB80, 0xBC95FB80, 0xBC96FB80, 0xBC97FB80, 0xBC98FB80, 0xBC99FB80, 0xBC9AFB80, 0xBC9BFB80, 0xBC9CFB80, 0xBC9DFB80, 0xBC9EFB80, 0xBC9FFB80, 0xBCA0FB80, 0xBCA1FB80, 0xBCA2FB80, 0xBCA3FB80, 0xBCA4FB80, 0xBCA5FB80, 0xBCA6FB80, 0xBCA7FB80, 0xBCA8FB80, 0xBCA9FB80, 0xBCAAFB80, 0xBCABFB80, 0xBCACFB80, 0xBCADFB80, 0xBCAEFB80, 0xBCAFFB80, 0xBCB0FB80, 0xBCB1FB80, 0xBCB2FB80, 0xBCB3FB80, 0xBCB4FB80, 0xBCB5FB80, 0xBCB6FB80, 0xBCB7FB80, 0xBCB8FB80, 0xBCB9FB80, 0xBCBAFB80, 0xBCBBFB80, 0xBCBCFB80, /* 3C13 */
+ 0xBCBDFB80, 0xBCBEFB80, 0xBCBFFB80, 0xBCC0FB80, 0xBCC1FB80, 0xBCC2FB80, 0xBCC3FB80, 0xBCC4FB80, 0xBCC5FB80, 0xBCC6FB80, 0xBCC7FB80, 0xBCC8FB80, 0xBCC9FB80, 0xBCCAFB80, 0xBCCBFB80, 0xBCCCFB80, 0xBCCDFB80, 0xBCCEFB80, 0xBCCFFB80, 0xBCD0FB80, 0xBCD1FB80, 0xBCD2FB80, 0xBCD3FB80, 0xBCD4FB80, 0xBCD5FB80, 0xBCD6FB80, 0xBCD7FB80, 0xBCD8FB80, 0xBCD9FB80, 0xBCDAFB80, 0xBCDBFB80, 0xBCDCFB80, 0xBCDDFB80, 0xBCDEFB80, 0xBCDFFB80, 0xBCE0FB80, 0xBCE1FB80, 0xBCE2FB80, 0xBCE3FB80, 0xBCE4FB80, 0xBCE5FB80, 0xBCE6FB80, 0xBCE7FB80, 0xBCE8FB80, 0xBCE9FB80, 0xBCEAFB80, 0xBCEBFB80, 0xBCECFB80, 0xBCEDFB80, 0xBCEEFB80, 0xBCEFFB80, 0xBCF0FB80, 0xBCF1FB80, 0xBCF2FB80, 0xBCF3FB80, 0xBCF4FB80, 0xBCF5FB80, 0xBCF6FB80, 0xBCF7FB80, 0xBCF8FB80, 0xBCF9FB80, 0xBCFAFB80, 0xBCFBFB80, 0xBCFCFB80, 0xBCFDFB80, 0xBCFEFB80, 0xBCFFFB80, 0xBD00FB80, 0xBD01FB80, 0xBD02FB80, 0xBD03FB80, 0xBD04FB80, 0xBD05FB80, 0xBD06FB80, 0xBD07FB80, 0xBD08FB80, 0xBD09FB80, 0xBD0AFB80, 0xBD0BFB80, 0xBD0CFB80, 0xBD0DFB80, 0xBD0EFB80, 0xBD0FFB80, 0xBD10FB80, 0xBD11FB80, 0xBD12FB80, 0xBD13FB80, 0xBD14FB80, 0xBD15FB80, 0xBD16FB80, 0xBD17FB80, 0xBD18FB80, 0xBD19FB80, 0xBD1AFB80, 0xBD1BFB80, 0xBD1CFB80, 0xBD1DFB80, 0xBD1EFB80, 0xBD1FFB80, 0xBD20FB80, 0xBD21FB80, 0xBD22FB80, 0xBD23FB80, 0xBD24FB80, 0xBD25FB80, 0xBD26FB80, 0xBD27FB80, 0xBD28FB80, 0xBD29FB80, 0xBD2AFB80, 0xBD2BFB80, 0xBD2CFB80, 0xBD2DFB80, 0xBD2EFB80, 0xBD2FFB80, 0xBD30FB80, 0xBD31FB80, 0xBD32FB80, 0xBD33FB80, 0xBD34FB80, 0xBD35FB80, 0xBD36FB80, 0xBD37FB80, 0xBD38FB80, 0xBD39FB80, 0xBD3AFB80, 0xBD3BFB80, 0xBD3CFB80, 0xBD3DFB80, 0xBD3EFB80, 0xBD3FFB80, 0xBD40FB80, 0xBD41FB80, 0xBD42FB80, 0xBD43FB80, 0xBD44FB80, 0xBD45FB80, 0xBD46FB80, 0xBD47FB80, 0xBD48FB80, 0xBD49FB80, 0xBD4AFB80, 0xBD4BFB80, 0xBD4CFB80, 0xBD4DFB80, 0xBD4EFB80, 0xBD4FFB80, 0xBD50FB80, 0xBD51FB80, 0xBD52FB80, 0xBD53FB80, 0xBD54FB80, 0xBD55FB80, 0xBD56FB80, 0xBD57FB80, 0xBD58FB80, 0xBD59FB80, 0xBD5AFB80, 0xBD5BFB80, 0xBD5CFB80, 0xBD5DFB80, 0xBD5EFB80, 0xBD5FFB80, 0xBD60FB80, 0xBD61FB80, 0xBD62FB80, 0xBD63FB80, 0xBD64FB80, 0xBD65FB80, 0xBD66FB80, /* 3CBD */
+ 0xBD67FB80, 0xBD68FB80, 0xBD69FB80, 0xBD6AFB80, 0xBD6BFB80, 0xBD6CFB80, 0xBD6DFB80, 0xBD6EFB80, 0xBD6FFB80, 0xBD70FB80, 0xBD71FB80, 0xBD72FB80, 0xBD73FB80, 0xBD74FB80, 0xBD75FB80, 0xBD76FB80, 0xBD77FB80, 0xBD78FB80, 0xBD79FB80, 0xBD7AFB80, 0xBD7BFB80, 0xBD7CFB80, 0xBD7DFB80, 0xBD7EFB80, 0xBD7FFB80, 0xBD80FB80, 0xBD81FB80, 0xBD82FB80, 0xBD83FB80, 0xBD84FB80, 0xBD85FB80, 0xBD86FB80, 0xBD87FB80, 0xBD88FB80, 0xBD89FB80, 0xBD8AFB80, 0xBD8BFB80, 0xBD8CFB80, 0xBD8DFB80, 0xBD8EFB80, 0xBD8FFB80, 0xBD90FB80, 0xBD91FB80, 0xBD92FB80, 0xBD93FB80, 0xBD94FB80, 0xBD95FB80, 0xBD96FB80, 0xBD97FB80, 0xBD98FB80, 0xBD99FB80, 0xBD9AFB80, 0xBD9BFB80, 0xBD9CFB80, 0xBD9DFB80, 0xBD9EFB80, 0xBD9FFB80, 0xBDA0FB80, 0xBDA1FB80, 0xBDA2FB80, 0xBDA3FB80, 0xBDA4FB80, 0xBDA5FB80, 0xBDA6FB80, 0xBDA7FB80, 0xBDA8FB80, 0xBDA9FB80, 0xBDAAFB80, 0xBDABFB80, 0xBDACFB80, 0xBDADFB80, 0xBDAEFB80, 0xBDAFFB80, 0xBDB0FB80, 0xBDB1FB80, 0xBDB2FB80, 0xBDB3FB80, 0xBDB4FB80, 0xBDB5FB80, 0xBDB6FB80, 0xBDB7FB80, 0xBDB8FB80, 0xBDB9FB80, 0xBDBAFB80, 0xBDBBFB80, 0xBDBCFB80, 0xBDBDFB80, 0xBDBEFB80, 0xBDBFFB80, 0xBDC0FB80, 0xBDC1FB80, 0xBDC2FB80, 0xBDC3FB80, 0xBDC4FB80, 0xBDC5FB80, 0xBDC6FB80, 0xBDC7FB80, 0xBDC8FB80, 0xBDC9FB80, 0xBDCAFB80, 0xBDCBFB80, 0xBDCCFB80, 0xBDCDFB80, 0xBDCEFB80, 0xBDCFFB80, 0xBDD0FB80, 0xBDD1FB80, 0xBDD2FB80, 0xBDD3FB80, 0xBDD4FB80, 0xBDD5FB80, 0xBDD6FB80, 0xBDD7FB80, 0xBDD8FB80, 0xBDD9FB80, 0xBDDAFB80, 0xBDDBFB80, 0xBDDCFB80, 0xBDDDFB80, 0xBDDEFB80, 0xBDDFFB80, 0xBDE0FB80, 0xBDE1FB80, 0xBDE2FB80, 0xBDE3FB80, 0xBDE4FB80, 0xBDE5FB80, 0xBDE6FB80, 0xBDE7FB80, 0xBDE8FB80, 0xBDE9FB80, 0xBDEAFB80, 0xBDEBFB80, 0xBDECFB80, 0xBDEDFB80, 0xBDEEFB80, 0xBDEFFB80, 0xBDF0FB80, 0xBDF1FB80, 0xBDF2FB80, 0xBDF3FB80, 0xBDF4FB80, 0xBDF5FB80, 0xBDF6FB80, 0xBDF7FB80, 0xBDF8FB80, 0xBDF9FB80, 0xBDFAFB80, 0xBDFBFB80, 0xBDFCFB80, 0xBDFDFB80, 0xBDFEFB80, 0xBDFFFB80, 0xBE00FB80, 0xBE01FB80, 0xBE02FB80, 0xBE03FB80, 0xBE04FB80, 0xBE05FB80, 0xBE06FB80, 0xBE07FB80, 0xBE08FB80, 0xBE09FB80, 0xBE0AFB80, 0xBE0BFB80, 0xBE0CFB80, 0xBE0DFB80, 0xBE0EFB80, 0xBE0FFB80, 0xBE10FB80, /* 3D67 */
+ 0xBE11FB80, 0xBE12FB80, 0xBE13FB80, 0xBE14FB80, 0xBE15FB80, 0xBE16FB80, 0xBE17FB80, 0xBE18FB80, 0xBE19FB80, 0xBE1AFB80, 0xBE1BFB80, 0xBE1CFB80, 0xBE1DFB80, 0xBE1EFB80, 0xBE1FFB80, 0xBE20FB80, 0xBE21FB80, 0xBE22FB80, 0xBE23FB80, 0xBE24FB80, 0xBE25FB80, 0xBE26FB80, 0xBE27FB80, 0xBE28FB80, 0xBE29FB80, 0xBE2AFB80, 0xBE2BFB80, 0xBE2CFB80, 0xBE2DFB80, 0xBE2EFB80, 0xBE2FFB80, 0xBE30FB80, 0xBE31FB80, 0xBE32FB80, 0xBE33FB80, 0xBE34FB80, 0xBE35FB80, 0xBE36FB80, 0xBE37FB80, 0xBE38FB80, 0xBE39FB80, 0xBE3AFB80, 0xBE3BFB80, 0xBE3CFB80, 0xBE3DFB80, 0xBE3EFB80, 0xBE3FFB80, 0xBE40FB80, 0xBE41FB80, 0xBE42FB80, 0xBE43FB80, 0xBE44FB80, 0xBE45FB80, 0xBE46FB80, 0xBE47FB80, 0xBE48FB80, 0xBE49FB80, 0xBE4AFB80, 0xBE4BFB80, 0xBE4CFB80, 0xBE4DFB80, 0xBE4EFB80, 0xBE4FFB80, 0xBE50FB80, 0xBE51FB80, 0xBE52FB80, 0xBE53FB80, 0xBE54FB80, 0xBE55FB80, 0xBE56FB80, 0xBE57FB80, 0xBE58FB80, 0xBE59FB80, 0xBE5AFB80, 0xBE5BFB80, 0xBE5CFB80, 0xBE5DFB80, 0xBE5EFB80, 0xBE5FFB80, 0xBE60FB80, 0xBE61FB80, 0xBE62FB80, 0xBE63FB80, 0xBE64FB80, 0xBE65FB80, 0xBE66FB80, 0xBE67FB80, 0xBE68FB80, 0xBE69FB80, 0xBE6AFB80, 0xBE6BFB80, 0xBE6CFB80, 0xBE6DFB80, 0xBE6EFB80, 0xBE6FFB80, 0xBE70FB80, 0xBE71FB80, 0xBE72FB80, 0xBE73FB80, 0xBE74FB80, 0xBE75FB80, 0xBE76FB80, 0xBE77FB80, 0xBE78FB80, 0xBE79FB80, 0xBE7AFB80, 0xBE7BFB80, 0xBE7CFB80, 0xBE7DFB80, 0xBE7EFB80, 0xBE7FFB80, 0xBE80FB80, 0xBE81FB80, 0xBE82FB80, 0xBE83FB80, 0xBE84FB80, 0xBE85FB80, 0xBE86FB80, 0xBE87FB80, 0xBE88FB80, 0xBE89FB80, 0xBE8AFB80, 0xBE8BFB80, 0xBE8CFB80, 0xBE8DFB80, 0xBE8EFB80, 0xBE8FFB80, 0xBE90FB80, 0xBE91FB80, 0xBE92FB80, 0xBE93FB80, 0xBE94FB80, 0xBE95FB80, 0xBE96FB80, 0xBE97FB80, 0xBE98FB80, 0xBE99FB80, 0xBE9AFB80, 0xBE9BFB80, 0xBE9CFB80, 0xBE9DFB80, 0xBE9EFB80, 0xBE9FFB80, 0xBEA0FB80, 0xBEA1FB80, 0xBEA2FB80, 0xBEA3FB80, 0xBEA4FB80, 0xBEA5FB80, 0xBEA6FB80, 0xBEA7FB80, 0xBEA8FB80, 0xBEA9FB80, 0xBEAAFB80, 0xBEABFB80, 0xBEACFB80, 0xBEADFB80, 0xBEAEFB80, 0xBEAFFB80, 0xBEB0FB80, 0xBEB1FB80, 0xBEB2FB80, 0xBEB3FB80, 0xBEB4FB80, 0xBEB5FB80, 0xBEB6FB80, 0xBEB7FB80, 0xBEB8FB80, 0xBEB9FB80, 0xBEBAFB80, /* 3E11 */
+ 0xBEBBFB80, 0xBEBCFB80, 0xBEBDFB80, 0xBEBEFB80, 0xBEBFFB80, 0xBEC0FB80, 0xBEC1FB80, 0xBEC2FB80, 0xBEC3FB80, 0xBEC4FB80, 0xBEC5FB80, 0xBEC6FB80, 0xBEC7FB80, 0xBEC8FB80, 0xBEC9FB80, 0xBECAFB80, 0xBECBFB80, 0xBECCFB80, 0xBECDFB80, 0xBECEFB80, 0xBECFFB80, 0xBED0FB80, 0xBED1FB80, 0xBED2FB80, 0xBED3FB80, 0xBED4FB80, 0xBED5FB80, 0xBED6FB80, 0xBED7FB80, 0xBED8FB80, 0xBED9FB80, 0xBEDAFB80, 0xBEDBFB80, 0xBEDCFB80, 0xBEDDFB80, 0xBEDEFB80, 0xBEDFFB80, 0xBEE0FB80, 0xBEE1FB80, 0xBEE2FB80, 0xBEE3FB80, 0xBEE4FB80, 0xBEE5FB80, 0xBEE6FB80, 0xBEE7FB80, 0xBEE8FB80, 0xBEE9FB80, 0xBEEAFB80, 0xBEEBFB80, 0xBEECFB80, 0xBEEDFB80, 0xBEEEFB80, 0xBEEFFB80, 0xBEF0FB80, 0xBEF1FB80, 0xBEF2FB80, 0xBEF3FB80, 0xBEF4FB80, 0xBEF5FB80, 0xBEF6FB80, 0xBEF7FB80, 0xBEF8FB80, 0xBEF9FB80, 0xBEFAFB80, 0xBEFBFB80, 0xBEFCFB80, 0xBEFDFB80, 0xBEFEFB80, 0xBEFFFB80, 0xBF00FB80, 0xBF01FB80, 0xBF02FB80, 0xBF03FB80, 0xBF04FB80, 0xBF05FB80, 0xBF06FB80, 0xBF07FB80, 0xBF08FB80, 0xBF09FB80, 0xBF0AFB80, 0xBF0BFB80, 0xBF0CFB80, 0xBF0DFB80, 0xBF0EFB80, 0xBF0FFB80, 0xBF10FB80, 0xBF11FB80, 0xBF12FB80, 0xBF13FB80, 0xBF14FB80, 0xBF15FB80, 0xBF16FB80, 0xBF17FB80, 0xBF18FB80, 0xBF19FB80, 0xBF1AFB80, 0xBF1BFB80, 0xBF1CFB80, 0xBF1DFB80, 0xBF1EFB80, 0xBF1FFB80, 0xBF20FB80, 0xBF21FB80, 0xBF22FB80, 0xBF23FB80, 0xBF24FB80, 0xBF25FB80, 0xBF26FB80, 0xBF27FB80, 0xBF28FB80, 0xBF29FB80, 0xBF2AFB80, 0xBF2BFB80, 0xBF2CFB80, 0xBF2DFB80, 0xBF2EFB80, 0xBF2FFB80, 0xBF30FB80, 0xBF31FB80, 0xBF32FB80, 0xBF33FB80, 0xBF34FB80, 0xBF35FB80, 0xBF36FB80, 0xBF37FB80, 0xBF38FB80, 0xBF39FB80, 0xBF3AFB80, 0xBF3BFB80, 0xBF3CFB80, 0xBF3DFB80, 0xBF3EFB80, 0xBF3FFB80, 0xBF40FB80, 0xBF41FB80, 0xBF42FB80, 0xBF43FB80, 0xBF44FB80, 0xBF45FB80, 0xBF46FB80, 0xBF47FB80, 0xBF48FB80, 0xBF49FB80, 0xBF4AFB80, 0xBF4BFB80, 0xBF4CFB80, 0xBF4DFB80, 0xBF4EFB80, 0xBF4FFB80, 0xBF50FB80, 0xBF51FB80, 0xBF52FB80, 0xBF53FB80, 0xBF54FB80, 0xBF55FB80, 0xBF56FB80, 0xBF57FB80, 0xBF58FB80, 0xBF59FB80, 0xBF5AFB80, 0xBF5BFB80, 0xBF5CFB80, 0xBF5DFB80, 0xBF5EFB80, 0xBF5FFB80, 0xBF60FB80, 0xBF61FB80, 0xBF62FB80, 0xBF63FB80, 0xBF64FB80, /* 3EBB */
+ 0xBF65FB80, 0xBF66FB80, 0xBF67FB80, 0xBF68FB80, 0xBF69FB80, 0xBF6AFB80, 0xBF6BFB80, 0xBF6CFB80, 0xBF6DFB80, 0xBF6EFB80, 0xBF6FFB80, 0xBF70FB80, 0xBF71FB80, 0xBF72FB80, 0xBF73FB80, 0xBF74FB80, 0xBF75FB80, 0xBF76FB80, 0xBF77FB80, 0xBF78FB80, 0xBF79FB80, 0xBF7AFB80, 0xBF7BFB80, 0xBF7CFB80, 0xBF7DFB80, 0xBF7EFB80, 0xBF7FFB80, 0xBF80FB80, 0xBF81FB80, 0xBF82FB80, 0xBF83FB80, 0xBF84FB80, 0xBF85FB80, 0xBF86FB80, 0xBF87FB80, 0xBF88FB80, 0xBF89FB80, 0xBF8AFB80, 0xBF8BFB80, 0xBF8CFB80, 0xBF8DFB80, 0xBF8EFB80, 0xBF8FFB80, 0xBF90FB80, 0xBF91FB80, 0xBF92FB80, 0xBF93FB80, 0xBF94FB80, 0xBF95FB80, 0xBF96FB80, 0xBF97FB80, 0xBF98FB80, 0xBF99FB80, 0xBF9AFB80, 0xBF9BFB80, 0xBF9CFB80, 0xBF9DFB80, 0xBF9EFB80, 0xBF9FFB80, 0xBFA0FB80, 0xBFA1FB80, 0xBFA2FB80, 0xBFA3FB80, 0xBFA4FB80, 0xBFA5FB80, 0xBFA6FB80, 0xBFA7FB80, 0xBFA8FB80, 0xBFA9FB80, 0xBFAAFB80, 0xBFABFB80, 0xBFACFB80, 0xBFADFB80, 0xBFAEFB80, 0xBFAFFB80, 0xBFB0FB80, 0xBFB1FB80, 0xBFB2FB80, 0xBFB3FB80, 0xBFB4FB80, 0xBFB5FB80, 0xBFB6FB80, 0xBFB7FB80, 0xBFB8FB80, 0xBFB9FB80, 0xBFBAFB80, 0xBFBBFB80, 0xBFBCFB80, 0xBFBDFB80, 0xBFBEFB80, 0xBFBFFB80, 0xBFC0FB80, 0xBFC1FB80, 0xBFC2FB80, 0xBFC3FB80, 0xBFC4FB80, 0xBFC5FB80, 0xBFC6FB80, 0xBFC7FB80, 0xBFC8FB80, 0xBFC9FB80, 0xBFCAFB80, 0xBFCBFB80, 0xBFCCFB80, 0xBFCDFB80, 0xBFCEFB80, 0xBFCFFB80, 0xBFD0FB80, 0xBFD1FB80, 0xBFD2FB80, 0xBFD3FB80, 0xBFD4FB80, 0xBFD5FB80, 0xBFD6FB80, 0xBFD7FB80, 0xBFD8FB80, 0xBFD9FB80, 0xBFDAFB80, 0xBFDBFB80, 0xBFDCFB80, 0xBFDDFB80, 0xBFDEFB80, 0xBFDFFB80, 0xBFE0FB80, 0xBFE1FB80, 0xBFE2FB80, 0xBFE3FB80, 0xBFE4FB80, 0xBFE5FB80, 0xBFE6FB80, 0xBFE7FB80, 0xBFE8FB80, 0xBFE9FB80, 0xBFEAFB80, 0xBFEBFB80, 0xBFECFB80, 0xBFEDFB80, 0xBFEEFB80, 0xBFEFFB80, 0xBFF0FB80, 0xBFF1FB80, 0xBFF2FB80, 0xBFF3FB80, 0xBFF4FB80, 0xBFF5FB80, 0xBFF6FB80, 0xBFF7FB80, 0xBFF8FB80, 0xBFF9FB80, 0xBFFAFB80, 0xBFFBFB80, 0xBFFCFB80, 0xBFFDFB80, 0xBFFEFB80, 0xBFFFFB80, 0xC000FB80, 0xC001FB80, 0xC002FB80, 0xC003FB80, 0xC004FB80, 0xC005FB80, 0xC006FB80, 0xC007FB80, 0xC008FB80, 0xC009FB80, 0xC00AFB80, 0xC00BFB80, 0xC00CFB80, 0xC00DFB80, 0xC00EFB80, /* 3F65 */
+ 0xC00FFB80, 0xC010FB80, 0xC011FB80, 0xC012FB80, 0xC013FB80, 0xC014FB80, 0xC015FB80, 0xC016FB80, 0xC017FB80, 0xC018FB80, 0xC019FB80, 0xC01AFB80, 0xC01BFB80, 0xC01CFB80, 0xC01DFB80, 0xC01EFB80, 0xC01FFB80, 0xC020FB80, 0xC021FB80, 0xC022FB80, 0xC023FB80, 0xC024FB80, 0xC025FB80, 0xC026FB80, 0xC027FB80, 0xC028FB80, 0xC029FB80, 0xC02AFB80, 0xC02BFB80, 0xC02CFB80, 0xC02DFB80, 0xC02EFB80, 0xC02FFB80, 0xC030FB80, 0xC031FB80, 0xC032FB80, 0xC033FB80, 0xC034FB80, 0xC035FB80, 0xC036FB80, 0xC037FB80, 0xC038FB80, 0xC039FB80, 0xC03AFB80, 0xC03BFB80, 0xC03CFB80, 0xC03DFB80, 0xC03EFB80, 0xC03FFB80, 0xC040FB80, 0xC041FB80, 0xC042FB80, 0xC043FB80, 0xC044FB80, 0xC045FB80, 0xC046FB80, 0xC047FB80, 0xC048FB80, 0xC049FB80, 0xC04AFB80, 0xC04BFB80, 0xC04CFB80, 0xC04DFB80, 0xC04EFB80, 0xC04FFB80, 0xC050FB80, 0xC051FB80, 0xC052FB80, 0xC053FB80, 0xC054FB80, 0xC055FB80, 0xC056FB80, 0xC057FB80, 0xC058FB80, 0xC059FB80, 0xC05AFB80, 0xC05BFB80, 0xC05CFB80, 0xC05DFB80, 0xC05EFB80, 0xC05FFB80, 0xC060FB80, 0xC061FB80, 0xC062FB80, 0xC063FB80, 0xC064FB80, 0xC065FB80, 0xC066FB80, 0xC067FB80, 0xC068FB80, 0xC069FB80, 0xC06AFB80, 0xC06BFB80, 0xC06CFB80, 0xC06DFB80, 0xC06EFB80, 0xC06FFB80, 0xC070FB80, 0xC071FB80, 0xC072FB80, 0xC073FB80, 0xC074FB80, 0xC075FB80, 0xC076FB80, 0xC077FB80, 0xC078FB80, 0xC079FB80, 0xC07AFB80, 0xC07BFB80, 0xC07CFB80, 0xC07DFB80, 0xC07EFB80, 0xC07FFB80, 0xC080FB80, 0xC081FB80, 0xC082FB80, 0xC083FB80, 0xC084FB80, 0xC085FB80, 0xC086FB80, 0xC087FB80, 0xC088FB80, 0xC089FB80, 0xC08AFB80, 0xC08BFB80, 0xC08CFB80, 0xC08DFB80, 0xC08EFB80, 0xC08FFB80, 0xC090FB80, 0xC091FB80, 0xC092FB80, 0xC093FB80, 0xC094FB80, 0xC095FB80, 0xC096FB80, 0xC097FB80, 0xC098FB80, 0xC099FB80, 0xC09AFB80, 0xC09BFB80, 0xC09CFB80, 0xC09DFB80, 0xC09EFB80, 0xC09FFB80, 0xC0A0FB80, 0xC0A1FB80, 0xC0A2FB80, 0xC0A3FB80, 0xC0A4FB80, 0xC0A5FB80, 0xC0A6FB80, 0xC0A7FB80, 0xC0A8FB80, 0xC0A9FB80, 0xC0AAFB80, 0xC0ABFB80, 0xC0ACFB80, 0xC0ADFB80, 0xC0AEFB80, 0xC0AFFB80, 0xC0B0FB80, 0xC0B1FB80, 0xC0B2FB80, 0xC0B3FB80, 0xC0B4FB80, 0xC0B5FB80, 0xC0B6FB80, 0xC0B7FB80, 0xC0B8FB80, /* 400F */
+ 0xC0B9FB80, 0xC0BAFB80, 0xC0BBFB80, 0xC0BCFB80, 0xC0BDFB80, 0xC0BEFB80, 0xC0BFFB80, 0xC0C0FB80, 0xC0C1FB80, 0xC0C2FB80, 0xC0C3FB80, 0xC0C4FB80, 0xC0C5FB80, 0xC0C6FB80, 0xC0C7FB80, 0xC0C8FB80, 0xC0C9FB80, 0xC0CAFB80, 0xC0CBFB80, 0xC0CCFB80, 0xC0CDFB80, 0xC0CEFB80, 0xC0CFFB80, 0xC0D0FB80, 0xC0D1FB80, 0xC0D2FB80, 0xC0D3FB80, 0xC0D4FB80, 0xC0D5FB80, 0xC0D6FB80, 0xC0D7FB80, 0xC0D8FB80, 0xC0D9FB80, 0xC0DAFB80, 0xC0DBFB80, 0xC0DCFB80, 0xC0DDFB80, 0xC0DEFB80, 0xC0DFFB80, 0xC0E0FB80, 0xC0E1FB80, 0xC0E2FB80, 0xC0E3FB80, 0xC0E4FB80, 0xC0E5FB80, 0xC0E6FB80, 0xC0E7FB80, 0xC0E8FB80, 0xC0E9FB80, 0xC0EAFB80, 0xC0EBFB80, 0xC0ECFB80, 0xC0EDFB80, 0xC0EEFB80, 0xC0EFFB80, 0xC0F0FB80, 0xC0F1FB80, 0xC0F2FB80, 0xC0F3FB80, 0xC0F4FB80, 0xC0F5FB80, 0xC0F6FB80, 0xC0F7FB80, 0xC0F8FB80, 0xC0F9FB80, 0xC0FAFB80, 0xC0FBFB80, 0xC0FCFB80, 0xC0FDFB80, 0xC0FEFB80, 0xC0FFFB80, 0xC100FB80, 0xC101FB80, 0xC102FB80, 0xC103FB80, 0xC104FB80, 0xC105FB80, 0xC106FB80, 0xC107FB80, 0xC108FB80, 0xC109FB80, 0xC10AFB80, 0xC10BFB80, 0xC10CFB80, 0xC10DFB80, 0xC10EFB80, 0xC10FFB80, 0xC110FB80, 0xC111FB80, 0xC112FB80, 0xC113FB80, 0xC114FB80, 0xC115FB80, 0xC116FB80, 0xC117FB80, 0xC118FB80, 0xC119FB80, 0xC11AFB80, 0xC11BFB80, 0xC11CFB80, 0xC11DFB80, 0xC11EFB80, 0xC11FFB80, 0xC120FB80, 0xC121FB80, 0xC122FB80, 0xC123FB80, 0xC124FB80, 0xC125FB80, 0xC126FB80, 0xC127FB80, 0xC128FB80, 0xC129FB80, 0xC12AFB80, 0xC12BFB80, 0xC12CFB80, 0xC12DFB80, 0xC12EFB80, 0xC12FFB80, 0xC130FB80, 0xC131FB80, 0xC132FB80, 0xC133FB80, 0xC134FB80, 0xC135FB80, 0xC136FB80, 0xC137FB80, 0xC138FB80, 0xC139FB80, 0xC13AFB80, 0xC13BFB80, 0xC13CFB80, 0xC13DFB80, 0xC13EFB80, 0xC13FFB80, 0xC140FB80, 0xC141FB80, 0xC142FB80, 0xC143FB80, 0xC144FB80, 0xC145FB80, 0xC146FB80, 0xC147FB80, 0xC148FB80, 0xC149FB80, 0xC14AFB80, 0xC14BFB80, 0xC14CFB80, 0xC14DFB80, 0xC14EFB80, 0xC14FFB80, 0xC150FB80, 0xC151FB80, 0xC152FB80, 0xC153FB80, 0xC154FB80, 0xC155FB80, 0xC156FB80, 0xC157FB80, 0xC158FB80, 0xC159FB80, 0xC15AFB80, 0xC15BFB80, 0xC15CFB80, 0xC15DFB80, 0xC15EFB80, 0xC15FFB80, 0xC160FB80, 0xC161FB80, 0xC162FB80, /* 40B9 */
+ 0xC163FB80, 0xC164FB80, 0xC165FB80, 0xC166FB80, 0xC167FB80, 0xC168FB80, 0xC169FB80, 0xC16AFB80, 0xC16BFB80, 0xC16CFB80, 0xC16DFB80, 0xC16EFB80, 0xC16FFB80, 0xC170FB80, 0xC171FB80, 0xC172FB80, 0xC173FB80, 0xC174FB80, 0xC175FB80, 0xC176FB80, 0xC177FB80, 0xC178FB80, 0xC179FB80, 0xC17AFB80, 0xC17BFB80, 0xC17CFB80, 0xC17DFB80, 0xC17EFB80, 0xC17FFB80, 0xC180FB80, 0xC181FB80, 0xC182FB80, 0xC183FB80, 0xC184FB80, 0xC185FB80, 0xC186FB80, 0xC187FB80, 0xC188FB80, 0xC189FB80, 0xC18AFB80, 0xC18BFB80, 0xC18CFB80, 0xC18DFB80, 0xC18EFB80, 0xC18FFB80, 0xC190FB80, 0xC191FB80, 0xC192FB80, 0xC193FB80, 0xC194FB80, 0xC195FB80, 0xC196FB80, 0xC197FB80, 0xC198FB80, 0xC199FB80, 0xC19AFB80, 0xC19BFB80, 0xC19CFB80, 0xC19DFB80, 0xC19EFB80, 0xC19FFB80, 0xC1A0FB80, 0xC1A1FB80, 0xC1A2FB80, 0xC1A3FB80, 0xC1A4FB80, 0xC1A5FB80, 0xC1A6FB80, 0xC1A7FB80, 0xC1A8FB80, 0xC1A9FB80, 0xC1AAFB80, 0xC1ABFB80, 0xC1ACFB80, 0xC1ADFB80, 0xC1AEFB80, 0xC1AFFB80, 0xC1B0FB80, 0xC1B1FB80, 0xC1B2FB80, 0xC1B3FB80, 0xC1B4FB80, 0xC1B5FB80, 0xC1B6FB80, 0xC1B7FB80, 0xC1B8FB80, 0xC1B9FB80, 0xC1BAFB80, 0xC1BBFB80, 0xC1BCFB80, 0xC1BDFB80, 0xC1BEFB80, 0xC1BFFB80, 0xC1C0FB80, 0xC1C1FB80, 0xC1C2FB80, 0xC1C3FB80, 0xC1C4FB80, 0xC1C5FB80, 0xC1C6FB80, 0xC1C7FB80, 0xC1C8FB80, 0xC1C9FB80, 0xC1CAFB80, 0xC1CBFB80, 0xC1CCFB80, 0xC1CDFB80, 0xC1CEFB80, 0xC1CFFB80, 0xC1D0FB80, 0xC1D1FB80, 0xC1D2FB80, 0xC1D3FB80, 0xC1D4FB80, 0xC1D5FB80, 0xC1D6FB80, 0xC1D7FB80, 0xC1D8FB80, 0xC1D9FB80, 0xC1DAFB80, 0xC1DBFB80, 0xC1DCFB80, 0xC1DDFB80, 0xC1DEFB80, 0xC1DFFB80, 0xC1E0FB80, 0xC1E1FB80, 0xC1E2FB80, 0xC1E3FB80, 0xC1E4FB80, 0xC1E5FB80, 0xC1E6FB80, 0xC1E7FB80, 0xC1E8FB80, 0xC1E9FB80, 0xC1EAFB80, 0xC1EBFB80, 0xC1ECFB80, 0xC1EDFB80, 0xC1EEFB80, 0xC1EFFB80, 0xC1F0FB80, 0xC1F1FB80, 0xC1F2FB80, 0xC1F3FB80, 0xC1F4FB80, 0xC1F5FB80, 0xC1F6FB80, 0xC1F7FB80, 0xC1F8FB80, 0xC1F9FB80, 0xC1FAFB80, 0xC1FBFB80, 0xC1FCFB80, 0xC1FDFB80, 0xC1FEFB80, 0xC1FFFB80, 0xC200FB80, 0xC201FB80, 0xC202FB80, 0xC203FB80, 0xC204FB80, 0xC205FB80, 0xC206FB80, 0xC207FB80, 0xC208FB80, 0xC209FB80, 0xC20AFB80, 0xC20BFB80, 0xC20CFB80, /* 4163 */
+ 0xC20DFB80, 0xC20EFB80, 0xC20FFB80, 0xC210FB80, 0xC211FB80, 0xC212FB80, 0xC213FB80, 0xC214FB80, 0xC215FB80, 0xC216FB80, 0xC217FB80, 0xC218FB80, 0xC219FB80, 0xC21AFB80, 0xC21BFB80, 0xC21CFB80, 0xC21DFB80, 0xC21EFB80, 0xC21FFB80, 0xC220FB80, 0xC221FB80, 0xC222FB80, 0xC223FB80, 0xC224FB80, 0xC225FB80, 0xC226FB80, 0xC227FB80, 0xC228FB80, 0xC229FB80, 0xC22AFB80, 0xC22BFB80, 0xC22CFB80, 0xC22DFB80, 0xC22EFB80, 0xC22FFB80, 0xC230FB80, 0xC231FB80, 0xC232FB80, 0xC233FB80, 0xC234FB80, 0xC235FB80, 0xC236FB80, 0xC237FB80, 0xC238FB80, 0xC239FB80, 0xC23AFB80, 0xC23BFB80, 0xC23CFB80, 0xC23DFB80, 0xC23EFB80, 0xC23FFB80, 0xC240FB80, 0xC241FB80, 0xC242FB80, 0xC243FB80, 0xC244FB80, 0xC245FB80, 0xC246FB80, 0xC247FB80, 0xC248FB80, 0xC249FB80, 0xC24AFB80, 0xC24BFB80, 0xC24CFB80, 0xC24DFB80, 0xC24EFB80, 0xC24FFB80, 0xC250FB80, 0xC251FB80, 0xC252FB80, 0xC253FB80, 0xC254FB80, 0xC255FB80, 0xC256FB80, 0xC257FB80, 0xC258FB80, 0xC259FB80, 0xC25AFB80, 0xC25BFB80, 0xC25CFB80, 0xC25DFB80, 0xC25EFB80, 0xC25FFB80, 0xC260FB80, 0xC261FB80, 0xC262FB80, 0xC263FB80, 0xC264FB80, 0xC265FB80, 0xC266FB80, 0xC267FB80, 0xC268FB80, 0xC269FB80, 0xC26AFB80, 0xC26BFB80, 0xC26CFB80, 0xC26DFB80, 0xC26EFB80, 0xC26FFB80, 0xC270FB80, 0xC271FB80, 0xC272FB80, 0xC273FB80, 0xC274FB80, 0xC275FB80, 0xC276FB80, 0xC277FB80, 0xC278FB80, 0xC279FB80, 0xC27AFB80, 0xC27BFB80, 0xC27CFB80, 0xC27DFB80, 0xC27EFB80, 0xC27FFB80, 0xC280FB80, 0xC281FB80, 0xC282FB80, 0xC283FB80, 0xC284FB80, 0xC285FB80, 0xC286FB80, 0xC287FB80, 0xC288FB80, 0xC289FB80, 0xC28AFB80, 0xC28BFB80, 0xC28CFB80, 0xC28DFB80, 0xC28EFB80, 0xC28FFB80, 0xC290FB80, 0xC291FB80, 0xC292FB80, 0xC293FB80, 0xC294FB80, 0xC295FB80, 0xC296FB80, 0xC297FB80, 0xC298FB80, 0xC299FB80, 0xC29AFB80, 0xC29BFB80, 0xC29CFB80, 0xC29DFB80, 0xC29EFB80, 0xC29FFB80, 0xC2A0FB80, 0xC2A1FB80, 0xC2A2FB80, 0xC2A3FB80, 0xC2A4FB80, 0xC2A5FB80, 0xC2A6FB80, 0xC2A7FB80, 0xC2A8FB80, 0xC2A9FB80, 0xC2AAFB80, 0xC2ABFB80, 0xC2ACFB80, 0xC2ADFB80, 0xC2AEFB80, 0xC2AFFB80, 0xC2B0FB80, 0xC2B1FB80, 0xC2B2FB80, 0xC2B3FB80, 0xC2B4FB80, 0xC2B5FB80, 0xC2B6FB80, /* 420D */
+ 0xC2B7FB80, 0xC2B8FB80, 0xC2B9FB80, 0xC2BAFB80, 0xC2BBFB80, 0xC2BCFB80, 0xC2BDFB80, 0xC2BEFB80, 0xC2BFFB80, 0xC2C0FB80, 0xC2C1FB80, 0xC2C2FB80, 0xC2C3FB80, 0xC2C4FB80, 0xC2C5FB80, 0xC2C6FB80, 0xC2C7FB80, 0xC2C8FB80, 0xC2C9FB80, 0xC2CAFB80, 0xC2CBFB80, 0xC2CCFB80, 0xC2CDFB80, 0xC2CEFB80, 0xC2CFFB80, 0xC2D0FB80, 0xC2D1FB80, 0xC2D2FB80, 0xC2D3FB80, 0xC2D4FB80, 0xC2D5FB80, 0xC2D6FB80, 0xC2D7FB80, 0xC2D8FB80, 0xC2D9FB80, 0xC2DAFB80, 0xC2DBFB80, 0xC2DCFB80, 0xC2DDFB80, 0xC2DEFB80, 0xC2DFFB80, 0xC2E0FB80, 0xC2E1FB80, 0xC2E2FB80, 0xC2E3FB80, 0xC2E4FB80, 0xC2E5FB80, 0xC2E6FB80, 0xC2E7FB80, 0xC2E8FB80, 0xC2E9FB80, 0xC2EAFB80, 0xC2EBFB80, 0xC2ECFB80, 0xC2EDFB80, 0xC2EEFB80, 0xC2EFFB80, 0xC2F0FB80, 0xC2F1FB80, 0xC2F2FB80, 0xC2F3FB80, 0xC2F4FB80, 0xC2F5FB80, 0xC2F6FB80, 0xC2F7FB80, 0xC2F8FB80, 0xC2F9FB80, 0xC2FAFB80, 0xC2FBFB80, 0xC2FCFB80, 0xC2FDFB80, 0xC2FEFB80, 0xC2FFFB80, 0xC300FB80, 0xC301FB80, 0xC302FB80, 0xC303FB80, 0xC304FB80, 0xC305FB80, 0xC306FB80, 0xC307FB80, 0xC308FB80, 0xC309FB80, 0xC30AFB80, 0xC30BFB80, 0xC30CFB80, 0xC30DFB80, 0xC30EFB80, 0xC30FFB80, 0xC310FB80, 0xC311FB80, 0xC312FB80, 0xC313FB80, 0xC314FB80, 0xC315FB80, 0xC316FB80, 0xC317FB80, 0xC318FB80, 0xC319FB80, 0xC31AFB80, 0xC31BFB80, 0xC31CFB80, 0xC31DFB80, 0xC31EFB80, 0xC31FFB80, 0xC320FB80, 0xC321FB80, 0xC322FB80, 0xC323FB80, 0xC324FB80, 0xC325FB80, 0xC326FB80, 0xC327FB80, 0xC328FB80, 0xC329FB80, 0xC32AFB80, 0xC32BFB80, 0xC32CFB80, 0xC32DFB80, 0xC32EFB80, 0xC32FFB80, 0xC330FB80, 0xC331FB80, 0xC332FB80, 0xC333FB80, 0xC334FB80, 0xC335FB80, 0xC336FB80, 0xC337FB80, 0xC338FB80, 0xC339FB80, 0xC33AFB80, 0xC33BFB80, 0xC33CFB80, 0xC33DFB80, 0xC33EFB80, 0xC33FFB80, 0xC340FB80, 0xC341FB80, 0xC342FB80, 0xC343FB80, 0xC344FB80, 0xC345FB80, 0xC346FB80, 0xC347FB80, 0xC348FB80, 0xC349FB80, 0xC34AFB80, 0xC34BFB80, 0xC34CFB80, 0xC34DFB80, 0xC34EFB80, 0xC34FFB80, 0xC350FB80, 0xC351FB80, 0xC352FB80, 0xC353FB80, 0xC354FB80, 0xC355FB80, 0xC356FB80, 0xC357FB80, 0xC358FB80, 0xC359FB80, 0xC35AFB80, 0xC35BFB80, 0xC35CFB80, 0xC35DFB80, 0xC35EFB80, 0xC35FFB80, 0xC360FB80, /* 42B7 */
+ 0xC361FB80, 0xC362FB80, 0xC363FB80, 0xC364FB80, 0xC365FB80, 0xC366FB80, 0xC367FB80, 0xC368FB80, 0xC369FB80, 0xC36AFB80, 0xC36BFB80, 0xC36CFB80, 0xC36DFB80, 0xC36EFB80, 0xC36FFB80, 0xC370FB80, 0xC371FB80, 0xC372FB80, 0xC373FB80, 0xC374FB80, 0xC375FB80, 0xC376FB80, 0xC377FB80, 0xC378FB80, 0xC379FB80, 0xC37AFB80, 0xC37BFB80, 0xC37CFB80, 0xC37DFB80, 0xC37EFB80, 0xC37FFB80, 0xC380FB80, 0xC381FB80, 0xC382FB80, 0xC383FB80, 0xC384FB80, 0xC385FB80, 0xC386FB80, 0xC387FB80, 0xC388FB80, 0xC389FB80, 0xC38AFB80, 0xC38BFB80, 0xC38CFB80, 0xC38DFB80, 0xC38EFB80, 0xC38FFB80, 0xC390FB80, 0xC391FB80, 0xC392FB80, 0xC393FB80, 0xC394FB80, 0xC395FB80, 0xC396FB80, 0xC397FB80, 0xC398FB80, 0xC399FB80, 0xC39AFB80, 0xC39BFB80, 0xC39CFB80, 0xC39DFB80, 0xC39EFB80, 0xC39FFB80, 0xC3A0FB80, 0xC3A1FB80, 0xC3A2FB80, 0xC3A3FB80, 0xC3A4FB80, 0xC3A5FB80, 0xC3A6FB80, 0xC3A7FB80, 0xC3A8FB80, 0xC3A9FB80, 0xC3AAFB80, 0xC3ABFB80, 0xC3ACFB80, 0xC3ADFB80, 0xC3AEFB80, 0xC3AFFB80, 0xC3B0FB80, 0xC3B1FB80, 0xC3B2FB80, 0xC3B3FB80, 0xC3B4FB80, 0xC3B5FB80, 0xC3B6FB80, 0xC3B7FB80, 0xC3B8FB80, 0xC3B9FB80, 0xC3BAFB80, 0xC3BBFB80, 0xC3BCFB80, 0xC3BDFB80, 0xC3BEFB80, 0xC3BFFB80, 0xC3C0FB80, 0xC3C1FB80, 0xC3C2FB80, 0xC3C3FB80, 0xC3C4FB80, 0xC3C5FB80, 0xC3C6FB80, 0xC3C7FB80, 0xC3C8FB80, 0xC3C9FB80, 0xC3CAFB80, 0xC3CBFB80, 0xC3CCFB80, 0xC3CDFB80, 0xC3CEFB80, 0xC3CFFB80, 0xC3D0FB80, 0xC3D1FB80, 0xC3D2FB80, 0xC3D3FB80, 0xC3D4FB80, 0xC3D5FB80, 0xC3D6FB80, 0xC3D7FB80, 0xC3D8FB80, 0xC3D9FB80, 0xC3DAFB80, 0xC3DBFB80, 0xC3DCFB80, 0xC3DDFB80, 0xC3DEFB80, 0xC3DFFB80, 0xC3E0FB80, 0xC3E1FB80, 0xC3E2FB80, 0xC3E3FB80, 0xC3E4FB80, 0xC3E5FB80, 0xC3E6FB80, 0xC3E7FB80, 0xC3E8FB80, 0xC3E9FB80, 0xC3EAFB80, 0xC3EBFB80, 0xC3ECFB80, 0xC3EDFB80, 0xC3EEFB80, 0xC3EFFB80, 0xC3F0FB80, 0xC3F1FB80, 0xC3F2FB80, 0xC3F3FB80, 0xC3F4FB80, 0xC3F5FB80, 0xC3F6FB80, 0xC3F7FB80, 0xC3F8FB80, 0xC3F9FB80, 0xC3FAFB80, 0xC3FBFB80, 0xC3FCFB80, 0xC3FDFB80, 0xC3FEFB80, 0xC3FFFB80, 0xC400FB80, 0xC401FB80, 0xC402FB80, 0xC403FB80, 0xC404FB80, 0xC405FB80, 0xC406FB80, 0xC407FB80, 0xC408FB80, 0xC409FB80, 0xC40AFB80, /* 4361 */
+ 0xC40BFB80, 0xC40CFB80, 0xC40DFB80, 0xC40EFB80, 0xC40FFB80, 0xC410FB80, 0xC411FB80, 0xC412FB80, 0xC413FB80, 0xC414FB80, 0xC415FB80, 0xC416FB80, 0xC417FB80, 0xC418FB80, 0xC419FB80, 0xC41AFB80, 0xC41BFB80, 0xC41CFB80, 0xC41DFB80, 0xC41EFB80, 0xC41FFB80, 0xC420FB80, 0xC421FB80, 0xC422FB80, 0xC423FB80, 0xC424FB80, 0xC425FB80, 0xC426FB80, 0xC427FB80, 0xC428FB80, 0xC429FB80, 0xC42AFB80, 0xC42BFB80, 0xC42CFB80, 0xC42DFB80, 0xC42EFB80, 0xC42FFB80, 0xC430FB80, 0xC431FB80, 0xC432FB80, 0xC433FB80, 0xC434FB80, 0xC435FB80, 0xC436FB80, 0xC437FB80, 0xC438FB80, 0xC439FB80, 0xC43AFB80, 0xC43BFB80, 0xC43CFB80, 0xC43DFB80, 0xC43EFB80, 0xC43FFB80, 0xC440FB80, 0xC441FB80, 0xC442FB80, 0xC443FB80, 0xC444FB80, 0xC445FB80, 0xC446FB80, 0xC447FB80, 0xC448FB80, 0xC449FB80, 0xC44AFB80, 0xC44BFB80, 0xC44CFB80, 0xC44DFB80, 0xC44EFB80, 0xC44FFB80, 0xC450FB80, 0xC451FB80, 0xC452FB80, 0xC453FB80, 0xC454FB80, 0xC455FB80, 0xC456FB80, 0xC457FB80, 0xC458FB80, 0xC459FB80, 0xC45AFB80, 0xC45BFB80, 0xC45CFB80, 0xC45DFB80, 0xC45EFB80, 0xC45FFB80, 0xC460FB80, 0xC461FB80, 0xC462FB80, 0xC463FB80, 0xC464FB80, 0xC465FB80, 0xC466FB80, 0xC467FB80, 0xC468FB80, 0xC469FB80, 0xC46AFB80, 0xC46BFB80, 0xC46CFB80, 0xC46DFB80, 0xC46EFB80, 0xC46FFB80, 0xC470FB80, 0xC471FB80, 0xC472FB80, 0xC473FB80, 0xC474FB80, 0xC475FB80, 0xC476FB80, 0xC477FB80, 0xC478FB80, 0xC479FB80, 0xC47AFB80, 0xC47BFB80, 0xC47CFB80, 0xC47DFB80, 0xC47EFB80, 0xC47FFB80, 0xC480FB80, 0xC481FB80, 0xC482FB80, 0xC483FB80, 0xC484FB80, 0xC485FB80, 0xC486FB80, 0xC487FB80, 0xC488FB80, 0xC489FB80, 0xC48AFB80, 0xC48BFB80, 0xC48CFB80, 0xC48DFB80, 0xC48EFB80, 0xC48FFB80, 0xC490FB80, 0xC491FB80, 0xC492FB80, 0xC493FB80, 0xC494FB80, 0xC495FB80, 0xC496FB80, 0xC497FB80, 0xC498FB80, 0xC499FB80, 0xC49AFB80, 0xC49BFB80, 0xC49CFB80, 0xC49DFB80, 0xC49EFB80, 0xC49FFB80, 0xC4A0FB80, 0xC4A1FB80, 0xC4A2FB80, 0xC4A3FB80, 0xC4A4FB80, 0xC4A5FB80, 0xC4A6FB80, 0xC4A7FB80, 0xC4A8FB80, 0xC4A9FB80, 0xC4AAFB80, 0xC4ABFB80, 0xC4ACFB80, 0xC4ADFB80, 0xC4AEFB80, 0xC4AFFB80, 0xC4B0FB80, 0xC4B1FB80, 0xC4B2FB80, 0xC4B3FB80, 0xC4B4FB80, /* 440B */
+ 0xC4B5FB80, 0xC4B6FB80, 0xC4B7FB80, 0xC4B8FB80, 0xC4B9FB80, 0xC4BAFB80, 0xC4BBFB80, 0xC4BCFB80, 0xC4BDFB80, 0xC4BEFB80, 0xC4BFFB80, 0xC4C0FB80, 0xC4C1FB80, 0xC4C2FB80, 0xC4C3FB80, 0xC4C4FB80, 0xC4C5FB80, 0xC4C6FB80, 0xC4C7FB80, 0xC4C8FB80, 0xC4C9FB80, 0xC4CAFB80, 0xC4CBFB80, 0xC4CCFB80, 0xC4CDFB80, 0xC4CEFB80, 0xC4CFFB80, 0xC4D0FB80, 0xC4D1FB80, 0xC4D2FB80, 0xC4D3FB80, 0xC4D4FB80, 0xC4D5FB80, 0xC4D6FB80, 0xC4D7FB80, 0xC4D8FB80, 0xC4D9FB80, 0xC4DAFB80, 0xC4DBFB80, 0xC4DCFB80, 0xC4DDFB80, 0xC4DEFB80, 0xC4DFFB80, 0xC4E0FB80, 0xC4E1FB80, 0xC4E2FB80, 0xC4E3FB80, 0xC4E4FB80, 0xC4E5FB80, 0xC4E6FB80, 0xC4E7FB80, 0xC4E8FB80, 0xC4E9FB80, 0xC4EAFB80, 0xC4EBFB80, 0xC4ECFB80, 0xC4EDFB80, 0xC4EEFB80, 0xC4EFFB80, 0xC4F0FB80, 0xC4F1FB80, 0xC4F2FB80, 0xC4F3FB80, 0xC4F4FB80, 0xC4F5FB80, 0xC4F6FB80, 0xC4F7FB80, 0xC4F8FB80, 0xC4F9FB80, 0xC4FAFB80, 0xC4FBFB80, 0xC4FCFB80, 0xC4FDFB80, 0xC4FEFB80, 0xC4FFFB80, 0xC500FB80, 0xC501FB80, 0xC502FB80, 0xC503FB80, 0xC504FB80, 0xC505FB80, 0xC506FB80, 0xC507FB80, 0xC508FB80, 0xC509FB80, 0xC50AFB80, 0xC50BFB80, 0xC50CFB80, 0xC50DFB80, 0xC50EFB80, 0xC50FFB80, 0xC510FB80, 0xC511FB80, 0xC512FB80, 0xC513FB80, 0xC514FB80, 0xC515FB80, 0xC516FB80, 0xC517FB80, 0xC518FB80, 0xC519FB80, 0xC51AFB80, 0xC51BFB80, 0xC51CFB80, 0xC51DFB80, 0xC51EFB80, 0xC51FFB80, 0xC520FB80, 0xC521FB80, 0xC522FB80, 0xC523FB80, 0xC524FB80, 0xC525FB80, 0xC526FB80, 0xC527FB80, 0xC528FB80, 0xC529FB80, 0xC52AFB80, 0xC52BFB80, 0xC52CFB80, 0xC52DFB80, 0xC52EFB80, 0xC52FFB80, 0xC530FB80, 0xC531FB80, 0xC532FB80, 0xC533FB80, 0xC534FB80, 0xC535FB80, 0xC536FB80, 0xC537FB80, 0xC538FB80, 0xC539FB80, 0xC53AFB80, 0xC53BFB80, 0xC53CFB80, 0xC53DFB80, 0xC53EFB80, 0xC53FFB80, 0xC540FB80, 0xC541FB80, 0xC542FB80, 0xC543FB80, 0xC544FB80, 0xC545FB80, 0xC546FB80, 0xC547FB80, 0xC548FB80, 0xC549FB80, 0xC54AFB80, 0xC54BFB80, 0xC54CFB80, 0xC54DFB80, 0xC54EFB80, 0xC54FFB80, 0xC550FB80, 0xC551FB80, 0xC552FB80, 0xC553FB80, 0xC554FB80, 0xC555FB80, 0xC556FB80, 0xC557FB80, 0xC558FB80, 0xC559FB80, 0xC55AFB80, 0xC55BFB80, 0xC55CFB80, 0xC55DFB80, 0xC55EFB80, /* 44B5 */
+ 0xC55FFB80, 0xC560FB80, 0xC561FB80, 0xC562FB80, 0xC563FB80, 0xC564FB80, 0xC565FB80, 0xC566FB80, 0xC567FB80, 0xC568FB80, 0xC569FB80, 0xC56AFB80, 0xC56BFB80, 0xC56CFB80, 0xC56DFB80, 0xC56EFB80, 0xC56FFB80, 0xC570FB80, 0xC571FB80, 0xC572FB80, 0xC573FB80, 0xC574FB80, 0xC575FB80, 0xC576FB80, 0xC577FB80, 0xC578FB80, 0xC579FB80, 0xC57AFB80, 0xC57BFB80, 0xC57CFB80, 0xC57DFB80, 0xC57EFB80, 0xC57FFB80, 0xC580FB80, 0xC581FB80, 0xC582FB80, 0xC583FB80, 0xC584FB80, 0xC585FB80, 0xC586FB80, 0xC587FB80, 0xC588FB80, 0xC589FB80, 0xC58AFB80, 0xC58BFB80, 0xC58CFB80, 0xC58DFB80, 0xC58EFB80, 0xC58FFB80, 0xC590FB80, 0xC591FB80, 0xC592FB80, 0xC593FB80, 0xC594FB80, 0xC595FB80, 0xC596FB80, 0xC597FB80, 0xC598FB80, 0xC599FB80, 0xC59AFB80, 0xC59BFB80, 0xC59CFB80, 0xC59DFB80, 0xC59EFB80, 0xC59FFB80, 0xC5A0FB80, 0xC5A1FB80, 0xC5A2FB80, 0xC5A3FB80, 0xC5A4FB80, 0xC5A5FB80, 0xC5A6FB80, 0xC5A7FB80, 0xC5A8FB80, 0xC5A9FB80, 0xC5AAFB80, 0xC5ABFB80, 0xC5ACFB80, 0xC5ADFB80, 0xC5AEFB80, 0xC5AFFB80, 0xC5B0FB80, 0xC5B1FB80, 0xC5B2FB80, 0xC5B3FB80, 0xC5B4FB80, 0xC5B5FB80, 0xC5B6FB80, 0xC5B7FB80, 0xC5B8FB80, 0xC5B9FB80, 0xC5BAFB80, 0xC5BBFB80, 0xC5BCFB80, 0xC5BDFB80, 0xC5BEFB80, 0xC5BFFB80, 0xC5C0FB80, 0xC5C1FB80, 0xC5C2FB80, 0xC5C3FB80, 0xC5C4FB80, 0xC5C5FB80, 0xC5C6FB80, 0xC5C7FB80, 0xC5C8FB80, 0xC5C9FB80, 0xC5CAFB80, 0xC5CBFB80, 0xC5CCFB80, 0xC5CDFB80, 0xC5CEFB80, 0xC5CFFB80, 0xC5D0FB80, 0xC5D1FB80, 0xC5D2FB80, 0xC5D3FB80, 0xC5D4FB80, 0xC5D5FB80, 0xC5D6FB80, 0xC5D7FB80, 0xC5D8FB80, 0xC5D9FB80, 0xC5DAFB80, 0xC5DBFB80, 0xC5DCFB80, 0xC5DDFB80, 0xC5DEFB80, 0xC5DFFB80, 0xC5E0FB80, 0xC5E1FB80, 0xC5E2FB80, 0xC5E3FB80, 0xC5E4FB80, 0xC5E5FB80, 0xC5E6FB80, 0xC5E7FB80, 0xC5E8FB80, 0xC5E9FB80, 0xC5EAFB80, 0xC5EBFB80, 0xC5ECFB80, 0xC5EDFB80, 0xC5EEFB80, 0xC5EFFB80, 0xC5F0FB80, 0xC5F1FB80, 0xC5F2FB80, 0xC5F3FB80, 0xC5F4FB80, 0xC5F5FB80, 0xC5F6FB80, 0xC5F7FB80, 0xC5F8FB80, 0xC5F9FB80, 0xC5FAFB80, 0xC5FBFB80, 0xC5FCFB80, 0xC5FDFB80, 0xC5FEFB80, 0xC5FFFB80, 0xC600FB80, 0xC601FB80, 0xC602FB80, 0xC603FB80, 0xC604FB80, 0xC605FB80, 0xC606FB80, 0xC607FB80, 0xC608FB80, /* 455F */
+ 0xC609FB80, 0xC60AFB80, 0xC60BFB80, 0xC60CFB80, 0xC60DFB80, 0xC60EFB80, 0xC60FFB80, 0xC610FB80, 0xC611FB80, 0xC612FB80, 0xC613FB80, 0xC614FB80, 0xC615FB80, 0xC616FB80, 0xC617FB80, 0xC618FB80, 0xC619FB80, 0xC61AFB80, 0xC61BFB80, 0xC61CFB80, 0xC61DFB80, 0xC61EFB80, 0xC61FFB80, 0xC620FB80, 0xC621FB80, 0xC622FB80, 0xC623FB80, 0xC624FB80, 0xC625FB80, 0xC626FB80, 0xC627FB80, 0xC628FB80, 0xC629FB80, 0xC62AFB80, 0xC62BFB80, 0xC62CFB80, 0xC62DFB80, 0xC62EFB80, 0xC62FFB80, 0xC630FB80, 0xC631FB80, 0xC632FB80, 0xC633FB80, 0xC634FB80, 0xC635FB80, 0xC636FB80, 0xC637FB80, 0xC638FB80, 0xC639FB80, 0xC63AFB80, 0xC63BFB80, 0xC63CFB80, 0xC63DFB80, 0xC63EFB80, 0xC63FFB80, 0xC640FB80, 0xC641FB80, 0xC642FB80, 0xC643FB80, 0xC644FB80, 0xC645FB80, 0xC646FB80, 0xC647FB80, 0xC648FB80, 0xC649FB80, 0xC64AFB80, 0xC64BFB80, 0xC64CFB80, 0xC64DFB80, 0xC64EFB80, 0xC64FFB80, 0xC650FB80, 0xC651FB80, 0xC652FB80, 0xC653FB80, 0xC654FB80, 0xC655FB80, 0xC656FB80, 0xC657FB80, 0xC658FB80, 0xC659FB80, 0xC65AFB80, 0xC65BFB80, 0xC65CFB80, 0xC65DFB80, 0xC65EFB80, 0xC65FFB80, 0xC660FB80, 0xC661FB80, 0xC662FB80, 0xC663FB80, 0xC664FB80, 0xC665FB80, 0xC666FB80, 0xC667FB80, 0xC668FB80, 0xC669FB80, 0xC66AFB80, 0xC66BFB80, 0xC66CFB80, 0xC66DFB80, 0xC66EFB80, 0xC66FFB80, 0xC670FB80, 0xC671FB80, 0xC672FB80, 0xC673FB80, 0xC674FB80, 0xC675FB80, 0xC676FB80, 0xC677FB80, 0xC678FB80, 0xC679FB80, 0xC67AFB80, 0xC67BFB80, 0xC67CFB80, 0xC67DFB80, 0xC67EFB80, 0xC67FFB80, 0xC680FB80, 0xC681FB80, 0xC682FB80, 0xC683FB80, 0xC684FB80, 0xC685FB80, 0xC686FB80, 0xC687FB80, 0xC688FB80, 0xC689FB80, 0xC68AFB80, 0xC68BFB80, 0xC68CFB80, 0xC68DFB80, 0xC68EFB80, 0xC68FFB80, 0xC690FB80, 0xC691FB80, 0xC692FB80, 0xC693FB80, 0xC694FB80, 0xC695FB80, 0xC696FB80, 0xC697FB80, 0xC698FB80, 0xC699FB80, 0xC69AFB80, 0xC69BFB80, 0xC69CFB80, 0xC69DFB80, 0xC69EFB80, 0xC69FFB80, 0xC6A0FB80, 0xC6A1FB80, 0xC6A2FB80, 0xC6A3FB80, 0xC6A4FB80, 0xC6A5FB80, 0xC6A6FB80, 0xC6A7FB80, 0xC6A8FB80, 0xC6A9FB80, 0xC6AAFB80, 0xC6ABFB80, 0xC6ACFB80, 0xC6ADFB80, 0xC6AEFB80, 0xC6AFFB80, 0xC6B0FB80, 0xC6B1FB80, 0xC6B2FB80, /* 4609 */
+ 0xC6B3FB80, 0xC6B4FB80, 0xC6B5FB80, 0xC6B6FB80, 0xC6B7FB80, 0xC6B8FB80, 0xC6B9FB80, 0xC6BAFB80, 0xC6BBFB80, 0xC6BCFB80, 0xC6BDFB80, 0xC6BEFB80, 0xC6BFFB80, 0xC6C0FB80, 0xC6C1FB80, 0xC6C2FB80, 0xC6C3FB80, 0xC6C4FB80, 0xC6C5FB80, 0xC6C6FB80, 0xC6C7FB80, 0xC6C8FB80, 0xC6C9FB80, 0xC6CAFB80, 0xC6CBFB80, 0xC6CCFB80, 0xC6CDFB80, 0xC6CEFB80, 0xC6CFFB80, 0xC6D0FB80, 0xC6D1FB80, 0xC6D2FB80, 0xC6D3FB80, 0xC6D4FB80, 0xC6D5FB80, 0xC6D6FB80, 0xC6D7FB80, 0xC6D8FB80, 0xC6D9FB80, 0xC6DAFB80, 0xC6DBFB80, 0xC6DCFB80, 0xC6DDFB80, 0xC6DEFB80, 0xC6DFFB80, 0xC6E0FB80, 0xC6E1FB80, 0xC6E2FB80, 0xC6E3FB80, 0xC6E4FB80, 0xC6E5FB80, 0xC6E6FB80, 0xC6E7FB80, 0xC6E8FB80, 0xC6E9FB80, 0xC6EAFB80, 0xC6EBFB80, 0xC6ECFB80, 0xC6EDFB80, 0xC6EEFB80, 0xC6EFFB80, 0xC6F0FB80, 0xC6F1FB80, 0xC6F2FB80, 0xC6F3FB80, 0xC6F4FB80, 0xC6F5FB80, 0xC6F6FB80, 0xC6F7FB80, 0xC6F8FB80, 0xC6F9FB80, 0xC6FAFB80, 0xC6FBFB80, 0xC6FCFB80, 0xC6FDFB80, 0xC6FEFB80, 0xC6FFFB80, 0xC700FB80, 0xC701FB80, 0xC702FB80, 0xC703FB80, 0xC704FB80, 0xC705FB80, 0xC706FB80, 0xC707FB80, 0xC708FB80, 0xC709FB80, 0xC70AFB80, 0xC70BFB80, 0xC70CFB80, 0xC70DFB80, 0xC70EFB80, 0xC70FFB80, 0xC710FB80, 0xC711FB80, 0xC712FB80, 0xC713FB80, 0xC714FB80, 0xC715FB80, 0xC716FB80, 0xC717FB80, 0xC718FB80, 0xC719FB80, 0xC71AFB80, 0xC71BFB80, 0xC71CFB80, 0xC71DFB80, 0xC71EFB80, 0xC71FFB80, 0xC720FB80, 0xC721FB80, 0xC722FB80, 0xC723FB80, 0xC724FB80, 0xC725FB80, 0xC726FB80, 0xC727FB80, 0xC728FB80, 0xC729FB80, 0xC72AFB80, 0xC72BFB80, 0xC72CFB80, 0xC72DFB80, 0xC72EFB80, 0xC72FFB80, 0xC730FB80, 0xC731FB80, 0xC732FB80, 0xC733FB80, 0xC734FB80, 0xC735FB80, 0xC736FB80, 0xC737FB80, 0xC738FB80, 0xC739FB80, 0xC73AFB80, 0xC73BFB80, 0xC73CFB80, 0xC73DFB80, 0xC73EFB80, 0xC73FFB80, 0xC740FB80, 0xC741FB80, 0xC742FB80, 0xC743FB80, 0xC744FB80, 0xC745FB80, 0xC746FB80, 0xC747FB80, 0xC748FB80, 0xC749FB80, 0xC74AFB80, 0xC74BFB80, 0xC74CFB80, 0xC74DFB80, 0xC74EFB80, 0xC74FFB80, 0xC750FB80, 0xC751FB80, 0xC752FB80, 0xC753FB80, 0xC754FB80, 0xC755FB80, 0xC756FB80, 0xC757FB80, 0xC758FB80, 0xC759FB80, 0xC75AFB80, 0xC75BFB80, 0xC75CFB80, /* 46B3 */
+ 0xC75DFB80, 0xC75EFB80, 0xC75FFB80, 0xC760FB80, 0xC761FB80, 0xC762FB80, 0xC763FB80, 0xC764FB80, 0xC765FB80, 0xC766FB80, 0xC767FB80, 0xC768FB80, 0xC769FB80, 0xC76AFB80, 0xC76BFB80, 0xC76CFB80, 0xC76DFB80, 0xC76EFB80, 0xC76FFB80, 0xC770FB80, 0xC771FB80, 0xC772FB80, 0xC773FB80, 0xC774FB80, 0xC775FB80, 0xC776FB80, 0xC777FB80, 0xC778FB80, 0xC779FB80, 0xC77AFB80, 0xC77BFB80, 0xC77CFB80, 0xC77DFB80, 0xC77EFB80, 0xC77FFB80, 0xC780FB80, 0xC781FB80, 0xC782FB80, 0xC783FB80, 0xC784FB80, 0xC785FB80, 0xC786FB80, 0xC787FB80, 0xC788FB80, 0xC789FB80, 0xC78AFB80, 0xC78BFB80, 0xC78CFB80, 0xC78DFB80, 0xC78EFB80, 0xC78FFB80, 0xC790FB80, 0xC791FB80, 0xC792FB80, 0xC793FB80, 0xC794FB80, 0xC795FB80, 0xC796FB80, 0xC797FB80, 0xC798FB80, 0xC799FB80, 0xC79AFB80, 0xC79BFB80, 0xC79CFB80, 0xC79DFB80, 0xC79EFB80, 0xC79FFB80, 0xC7A0FB80, 0xC7A1FB80, 0xC7A2FB80, 0xC7A3FB80, 0xC7A4FB80, 0xC7A5FB80, 0xC7A6FB80, 0xC7A7FB80, 0xC7A8FB80, 0xC7A9FB80, 0xC7AAFB80, 0xC7ABFB80, 0xC7ACFB80, 0xC7ADFB80, 0xC7AEFB80, 0xC7AFFB80, 0xC7B0FB80, 0xC7B1FB80, 0xC7B2FB80, 0xC7B3FB80, 0xC7B4FB80, 0xC7B5FB80, 0xC7B6FB80, 0xC7B7FB80, 0xC7B8FB80, 0xC7B9FB80, 0xC7BAFB80, 0xC7BBFB80, 0xC7BCFB80, 0xC7BDFB80, 0xC7BEFB80, 0xC7BFFB80, 0xC7C0FB80, 0xC7C1FB80, 0xC7C2FB80, 0xC7C3FB80, 0xC7C4FB80, 0xC7C5FB80, 0xC7C6FB80, 0xC7C7FB80, 0xC7C8FB80, 0xC7C9FB80, 0xC7CAFB80, 0xC7CBFB80, 0xC7CCFB80, 0xC7CDFB80, 0xC7CEFB80, 0xC7CFFB80, 0xC7D0FB80, 0xC7D1FB80, 0xC7D2FB80, 0xC7D3FB80, 0xC7D4FB80, 0xC7D5FB80, 0xC7D6FB80, 0xC7D7FB80, 0xC7D8FB80, 0xC7D9FB80, 0xC7DAFB80, 0xC7DBFB80, 0xC7DCFB80, 0xC7DDFB80, 0xC7DEFB80, 0xC7DFFB80, 0xC7E0FB80, 0xC7E1FB80, 0xC7E2FB80, 0xC7E3FB80, 0xC7E4FB80, 0xC7E5FB80, 0xC7E6FB80, 0xC7E7FB80, 0xC7E8FB80, 0xC7E9FB80, 0xC7EAFB80, 0xC7EBFB80, 0xC7ECFB80, 0xC7EDFB80, 0xC7EEFB80, 0xC7EFFB80, 0xC7F0FB80, 0xC7F1FB80, 0xC7F2FB80, 0xC7F3FB80, 0xC7F4FB80, 0xC7F5FB80, 0xC7F6FB80, 0xC7F7FB80, 0xC7F8FB80, 0xC7F9FB80, 0xC7FAFB80, 0xC7FBFB80, 0xC7FCFB80, 0xC7FDFB80, 0xC7FEFB80, 0xC7FFFB80, 0xC800FB80, 0xC801FB80, 0xC802FB80, 0xC803FB80, 0xC804FB80, 0xC805FB80, 0xC806FB80, /* 475D */
+ 0xC807FB80, 0xC808FB80, 0xC809FB80, 0xC80AFB80, 0xC80BFB80, 0xC80CFB80, 0xC80DFB80, 0xC80EFB80, 0xC80FFB80, 0xC810FB80, 0xC811FB80, 0xC812FB80, 0xC813FB80, 0xC814FB80, 0xC815FB80, 0xC816FB80, 0xC817FB80, 0xC818FB80, 0xC819FB80, 0xC81AFB80, 0xC81BFB80, 0xC81CFB80, 0xC81DFB80, 0xC81EFB80, 0xC81FFB80, 0xC820FB80, 0xC821FB80, 0xC822FB80, 0xC823FB80, 0xC824FB80, 0xC825FB80, 0xC826FB80, 0xC827FB80, 0xC828FB80, 0xC829FB80, 0xC82AFB80, 0xC82BFB80, 0xC82CFB80, 0xC82DFB80, 0xC82EFB80, 0xC82FFB80, 0xC830FB80, 0xC831FB80, 0xC832FB80, 0xC833FB80, 0xC834FB80, 0xC835FB80, 0xC836FB80, 0xC837FB80, 0xC838FB80, 0xC839FB80, 0xC83AFB80, 0xC83BFB80, 0xC83CFB80, 0xC83DFB80, 0xC83EFB80, 0xC83FFB80, 0xC840FB80, 0xC841FB80, 0xC842FB80, 0xC843FB80, 0xC844FB80, 0xC845FB80, 0xC846FB80, 0xC847FB80, 0xC848FB80, 0xC849FB80, 0xC84AFB80, 0xC84BFB80, 0xC84CFB80, 0xC84DFB80, 0xC84EFB80, 0xC84FFB80, 0xC850FB80, 0xC851FB80, 0xC852FB80, 0xC853FB80, 0xC854FB80, 0xC855FB80, 0xC856FB80, 0xC857FB80, 0xC858FB80, 0xC859FB80, 0xC85AFB80, 0xC85BFB80, 0xC85CFB80, 0xC85DFB80, 0xC85EFB80, 0xC85FFB80, 0xC860FB80, 0xC861FB80, 0xC862FB80, 0xC863FB80, 0xC864FB80, 0xC865FB80, 0xC866FB80, 0xC867FB80, 0xC868FB80, 0xC869FB80, 0xC86AFB80, 0xC86BFB80, 0xC86CFB80, 0xC86DFB80, 0xC86EFB80, 0xC86FFB80, 0xC870FB80, 0xC871FB80, 0xC872FB80, 0xC873FB80, 0xC874FB80, 0xC875FB80, 0xC876FB80, 0xC877FB80, 0xC878FB80, 0xC879FB80, 0xC87AFB80, 0xC87BFB80, 0xC87CFB80, 0xC87DFB80, 0xC87EFB80, 0xC87FFB80, 0xC880FB80, 0xC881FB80, 0xC882FB80, 0xC883FB80, 0xC884FB80, 0xC885FB80, 0xC886FB80, 0xC887FB80, 0xC888FB80, 0xC889FB80, 0xC88AFB80, 0xC88BFB80, 0xC88CFB80, 0xC88DFB80, 0xC88EFB80, 0xC88FFB80, 0xC890FB80, 0xC891FB80, 0xC892FB80, 0xC893FB80, 0xC894FB80, 0xC895FB80, 0xC896FB80, 0xC897FB80, 0xC898FB80, 0xC899FB80, 0xC89AFB80, 0xC89BFB80, 0xC89CFB80, 0xC89DFB80, 0xC89EFB80, 0xC89FFB80, 0xC8A0FB80, 0xC8A1FB80, 0xC8A2FB80, 0xC8A3FB80, 0xC8A4FB80, 0xC8A5FB80, 0xC8A6FB80, 0xC8A7FB80, 0xC8A8FB80, 0xC8A9FB80, 0xC8AAFB80, 0xC8ABFB80, 0xC8ACFB80, 0xC8ADFB80, 0xC8AEFB80, 0xC8AFFB80, 0xC8B0FB80, /* 4807 */
+ 0xC8B1FB80, 0xC8B2FB80, 0xC8B3FB80, 0xC8B4FB80, 0xC8B5FB80, 0xC8B6FB80, 0xC8B7FB80, 0xC8B8FB80, 0xC8B9FB80, 0xC8BAFB80, 0xC8BBFB80, 0xC8BCFB80, 0xC8BDFB80, 0xC8BEFB80, 0xC8BFFB80, 0xC8C0FB80, 0xC8C1FB80, 0xC8C2FB80, 0xC8C3FB80, 0xC8C4FB80, 0xC8C5FB80, 0xC8C6FB80, 0xC8C7FB80, 0xC8C8FB80, 0xC8C9FB80, 0xC8CAFB80, 0xC8CBFB80, 0xC8CCFB80, 0xC8CDFB80, 0xC8CEFB80, 0xC8CFFB80, 0xC8D0FB80, 0xC8D1FB80, 0xC8D2FB80, 0xC8D3FB80, 0xC8D4FB80, 0xC8D5FB80, 0xC8D6FB80, 0xC8D7FB80, 0xC8D8FB80, 0xC8D9FB80, 0xC8DAFB80, 0xC8DBFB80, 0xC8DCFB80, 0xC8DDFB80, 0xC8DEFB80, 0xC8DFFB80, 0xC8E0FB80, 0xC8E1FB80, 0xC8E2FB80, 0xC8E3FB80, 0xC8E4FB80, 0xC8E5FB80, 0xC8E6FB80, 0xC8E7FB80, 0xC8E8FB80, 0xC8E9FB80, 0xC8EAFB80, 0xC8EBFB80, 0xC8ECFB80, 0xC8EDFB80, 0xC8EEFB80, 0xC8EFFB80, 0xC8F0FB80, 0xC8F1FB80, 0xC8F2FB80, 0xC8F3FB80, 0xC8F4FB80, 0xC8F5FB80, 0xC8F6FB80, 0xC8F7FB80, 0xC8F8FB80, 0xC8F9FB80, 0xC8FAFB80, 0xC8FBFB80, 0xC8FCFB80, 0xC8FDFB80, 0xC8FEFB80, 0xC8FFFB80, 0xC900FB80, 0xC901FB80, 0xC902FB80, 0xC903FB80, 0xC904FB80, 0xC905FB80, 0xC906FB80, 0xC907FB80, 0xC908FB80, 0xC909FB80, 0xC90AFB80, 0xC90BFB80, 0xC90CFB80, 0xC90DFB80, 0xC90EFB80, 0xC90FFB80, 0xC910FB80, 0xC911FB80, 0xC912FB80, 0xC913FB80, 0xC914FB80, 0xC915FB80, 0xC916FB80, 0xC917FB80, 0xC918FB80, 0xC919FB80, 0xC91AFB80, 0xC91BFB80, 0xC91CFB80, 0xC91DFB80, 0xC91EFB80, 0xC91FFB80, 0xC920FB80, 0xC921FB80, 0xC922FB80, 0xC923FB80, 0xC924FB80, 0xC925FB80, 0xC926FB80, 0xC927FB80, 0xC928FB80, 0xC929FB80, 0xC92AFB80, 0xC92BFB80, 0xC92CFB80, 0xC92DFB80, 0xC92EFB80, 0xC92FFB80, 0xC930FB80, 0xC931FB80, 0xC932FB80, 0xC933FB80, 0xC934FB80, 0xC935FB80, 0xC936FB80, 0xC937FB80, 0xC938FB80, 0xC939FB80, 0xC93AFB80, 0xC93BFB80, 0xC93CFB80, 0xC93DFB80, 0xC93EFB80, 0xC93FFB80, 0xC940FB80, 0xC941FB80, 0xC942FB80, 0xC943FB80, 0xC944FB80, 0xC945FB80, 0xC946FB80, 0xC947FB80, 0xC948FB80, 0xC949FB80, 0xC94AFB80, 0xC94BFB80, 0xC94CFB80, 0xC94DFB80, 0xC94EFB80, 0xC94FFB80, 0xC950FB80, 0xC951FB80, 0xC952FB80, 0xC953FB80, 0xC954FB80, 0xC955FB80, 0xC956FB80, 0xC957FB80, 0xC958FB80, 0xC959FB80, 0xC95AFB80, /* 48B1 */
+ 0xC95BFB80, 0xC95CFB80, 0xC95DFB80, 0xC95EFB80, 0xC95FFB80, 0xC960FB80, 0xC961FB80, 0xC962FB80, 0xC963FB80, 0xC964FB80, 0xC965FB80, 0xC966FB80, 0xC967FB80, 0xC968FB80, 0xC969FB80, 0xC96AFB80, 0xC96BFB80, 0xC96CFB80, 0xC96DFB80, 0xC96EFB80, 0xC96FFB80, 0xC970FB80, 0xC971FB80, 0xC972FB80, 0xC973FB80, 0xC974FB80, 0xC975FB80, 0xC976FB80, 0xC977FB80, 0xC978FB80, 0xC979FB80, 0xC97AFB80, 0xC97BFB80, 0xC97CFB80, 0xC97DFB80, 0xC97EFB80, 0xC97FFB80, 0xC980FB80, 0xC981FB80, 0xC982FB80, 0xC983FB80, 0xC984FB80, 0xC985FB80, 0xC986FB80, 0xC987FB80, 0xC988FB80, 0xC989FB80, 0xC98AFB80, 0xC98BFB80, 0xC98CFB80, 0xC98DFB80, 0xC98EFB80, 0xC98FFB80, 0xC990FB80, 0xC991FB80, 0xC992FB80, 0xC993FB80, 0xC994FB80, 0xC995FB80, 0xC996FB80, 0xC997FB80, 0xC998FB80, 0xC999FB80, 0xC99AFB80, 0xC99BFB80, 0xC99CFB80, 0xC99DFB80, 0xC99EFB80, 0xC99FFB80, 0xC9A0FB80, 0xC9A1FB80, 0xC9A2FB80, 0xC9A3FB80, 0xC9A4FB80, 0xC9A5FB80, 0xC9A6FB80, 0xC9A7FB80, 0xC9A8FB80, 0xC9A9FB80, 0xC9AAFB80, 0xC9ABFB80, 0xC9ACFB80, 0xC9ADFB80, 0xC9AEFB80, 0xC9AFFB80, 0xC9B0FB80, 0xC9B1FB80, 0xC9B2FB80, 0xC9B3FB80, 0xC9B4FB80, 0xC9B5FB80, 0xC9B6FB80, 0xC9B7FB80, 0xC9B8FB80, 0xC9B9FB80, 0xC9BAFB80, 0xC9BBFB80, 0xC9BCFB80, 0xC9BDFB80, 0xC9BEFB80, 0xC9BFFB80, 0xC9C0FB80, 0xC9C1FB80, 0xC9C2FB80, 0xC9C3FB80, 0xC9C4FB80, 0xC9C5FB80, 0xC9C6FB80, 0xC9C7FB80, 0xC9C8FB80, 0xC9C9FB80, 0xC9CAFB80, 0xC9CBFB80, 0xC9CCFB80, 0xC9CDFB80, 0xC9CEFB80, 0xC9CFFB80, 0xC9D0FB80, 0xC9D1FB80, 0xC9D2FB80, 0xC9D3FB80, 0xC9D4FB80, 0xC9D5FB80, 0xC9D6FB80, 0xC9D7FB80, 0xC9D8FB80, 0xC9D9FB80, 0xC9DAFB80, 0xC9DBFB80, 0xC9DCFB80, 0xC9DDFB80, 0xC9DEFB80, 0xC9DFFB80, 0xC9E0FB80, 0xC9E1FB80, 0xC9E2FB80, 0xC9E3FB80, 0xC9E4FB80, 0xC9E5FB80, 0xC9E6FB80, 0xC9E7FB80, 0xC9E8FB80, 0xC9E9FB80, 0xC9EAFB80, 0xC9EBFB80, 0xC9ECFB80, 0xC9EDFB80, 0xC9EEFB80, 0xC9EFFB80, 0xC9F0FB80, 0xC9F1FB80, 0xC9F2FB80, 0xC9F3FB80, 0xC9F4FB80, 0xC9F5FB80, 0xC9F6FB80, 0xC9F7FB80, 0xC9F8FB80, 0xC9F9FB80, 0xC9FAFB80, 0xC9FBFB80, 0xC9FCFB80, 0xC9FDFB80, 0xC9FEFB80, 0xC9FFFB80, 0xCA00FB80, 0xCA01FB80, 0xCA02FB80, 0xCA03FB80, 0xCA04FB80, /* 495B */
+ 0xCA05FB80, 0xCA06FB80, 0xCA07FB80, 0xCA08FB80, 0xCA09FB80, 0xCA0AFB80, 0xCA0BFB80, 0xCA0CFB80, 0xCA0DFB80, 0xCA0EFB80, 0xCA0FFB80, 0xCA10FB80, 0xCA11FB80, 0xCA12FB80, 0xCA13FB80, 0xCA14FB80, 0xCA15FB80, 0xCA16FB80, 0xCA17FB80, 0xCA18FB80, 0xCA19FB80, 0xCA1AFB80, 0xCA1BFB80, 0xCA1CFB80, 0xCA1DFB80, 0xCA1EFB80, 0xCA1FFB80, 0xCA20FB80, 0xCA21FB80, 0xCA22FB80, 0xCA23FB80, 0xCA24FB80, 0xCA25FB80, 0xCA26FB80, 0xCA27FB80, 0xCA28FB80, 0xCA29FB80, 0xCA2AFB80, 0xCA2BFB80, 0xCA2CFB80, 0xCA2DFB80, 0xCA2EFB80, 0xCA2FFB80, 0xCA30FB80, 0xCA31FB80, 0xCA32FB80, 0xCA33FB80, 0xCA34FB80, 0xCA35FB80, 0xCA36FB80, 0xCA37FB80, 0xCA38FB80, 0xCA39FB80, 0xCA3AFB80, 0xCA3BFB80, 0xCA3CFB80, 0xCA3DFB80, 0xCA3EFB80, 0xCA3FFB80, 0xCA40FB80, 0xCA41FB80, 0xCA42FB80, 0xCA43FB80, 0xCA44FB80, 0xCA45FB80, 0xCA46FB80, 0xCA47FB80, 0xCA48FB80, 0xCA49FB80, 0xCA4AFB80, 0xCA4BFB80, 0xCA4CFB80, 0xCA4DFB80, 0xCA4EFB80, 0xCA4FFB80, 0xCA50FB80, 0xCA51FB80, 0xCA52FB80, 0xCA53FB80, 0xCA54FB80, 0xCA55FB80, 0xCA56FB80, 0xCA57FB80, 0xCA58FB80, 0xCA59FB80, 0xCA5AFB80, 0xCA5BFB80, 0xCA5CFB80, 0xCA5DFB80, 0xCA5EFB80, 0xCA5FFB80, 0xCA60FB80, 0xCA61FB80, 0xCA62FB80, 0xCA63FB80, 0xCA64FB80, 0xCA65FB80, 0xCA66FB80, 0xCA67FB80, 0xCA68FB80, 0xCA69FB80, 0xCA6AFB80, 0xCA6BFB80, 0xCA6CFB80, 0xCA6DFB80, 0xCA6EFB80, 0xCA6FFB80, 0xCA70FB80, 0xCA71FB80, 0xCA72FB80, 0xCA73FB80, 0xCA74FB80, 0xCA75FB80, 0xCA76FB80, 0xCA77FB80, 0xCA78FB80, 0xCA79FB80, 0xCA7AFB80, 0xCA7BFB80, 0xCA7CFB80, 0xCA7DFB80, 0xCA7EFB80, 0xCA7FFB80, 0xCA80FB80, 0xCA81FB80, 0xCA82FB80, 0xCA83FB80, 0xCA84FB80, 0xCA85FB80, 0xCA86FB80, 0xCA87FB80, 0xCA88FB80, 0xCA89FB80, 0xCA8AFB80, 0xCA8BFB80, 0xCA8CFB80, 0xCA8DFB80, 0xCA8EFB80, 0xCA8FFB80, 0xCA90FB80, 0xCA91FB80, 0xCA92FB80, 0xCA93FB80, 0xCA94FB80, 0xCA95FB80, 0xCA96FB80, 0xCA97FB80, 0xCA98FB80, 0xCA99FB80, 0xCA9AFB80, 0xCA9BFB80, 0xCA9CFB80, 0xCA9DFB80, 0xCA9EFB80, 0xCA9FFB80, 0xCAA0FB80, 0xCAA1FB80, 0xCAA2FB80, 0xCAA3FB80, 0xCAA4FB80, 0xCAA5FB80, 0xCAA6FB80, 0xCAA7FB80, 0xCAA8FB80, 0xCAA9FB80, 0xCAAAFB80, 0xCAABFB80, 0xCAACFB80, 0xCAADFB80, 0xCAAEFB80, /* 4A05 */
+ 0xCAAFFB80, 0xCAB0FB80, 0xCAB1FB80, 0xCAB2FB80, 0xCAB3FB80, 0xCAB4FB80, 0xCAB5FB80, 0xCAB6FB80, 0xCAB7FB80, 0xCAB8FB80, 0xCAB9FB80, 0xCABAFB80, 0xCABBFB80, 0xCABCFB80, 0xCABDFB80, 0xCABEFB80, 0xCABFFB80, 0xCAC0FB80, 0xCAC1FB80, 0xCAC2FB80, 0xCAC3FB80, 0xCAC4FB80, 0xCAC5FB80, 0xCAC6FB80, 0xCAC7FB80, 0xCAC8FB80, 0xCAC9FB80, 0xCACAFB80, 0xCACBFB80, 0xCACCFB80, 0xCACDFB80, 0xCACEFB80, 0xCACFFB80, 0xCAD0FB80, 0xCAD1FB80, 0xCAD2FB80, 0xCAD3FB80, 0xCAD4FB80, 0xCAD5FB80, 0xCAD6FB80, 0xCAD7FB80, 0xCAD8FB80, 0xCAD9FB80, 0xCADAFB80, 0xCADBFB80, 0xCADCFB80, 0xCADDFB80, 0xCADEFB80, 0xCADFFB80, 0xCAE0FB80, 0xCAE1FB80, 0xCAE2FB80, 0xCAE3FB80, 0xCAE4FB80, 0xCAE5FB80, 0xCAE6FB80, 0xCAE7FB80, 0xCAE8FB80, 0xCAE9FB80, 0xCAEAFB80, 0xCAEBFB80, 0xCAECFB80, 0xCAEDFB80, 0xCAEEFB80, 0xCAEFFB80, 0xCAF0FB80, 0xCAF1FB80, 0xCAF2FB80, 0xCAF3FB80, 0xCAF4FB80, 0xCAF5FB80, 0xCAF6FB80, 0xCAF7FB80, 0xCAF8FB80, 0xCAF9FB80, 0xCAFAFB80, 0xCAFBFB80, 0xCAFCFB80, 0xCAFDFB80, 0xCAFEFB80, 0xCAFFFB80, 0xCB00FB80, 0xCB01FB80, 0xCB02FB80, 0xCB03FB80, 0xCB04FB80, 0xCB05FB80, 0xCB06FB80, 0xCB07FB80, 0xCB08FB80, 0xCB09FB80, 0xCB0AFB80, 0xCB0BFB80, 0xCB0CFB80, 0xCB0DFB80, 0xCB0EFB80, 0xCB0FFB80, 0xCB10FB80, 0xCB11FB80, 0xCB12FB80, 0xCB13FB80, 0xCB14FB80, 0xCB15FB80, 0xCB16FB80, 0xCB17FB80, 0xCB18FB80, 0xCB19FB80, 0xCB1AFB80, 0xCB1BFB80, 0xCB1CFB80, 0xCB1DFB80, 0xCB1EFB80, 0xCB1FFB80, 0xCB20FB80, 0xCB21FB80, 0xCB22FB80, 0xCB23FB80, 0xCB24FB80, 0xCB25FB80, 0xCB26FB80, 0xCB27FB80, 0xCB28FB80, 0xCB29FB80, 0xCB2AFB80, 0xCB2BFB80, 0xCB2CFB80, 0xCB2DFB80, 0xCB2EFB80, 0xCB2FFB80, 0xCB30FB80, 0xCB31FB80, 0xCB32FB80, 0xCB33FB80, 0xCB34FB80, 0xCB35FB80, 0xCB36FB80, 0xCB37FB80, 0xCB38FB80, 0xCB39FB80, 0xCB3AFB80, 0xCB3BFB80, 0xCB3CFB80, 0xCB3DFB80, 0xCB3EFB80, 0xCB3FFB80, 0xCB40FB80, 0xCB41FB80, 0xCB42FB80, 0xCB43FB80, 0xCB44FB80, 0xCB45FB80, 0xCB46FB80, 0xCB47FB80, 0xCB48FB80, 0xCB49FB80, 0xCB4AFB80, 0xCB4BFB80, 0xCB4CFB80, 0xCB4DFB80, 0xCB4EFB80, 0xCB4FFB80, 0xCB50FB80, 0xCB51FB80, 0xCB52FB80, 0xCB53FB80, 0xCB54FB80, 0xCB55FB80, 0xCB56FB80, 0xCB57FB80, 0xCB58FB80, /* 4AAF */
+ 0xCB59FB80, 0xCB5AFB80, 0xCB5BFB80, 0xCB5CFB80, 0xCB5DFB80, 0xCB5EFB80, 0xCB5FFB80, 0xCB60FB80, 0xCB61FB80, 0xCB62FB80, 0xCB63FB80, 0xCB64FB80, 0xCB65FB80, 0xCB66FB80, 0xCB67FB80, 0xCB68FB80, 0xCB69FB80, 0xCB6AFB80, 0xCB6BFB80, 0xCB6CFB80, 0xCB6DFB80, 0xCB6EFB80, 0xCB6FFB80, 0xCB70FB80, 0xCB71FB80, 0xCB72FB80, 0xCB73FB80, 0xCB74FB80, 0xCB75FB80, 0xCB76FB80, 0xCB77FB80, 0xCB78FB80, 0xCB79FB80, 0xCB7AFB80, 0xCB7BFB80, 0xCB7CFB80, 0xCB7DFB80, 0xCB7EFB80, 0xCB7FFB80, 0xCB80FB80, 0xCB81FB80, 0xCB82FB80, 0xCB83FB80, 0xCB84FB80, 0xCB85FB80, 0xCB86FB80, 0xCB87FB80, 0xCB88FB80, 0xCB89FB80, 0xCB8AFB80, 0xCB8BFB80, 0xCB8CFB80, 0xCB8DFB80, 0xCB8EFB80, 0xCB8FFB80, 0xCB90FB80, 0xCB91FB80, 0xCB92FB80, 0xCB93FB80, 0xCB94FB80, 0xCB95FB80, 0xCB96FB80, 0xCB97FB80, 0xCB98FB80, 0xCB99FB80, 0xCB9AFB80, 0xCB9BFB80, 0xCB9CFB80, 0xCB9DFB80, 0xCB9EFB80, 0xCB9FFB80, 0xCBA0FB80, 0xCBA1FB80, 0xCBA2FB80, 0xCBA3FB80, 0xCBA4FB80, 0xCBA5FB80, 0xCBA6FB80, 0xCBA7FB80, 0xCBA8FB80, 0xCBA9FB80, 0xCBAAFB80, 0xCBABFB80, 0xCBACFB80, 0xCBADFB80, 0xCBAEFB80, 0xCBAFFB80, 0xCBB0FB80, 0xCBB1FB80, 0xCBB2FB80, 0xCBB3FB80, 0xCBB4FB80, 0xCBB5FB80, 0xCBB6FB80, 0xCBB7FB80, 0xCBB8FB80, 0xCBB9FB80, 0xCBBAFB80, 0xCBBBFB80, 0xCBBCFB80, 0xCBBDFB80, 0xCBBEFB80, 0xCBBFFB80, 0xCBC0FB80, 0xCBC1FB80, 0xCBC2FB80, 0xCBC3FB80, 0xCBC4FB80, 0xCBC5FB80, 0xCBC6FB80, 0xCBC7FB80, 0xCBC8FB80, 0xCBC9FB80, 0xCBCAFB80, 0xCBCBFB80, 0xCBCCFB80, 0xCBCDFB80, 0xCBCEFB80, 0xCBCFFB80, 0xCBD0FB80, 0xCBD1FB80, 0xCBD2FB80, 0xCBD3FB80, 0xCBD4FB80, 0xCBD5FB80, 0xCBD6FB80, 0xCBD7FB80, 0xCBD8FB80, 0xCBD9FB80, 0xCBDAFB80, 0xCBDBFB80, 0xCBDCFB80, 0xCBDDFB80, 0xCBDEFB80, 0xCBDFFB80, 0xCBE0FB80, 0xCBE1FB80, 0xCBE2FB80, 0xCBE3FB80, 0xCBE4FB80, 0xCBE5FB80, 0xCBE6FB80, 0xCBE7FB80, 0xCBE8FB80, 0xCBE9FB80, 0xCBEAFB80, 0xCBEBFB80, 0xCBECFB80, 0xCBEDFB80, 0xCBEEFB80, 0xCBEFFB80, 0xCBF0FB80, 0xCBF1FB80, 0xCBF2FB80, 0xCBF3FB80, 0xCBF4FB80, 0xCBF5FB80, 0xCBF6FB80, 0xCBF7FB80, 0xCBF8FB80, 0xCBF9FB80, 0xCBFAFB80, 0xCBFBFB80, 0xCBFCFB80, 0xCBFDFB80, 0xCBFEFB80, 0xCBFFFB80, 0xCC00FB80, 0xCC01FB80, 0xCC02FB80, /* 4B59 */
+ 0xCC03FB80, 0xCC04FB80, 0xCC05FB80, 0xCC06FB80, 0xCC07FB80, 0xCC08FB80, 0xCC09FB80, 0xCC0AFB80, 0xCC0BFB80, 0xCC0CFB80, 0xCC0DFB80, 0xCC0EFB80, 0xCC0FFB80, 0xCC10FB80, 0xCC11FB80, 0xCC12FB80, 0xCC13FB80, 0xCC14FB80, 0xCC15FB80, 0xCC16FB80, 0xCC17FB80, 0xCC18FB80, 0xCC19FB80, 0xCC1AFB80, 0xCC1BFB80, 0xCC1CFB80, 0xCC1DFB80, 0xCC1EFB80, 0xCC1FFB80, 0xCC20FB80, 0xCC21FB80, 0xCC22FB80, 0xCC23FB80, 0xCC24FB80, 0xCC25FB80, 0xCC26FB80, 0xCC27FB80, 0xCC28FB80, 0xCC29FB80, 0xCC2AFB80, 0xCC2BFB80, 0xCC2CFB80, 0xCC2DFB80, 0xCC2EFB80, 0xCC2FFB80, 0xCC30FB80, 0xCC31FB80, 0xCC32FB80, 0xCC33FB80, 0xCC34FB80, 0xCC35FB80, 0xCC36FB80, 0xCC37FB80, 0xCC38FB80, 0xCC39FB80, 0xCC3AFB80, 0xCC3BFB80, 0xCC3CFB80, 0xCC3DFB80, 0xCC3EFB80, 0xCC3FFB80, 0xCC40FB80, 0xCC41FB80, 0xCC42FB80, 0xCC43FB80, 0xCC44FB80, 0xCC45FB80, 0xCC46FB80, 0xCC47FB80, 0xCC48FB80, 0xCC49FB80, 0xCC4AFB80, 0xCC4BFB80, 0xCC4CFB80, 0xCC4DFB80, 0xCC4EFB80, 0xCC4FFB80, 0xCC50FB80, 0xCC51FB80, 0xCC52FB80, 0xCC53FB80, 0xCC54FB80, 0xCC55FB80, 0xCC56FB80, 0xCC57FB80, 0xCC58FB80, 0xCC59FB80, 0xCC5AFB80, 0xCC5BFB80, 0xCC5CFB80, 0xCC5DFB80, 0xCC5EFB80, 0xCC5FFB80, 0xCC60FB80, 0xCC61FB80, 0xCC62FB80, 0xCC63FB80, 0xCC64FB80, 0xCC65FB80, 0xCC66FB80, 0xCC67FB80, 0xCC68FB80, 0xCC69FB80, 0xCC6AFB80, 0xCC6BFB80, 0xCC6CFB80, 0xCC6DFB80, 0xCC6EFB80, 0xCC6FFB80, 0xCC70FB80, 0xCC71FB80, 0xCC72FB80, 0xCC73FB80, 0xCC74FB80, 0xCC75FB80, 0xCC76FB80, 0xCC77FB80, 0xCC78FB80, 0xCC79FB80, 0xCC7AFB80, 0xCC7BFB80, 0xCC7CFB80, 0xCC7DFB80, 0xCC7EFB80, 0xCC7FFB80, 0xCC80FB80, 0xCC81FB80, 0xCC82FB80, 0xCC83FB80, 0xCC84FB80, 0xCC85FB80, 0xCC86FB80, 0xCC87FB80, 0xCC88FB80, 0xCC89FB80, 0xCC8AFB80, 0xCC8BFB80, 0xCC8CFB80, 0xCC8DFB80, 0xCC8EFB80, 0xCC8FFB80, 0xCC90FB80, 0xCC91FB80, 0xCC92FB80, 0xCC93FB80, 0xCC94FB80, 0xCC95FB80, 0xCC96FB80, 0xCC97FB80, 0xCC98FB80, 0xCC99FB80, 0xCC9AFB80, 0xCC9BFB80, 0xCC9CFB80, 0xCC9DFB80, 0xCC9EFB80, 0xCC9FFB80, 0xCCA0FB80, 0xCCA1FB80, 0xCCA2FB80, 0xCCA3FB80, 0xCCA4FB80, 0xCCA5FB80, 0xCCA6FB80, 0xCCA7FB80, 0xCCA8FB80, 0xCCA9FB80, 0xCCAAFB80, 0xCCABFB80, 0xCCACFB80, /* 4C03 */
+ 0xCCADFB80, 0xCCAEFB80, 0xCCAFFB80, 0xCCB0FB80, 0xCCB1FB80, 0xCCB2FB80, 0xCCB3FB80, 0xCCB4FB80, 0xCCB5FB80, 0xCCB6FB80, 0xCCB7FB80, 0xCCB8FB80, 0xCCB9FB80, 0xCCBAFB80, 0xCCBBFB80, 0xCCBCFB80, 0xCCBDFB80, 0xCCBEFB80, 0xCCBFFB80, 0xCCC0FB80, 0xCCC1FB80, 0xCCC2FB80, 0xCCC3FB80, 0xCCC4FB80, 0xCCC5FB80, 0xCCC6FB80, 0xCCC7FB80, 0xCCC8FB80, 0xCCC9FB80, 0xCCCAFB80, 0xCCCBFB80, 0xCCCCFB80, 0xCCCDFB80, 0xCCCEFB80, 0xCCCFFB80, 0xCCD0FB80, 0xCCD1FB80, 0xCCD2FB80, 0xCCD3FB80, 0xCCD4FB80, 0xCCD5FB80, 0xCCD6FB80, 0xCCD7FB80, 0xCCD8FB80, 0xCCD9FB80, 0xCCDAFB80, 0xCCDBFB80, 0xCCDCFB80, 0xCCDDFB80, 0xCCDEFB80, 0xCCDFFB80, 0xCCE0FB80, 0xCCE1FB80, 0xCCE2FB80, 0xCCE3FB80, 0xCCE4FB80, 0xCCE5FB80, 0xCCE6FB80, 0xCCE7FB80, 0xCCE8FB80, 0xCCE9FB80, 0xCCEAFB80, 0xCCEBFB80, 0xCCECFB80, 0xCCEDFB80, 0xCCEEFB80, 0xCCEFFB80, 0xCCF0FB80, 0xCCF1FB80, 0xCCF2FB80, 0xCCF3FB80, 0xCCF4FB80, 0xCCF5FB80, 0xCCF6FB80, 0xCCF7FB80, 0xCCF8FB80, 0xCCF9FB80, 0xCCFAFB80, 0xCCFBFB80, 0xCCFCFB80, 0xCCFDFB80, 0xCCFEFB80, 0xCCFFFB80, 0xCD00FB80, 0xCD01FB80, 0xCD02FB80, 0xCD03FB80, 0xCD04FB80, 0xCD05FB80, 0xCD06FB80, 0xCD07FB80, 0xCD08FB80, 0xCD09FB80, 0xCD0AFB80, 0xCD0BFB80, 0xCD0CFB80, 0xCD0DFB80, 0xCD0EFB80, 0xCD0FFB80, 0xCD10FB80, 0xCD11FB80, 0xCD12FB80, 0xCD13FB80, 0xCD14FB80, 0xCD15FB80, 0xCD16FB80, 0xCD17FB80, 0xCD18FB80, 0xCD19FB80, 0xCD1AFB80, 0xCD1BFB80, 0xCD1CFB80, 0xCD1DFB80, 0xCD1EFB80, 0xCD1FFB80, 0xCD20FB80, 0xCD21FB80, 0xCD22FB80, 0xCD23FB80, 0xCD24FB80, 0xCD25FB80, 0xCD26FB80, 0xCD27FB80, 0xCD28FB80, 0xCD29FB80, 0xCD2AFB80, 0xCD2BFB80, 0xCD2CFB80, 0xCD2DFB80, 0xCD2EFB80, 0xCD2FFB80, 0xCD30FB80, 0xCD31FB80, 0xCD32FB80, 0xCD33FB80, 0xCD34FB80, 0xCD35FB80, 0xCD36FB80, 0xCD37FB80, 0xCD38FB80, 0xCD39FB80, 0xCD3AFB80, 0xCD3BFB80, 0xCD3CFB80, 0xCD3DFB80, 0xCD3EFB80, 0xCD3FFB80, 0xCD40FB80, 0xCD41FB80, 0xCD42FB80, 0xCD43FB80, 0xCD44FB80, 0xCD45FB80, 0xCD46FB80, 0xCD47FB80, 0xCD48FB80, 0xCD49FB80, 0xCD4AFB80, 0xCD4BFB80, 0xCD4CFB80, 0xCD4DFB80, 0xCD4EFB80, 0xCD4FFB80, 0xCD50FB80, 0xCD51FB80, 0xCD52FB80, 0xCD53FB80, 0xCD54FB80, 0xCD55FB80, 0xCD56FB80, /* 4CAD */
+ 0xCD57FB80, 0xCD58FB80, 0xCD59FB80, 0xCD5AFB80, 0xCD5BFB80, 0xCD5CFB80, 0xCD5DFB80, 0xCD5EFB80, 0xCD5FFB80, 0xCD60FB80, 0xCD61FB80, 0xCD62FB80, 0xCD63FB80, 0xCD64FB80, 0xCD65FB80, 0xCD66FB80, 0xCD67FB80, 0xCD68FB80, 0xCD69FB80, 0xCD6AFB80, 0xCD6BFB80, 0xCD6CFB80, 0xCD6DFB80, 0xCD6EFB80, 0xCD6FFB80, 0xCD70FB80, 0xCD71FB80, 0xCD72FB80, 0xCD73FB80, 0xCD74FB80, 0xCD75FB80, 0xCD76FB80, 0xCD77FB80, 0xCD78FB80, 0xCD79FB80, 0xCD7AFB80, 0xCD7BFB80, 0xCD7CFB80, 0xCD7DFB80, 0xCD7EFB80, 0xCD7FFB80, 0xCD80FB80, 0xCD81FB80, 0xCD82FB80, 0xCD83FB80, 0xCD84FB80, 0xCD85FB80, 0xCD86FB80, 0xCD87FB80, 0xCD88FB80, 0xCD89FB80, 0xCD8AFB80, 0xCD8BFB80, 0xCD8CFB80, 0xCD8DFB80, 0xCD8EFB80, 0xCD8FFB80, 0xCD90FB80, 0xCD91FB80, 0xCD92FB80, 0xCD93FB80, 0xCD94FB80, 0xCD95FB80, 0xCD96FB80, 0xCD97FB80, 0xCD98FB80, 0xCD99FB80, 0xCD9AFB80, 0xCD9BFB80, 0xCD9CFB80, 0xCD9DFB80, 0xCD9EFB80, 0xCD9FFB80, 0xCDA0FB80, 0xCDA1FB80, 0xCDA2FB80, 0xCDA3FB80, 0xCDA4FB80, 0xCDA5FB80, 0xCDA6FB80, 0xCDA7FB80, 0xCDA8FB80, 0xCDA9FB80, 0xCDAAFB80, 0xCDABFB80, 0xCDACFB80, 0xCDADFB80, 0xCDAEFB80, 0xCDAFFB80, 0xCDB0FB80, 0xCDB1FB80, 0xCDB2FB80, 0xCDB3FB80, 0xCDB4FB80, 0xCDB5FB80, 0xCDB6FBC0, 0xCDB7FBC0, 0xCDB8FBC0, 0xCDB9FBC0, 0xCDBAFBC0, 0xCDBBFBC0, 0xCDBCFBC0, 0xCDBDFBC0, 0xCDBEFBC0, 0xCDBFFBC0, 0xB37, 0xB38, 0xB39, 0xB3A, 0xB3B, 0xB3C, 0xB3D, 0xB3E, 0xB3F, 0xB40, 0xB41, 0xB42, 0xB43, 0xB44, 0xB45, 0xB46, 0xB47, 0xB48, 0xB49, 0xB4A, 0xB4B, 0xB4C, 0xB4D, 0xB4E, 0xB4F, 0xB50, 0xB51, 0xB52, 0xB53, 0xB54, 0xB55, 0xB56, 0xB57, 0xB58, 0xB59, 0xB5A, 0xB5B, 0xB5C, 0xB5D, 0xB5E, 0xB5F, 0xB60, 0xB61, 0xB62, 0xB63, 0xB64, 0xB65, 0xB66, 0xB67, 0xB68, 0xB69, 0xB6A, 0xB6B, 0xB6C, 0xB6D, 0xB6E, 0xB6F, 0xB70, 0xB71, 0xB72, 0xB73, 0xB74, 0xB75, 0xB76, 0xCE00FB40, 0xCE01FB40, 0xCE02FB40, 0xCE03FB40, 0xCE04FB40, 0xCE05FB40, 0xCE06FB40, 0xCE07FB40, 0xCE08FB40, 0xCE09FB40, 0xCE0AFB40, 0xCE0BFB40, 0xCE0CFB40, 0xCE0DFB40, 0xCE0EFB40, 0xCE0FFB40, 0xCE10FB40, 0xCE11FB40, 0xCE12FB40, 0xCE13FB40, 0xCE14FB40, 0xCE15FB40, 0xCE16FB40, 0xCE17FB40, 0xCE18FB40, 0xCE19FB40, 0xCE1AFB40, 0xCE1BFB40, /* 4D57 */
+ 0xCE1CFB40, 0xCE1DFB40, 0xCE1EFB40, 0xCE1FFB40, 0xCE20FB40, 0xCE21FB40, 0xCE22FB40, 0xCE23FB40, 0xCE24FB40, 0xCE25FB40, 0xCE26FB40, 0xCE27FB40, 0xCE28FB40, 0xCE29FB40, 0xCE2AFB40, 0xCE2BFB40, 0xCE2CFB40, 0xCE2DFB40, 0xCE2EFB40, 0xCE2FFB40, 0xCE30FB40, 0xCE31FB40, 0xCE32FB40, 0xCE33FB40, 0xCE34FB40, 0xCE35FB40, 0xCE36FB40, 0xCE37FB40, 0xCE38FB40, 0xCE39FB40, 0xCE3AFB40, 0xCE3BFB40, 0xCE3CFB40, 0xCE3DFB40, 0xCE3EFB40, 0xCE3FFB40, 0xCE40FB40, 0xCE41FB40, 0xCE42FB40, 0xCE43FB40, 0xCE44FB40, 0xCE45FB40, 0xCE46FB40, 0xCE47FB40, 0xCE48FB40, 0xCE49FB40, 0xCE4AFB40, 0xCE4BFB40, 0xCE4CFB40, 0xCE4DFB40, 0xCE4EFB40, 0xCE4FFB40, 0xCE50FB40, 0xCE51FB40, 0xCE52FB40, 0xCE53FB40, 0xCE54FB40, 0xCE55FB40, 0xCE56FB40, 0xCE57FB40, 0xCE58FB40, 0xCE59FB40, 0xCE5AFB40, 0xCE5BFB40, 0xCE5CFB40, 0xCE5DFB40, 0xCE5EFB40, 0xCE5FFB40, 0xCE60FB40, 0xCE61FB40, 0xCE62FB40, 0xCE63FB40, 0xCE64FB40, 0xCE65FB40, 0xCE66FB40, 0xCE67FB40, 0xCE68FB40, 0xCE69FB40, 0xCE6AFB40, 0xCE6BFB40, 0xCE6CFB40, 0xCE6DFB40, 0xCE6EFB40, 0xCE6FFB40, 0xCE70FB40, 0xCE71FB40, 0xCE72FB40, 0xCE73FB40, 0xCE74FB40, 0xCE75FB40, 0xCE76FB40, 0xCE77FB40, 0xCE78FB40, 0xCE79FB40, 0xCE7AFB40, 0xCE7BFB40, 0xCE7CFB40, 0xCE7DFB40, 0xCE7EFB40, 0xCE7FFB40, 0xCE80FB40, 0xCE81FB40, 0xCE82FB40, 0xCE83FB40, 0xCE84FB40, 0xCE85FB40, 0xCE86FB40, 0xCE87FB40, 0xCE88FB40, 0xCE89FB40, 0xCE8AFB40, 0xCE8BFB40, 0xCE8CFB40, 0xCE8DFB40, 0xCE8EFB40, 0xCE8FFB40, 0xCE90FB40, 0xCE91FB40, 0xCE92FB40, 0xCE93FB40, 0xCE94FB40, 0xCE95FB40, 0xCE96FB40, 0xCE97FB40, 0xCE98FB40, 0xCE99FB40, 0xCE9AFB40, 0xCE9BFB40, 0xCE9CFB40, 0xCE9DFB40, 0xCE9EFB40, 0xCE9FFB40, 0xCEA0FB40, 0xCEA1FB40, 0xCEA2FB40, 0xCEA3FB40, 0xCEA4FB40, 0xCEA5FB40, 0xCEA6FB40, 0xCEA7FB40, 0xCEA8FB40, 0xCEA9FB40, 0xCEAAFB40, 0xCEABFB40, 0xCEACFB40, 0xCEADFB40, 0xCEAEFB40, 0xCEAFFB40, 0xCEB0FB40, 0xCEB1FB40, 0xCEB2FB40, 0xCEB3FB40, 0xCEB4FB40, 0xCEB5FB40, 0xCEB6FB40, 0xCEB7FB40, 0xCEB8FB40, 0xCEB9FB40, 0xCEBAFB40, 0xCEBBFB40, 0xCEBCFB40, 0xCEBDFB40, 0xCEBEFB40, 0xCEBFFB40, 0xCEC0FB40, 0xCEC1FB40, 0xCEC2FB40, 0xCEC3FB40, 0xCEC4FB40, 0xCEC5FB40, /* 4E1C */
+ 0xCEC6FB40, 0xCEC7FB40, 0xCEC8FB40, 0xCEC9FB40, 0xCECAFB40, 0xCECBFB40, 0xCECCFB40, 0xCECDFB40, 0xCECEFB40, 0xCECFFB40, 0xCED0FB40, 0xCED1FB40, 0xCED2FB40, 0xCED3FB40, 0xCED4FB40, 0xCED5FB40, 0xCED6FB40, 0xCED7FB40, 0xCED8FB40, 0xCED9FB40, 0xCEDAFB40, 0xCEDBFB40, 0xCEDCFB40, 0xCEDDFB40, 0xCEDEFB40, 0xCEDFFB40, 0xCEE0FB40, 0xCEE1FB40, 0xCEE2FB40, 0xCEE3FB40, 0xCEE4FB40, 0xCEE5FB40, 0xCEE6FB40, 0xCEE7FB40, 0xCEE8FB40, 0xCEE9FB40, 0xCEEAFB40, 0xCEEBFB40, 0xCEECFB40, 0xCEEDFB40, 0xCEEEFB40, 0xCEEFFB40, 0xCEF0FB40, 0xCEF1FB40, 0xCEF2FB40, 0xCEF3FB40, 0xCEF4FB40, 0xCEF5FB40, 0xCEF6FB40, 0xCEF7FB40, 0xCEF8FB40, 0xCEF9FB40, 0xCEFAFB40, 0xCEFBFB40, 0xCEFCFB40, 0xCEFDFB40, 0xCEFEFB40, 0xCEFFFB40, 0xCF00FB40, 0xCF01FB40, 0xCF02FB40, 0xCF03FB40, 0xCF04FB40, 0xCF05FB40, 0xCF06FB40, 0xCF07FB40, 0xCF08FB40, 0xCF09FB40, 0xCF0AFB40, 0xCF0BFB40, 0xCF0CFB40, 0xCF0DFB40, 0xCF0EFB40, 0xCF0FFB40, 0xCF10FB40, 0xCF11FB40, 0xCF12FB40, 0xCF13FB40, 0xCF14FB40, 0xCF15FB40, 0xCF16FB40, 0xCF17FB40, 0xCF18FB40, 0xCF19FB40, 0xCF1AFB40, 0xCF1BFB40, 0xCF1CFB40, 0xCF1DFB40, 0xCF1EFB40, 0xCF1FFB40, 0xCF20FB40, 0xCF21FB40, 0xCF22FB40, 0xCF23FB40, 0xCF24FB40, 0xCF25FB40, 0xCF26FB40, 0xCF27FB40, 0xCF28FB40, 0xCF29FB40, 0xCF2AFB40, 0xCF2BFB40, 0xCF2CFB40, 0xCF2DFB40, 0xCF2EFB40, 0xCF2FFB40, 0xCF30FB40, 0xCF31FB40, 0xCF32FB40, 0xCF33FB40, 0xCF34FB40, 0xCF35FB40, 0xCF36FB40, 0xCF37FB40, 0xCF38FB40, 0xCF39FB40, 0xCF3AFB40, 0xCF3BFB40, 0xCF3CFB40, 0xCF3DFB40, 0xCF3EFB40, 0xCF3FFB40, 0xCF40FB40, 0xCF41FB40, 0xCF42FB40, 0xCF43FB40, 0xCF44FB40, 0xCF45FB40, 0xCF46FB40, 0xCF47FB40, 0xCF48FB40, 0xCF49FB40, 0xCF4AFB40, 0xCF4BFB40, 0xCF4CFB40, 0xCF4DFB40, 0xCF4EFB40, 0xCF4FFB40, 0xCF50FB40, 0xCF51FB40, 0xCF52FB40, 0xCF53FB40, 0xCF54FB40, 0xCF55FB40, 0xCF56FB40, 0xCF57FB40, 0xCF58FB40, 0xCF59FB40, 0xCF5AFB40, 0xCF5BFB40, 0xCF5CFB40, 0xCF5DFB40, 0xCF5EFB40, 0xCF5FFB40, 0xCF60FB40, 0xCF61FB40, 0xCF62FB40, 0xCF63FB40, 0xCF64FB40, 0xCF65FB40, 0xCF66FB40, 0xCF67FB40, 0xCF68FB40, 0xCF69FB40, 0xCF6AFB40, 0xCF6BFB40, 0xCF6CFB40, 0xCF6DFB40, 0xCF6EFB40, 0xCF6FFB40, /* 4EC6 */
+ 0xCF70FB40, 0xCF71FB40, 0xCF72FB40, 0xCF73FB40, 0xCF74FB40, 0xCF75FB40, 0xCF76FB40, 0xCF77FB40, 0xCF78FB40, 0xCF79FB40, 0xCF7AFB40, 0xCF7BFB40, 0xCF7CFB40, 0xCF7DFB40, 0xCF7EFB40, 0xCF7FFB40, 0xCF80FB40, 0xCF81FB40, 0xCF82FB40, 0xCF83FB40, 0xCF84FB40, 0xCF85FB40, 0xCF86FB40, 0xCF87FB40, 0xCF88FB40, 0xCF89FB40, 0xCF8AFB40, 0xCF8BFB40, 0xCF8CFB40, 0xCF8DFB40, 0xCF8EFB40, 0xCF8FFB40, 0xCF90FB40, 0xCF91FB40, 0xCF92FB40, 0xCF93FB40, 0xCF94FB40, 0xCF95FB40, 0xCF96FB40, 0xCF97FB40, 0xCF98FB40, 0xCF99FB40, 0xCF9AFB40, 0xCF9BFB40, 0xCF9CFB40, 0xCF9DFB40, 0xCF9EFB40, 0xCF9FFB40, 0xCFA0FB40, 0xCFA1FB40, 0xCFA2FB40, 0xCFA3FB40, 0xCFA4FB40, 0xCFA5FB40, 0xCFA6FB40, 0xCFA7FB40, 0xCFA8FB40, 0xCFA9FB40, 0xCFAAFB40, 0xCFABFB40, 0xCFACFB40, 0xCFADFB40, 0xCFAEFB40, 0xCFAFFB40, 0xCFB0FB40, 0xCFB1FB40, 0xCFB2FB40, 0xCFB3FB40, 0xCFB4FB40, 0xCFB5FB40, 0xCFB6FB40, 0xCFB7FB40, 0xCFB8FB40, 0xCFB9FB40, 0xCFBAFB40, 0xCFBBFB40, 0xCFBCFB40, 0xCFBDFB40, 0xCFBEFB40, 0xCFBFFB40, 0xCFC0FB40, 0xCFC1FB40, 0xCFC2FB40, 0xCFC3FB40, 0xCFC4FB40, 0xCFC5FB40, 0xCFC6FB40, 0xCFC7FB40, 0xCFC8FB40, 0xCFC9FB40, 0xCFCAFB40, 0xCFCBFB40, 0xCFCCFB40, 0xCFCDFB40, 0xCFCEFB40, 0xCFCFFB40, 0xCFD0FB40, 0xCFD1FB40, 0xCFD2FB40, 0xCFD3FB40, 0xCFD4FB40, 0xCFD5FB40, 0xCFD6FB40, 0xCFD7FB40, 0xCFD8FB40, 0xCFD9FB40, 0xCFDAFB40, 0xCFDBFB40, 0xCFDCFB40, 0xCFDDFB40, 0xCFDEFB40, 0xCFDFFB40, 0xCFE0FB40, 0xCFE1FB40, 0xCFE2FB40, 0xCFE3FB40, 0xCFE4FB40, 0xCFE5FB40, 0xCFE6FB40, 0xCFE7FB40, 0xCFE8FB40, 0xCFE9FB40, 0xCFEAFB40, 0xCFEBFB40, 0xCFECFB40, 0xCFEDFB40, 0xCFEEFB40, 0xCFEFFB40, 0xCFF0FB40, 0xCFF1FB40, 0xCFF2FB40, 0xCFF3FB40, 0xCFF4FB40, 0xCFF5FB40, 0xCFF6FB40, 0xCFF7FB40, 0xCFF8FB40, 0xCFF9FB40, 0xCFFAFB40, 0xCFFBFB40, 0xCFFCFB40, 0xCFFDFB40, 0xCFFEFB40, 0xCFFFFB40, 0xD000FB40, 0xD001FB40, 0xD002FB40, 0xD003FB40, 0xD004FB40, 0xD005FB40, 0xD006FB40, 0xD007FB40, 0xD008FB40, 0xD009FB40, 0xD00AFB40, 0xD00BFB40, 0xD00CFB40, 0xD00DFB40, 0xD00EFB40, 0xD00FFB40, 0xD010FB40, 0xD011FB40, 0xD012FB40, 0xD013FB40, 0xD014FB40, 0xD015FB40, 0xD016FB40, 0xD017FB40, 0xD018FB40, 0xD019FB40, /* 4F70 */
+ 0xD01AFB40, 0xD01BFB40, 0xD01CFB40, 0xD01DFB40, 0xD01EFB40, 0xD01FFB40, 0xD020FB40, 0xD021FB40, 0xD022FB40, 0xD023FB40, 0xD024FB40, 0xD025FB40, 0xD026FB40, 0xD027FB40, 0xD028FB40, 0xD029FB40, 0xD02AFB40, 0xD02BFB40, 0xD02CFB40, 0xD02DFB40, 0xD02EFB40, 0xD02FFB40, 0xD030FB40, 0xD031FB40, 0xD032FB40, 0xD033FB40, 0xD034FB40, 0xD035FB40, 0xD036FB40, 0xD037FB40, 0xD038FB40, 0xD039FB40, 0xD03AFB40, 0xD03BFB40, 0xD03CFB40, 0xD03DFB40, 0xD03EFB40, 0xD03FFB40, 0xD040FB40, 0xD041FB40, 0xD042FB40, 0xD043FB40, 0xD044FB40, 0xD045FB40, 0xD046FB40, 0xD047FB40, 0xD048FB40, 0xD049FB40, 0xD04AFB40, 0xD04BFB40, 0xD04CFB40, 0xD04DFB40, 0xD04EFB40, 0xD04FFB40, 0xD050FB40, 0xD051FB40, 0xD052FB40, 0xD053FB40, 0xD054FB40, 0xD055FB40, 0xD056FB40, 0xD057FB40, 0xD058FB40, 0xD059FB40, 0xD05AFB40, 0xD05BFB40, 0xD05CFB40, 0xD05DFB40, 0xD05EFB40, 0xD05FFB40, 0xD060FB40, 0xD061FB40, 0xD062FB40, 0xD063FB40, 0xD064FB40, 0xD065FB40, 0xD066FB40, 0xD067FB40, 0xD068FB40, 0xD069FB40, 0xD06AFB40, 0xD06BFB40, 0xD06CFB40, 0xD06DFB40, 0xD06EFB40, 0xD06FFB40, 0xD070FB40, 0xD071FB40, 0xD072FB40, 0xD073FB40, 0xD074FB40, 0xD075FB40, 0xD076FB40, 0xD077FB40, 0xD078FB40, 0xD079FB40, 0xD07AFB40, 0xD07BFB40, 0xD07CFB40, 0xD07DFB40, 0xD07EFB40, 0xD07FFB40, 0xD080FB40, 0xD081FB40, 0xD082FB40, 0xD083FB40, 0xD084FB40, 0xD085FB40, 0xD086FB40, 0xD087FB40, 0xD088FB40, 0xD089FB40, 0xD08AFB40, 0xD08BFB40, 0xD08CFB40, 0xD08DFB40, 0xD08EFB40, 0xD08FFB40, 0xD090FB40, 0xD091FB40, 0xD092FB40, 0xD093FB40, 0xD094FB40, 0xD095FB40, 0xD096FB40, 0xD097FB40, 0xD098FB40, 0xD099FB40, 0xD09AFB40, 0xD09BFB40, 0xD09CFB40, 0xD09DFB40, 0xD09EFB40, 0xD09FFB40, 0xD0A0FB40, 0xD0A1FB40, 0xD0A2FB40, 0xD0A3FB40, 0xD0A4FB40, 0xD0A5FB40, 0xD0A6FB40, 0xD0A7FB40, 0xD0A8FB40, 0xD0A9FB40, 0xD0AAFB40, 0xD0ABFB40, 0xD0ACFB40, 0xD0ADFB40, 0xD0AEFB40, 0xD0AFFB40, 0xD0B0FB40, 0xD0B1FB40, 0xD0B2FB40, 0xD0B3FB40, 0xD0B4FB40, 0xD0B5FB40, 0xD0B6FB40, 0xD0B7FB40, 0xD0B8FB40, 0xD0B9FB40, 0xD0BAFB40, 0xD0BBFB40, 0xD0BCFB40, 0xD0BDFB40, 0xD0BEFB40, 0xD0BFFB40, 0xD0C0FB40, 0xD0C1FB40, 0xD0C2FB40, 0xD0C3FB40, /* 501A */
+ 0xD0C4FB40, 0xD0C5FB40, 0xD0C6FB40, 0xD0C7FB40, 0xD0C8FB40, 0xD0C9FB40, 0xD0CAFB40, 0xD0CBFB40, 0xD0CCFB40, 0xD0CDFB40, 0xD0CEFB40, 0xD0CFFB40, 0xD0D0FB40, 0xD0D1FB40, 0xD0D2FB40, 0xD0D3FB40, 0xD0D4FB40, 0xD0D5FB40, 0xD0D6FB40, 0xD0D7FB40, 0xD0D8FB40, 0xD0D9FB40, 0xD0DAFB40, 0xD0DBFB40, 0xD0DCFB40, 0xD0DDFB40, 0xD0DEFB40, 0xD0DFFB40, 0xD0E0FB40, 0xD0E1FB40, 0xD0E2FB40, 0xD0E3FB40, 0xD0E4FB40, 0xD0E5FB40, 0xD0E6FB40, 0xD0E7FB40, 0xD0E8FB40, 0xD0E9FB40, 0xD0EAFB40, 0xD0EBFB40, 0xD0ECFB40, 0xD0EDFB40, 0xD0EEFB40, 0xD0EFFB40, 0xD0F0FB40, 0xD0F1FB40, 0xD0F2FB40, 0xD0F3FB40, 0xD0F4FB40, 0xD0F5FB40, 0xD0F6FB40, 0xD0F7FB40, 0xD0F8FB40, 0xD0F9FB40, 0xD0FAFB40, 0xD0FBFB40, 0xD0FCFB40, 0xD0FDFB40, 0xD0FEFB40, 0xD0FFFB40, 0xD100FB40, 0xD101FB40, 0xD102FB40, 0xD103FB40, 0xD104FB40, 0xD105FB40, 0xD106FB40, 0xD107FB40, 0xD108FB40, 0xD109FB40, 0xD10AFB40, 0xD10BFB40, 0xD10CFB40, 0xD10DFB40, 0xD10EFB40, 0xD10FFB40, 0xD110FB40, 0xD111FB40, 0xD112FB40, 0xD113FB40, 0xD114FB40, 0xD115FB40, 0xD116FB40, 0xD117FB40, 0xD118FB40, 0xD119FB40, 0xD11AFB40, 0xD11BFB40, 0xD11CFB40, 0xD11DFB40, 0xD11EFB40, 0xD11FFB40, 0xD120FB40, 0xD121FB40, 0xD122FB40, 0xD123FB40, 0xD124FB40, 0xD125FB40, 0xD126FB40, 0xD127FB40, 0xD128FB40, 0xD129FB40, 0xD12AFB40, 0xD12BFB40, 0xD12CFB40, 0xD12DFB40, 0xD12EFB40, 0xD12FFB40, 0xD130FB40, 0xD131FB40, 0xD132FB40, 0xD133FB40, 0xD134FB40, 0xD135FB40, 0xD136FB40, 0xD137FB40, 0xD138FB40, 0xD139FB40, 0xD13AFB40, 0xD13BFB40, 0xD13CFB40, 0xD13DFB40, 0xD13EFB40, 0xD13FFB40, 0xD140FB40, 0xD141FB40, 0xD142FB40, 0xD143FB40, 0xD144FB40, 0xD145FB40, 0xD146FB40, 0xD147FB40, 0xD148FB40, 0xD149FB40, 0xD14AFB40, 0xD14BFB40, 0xD14CFB40, 0xD14DFB40, 0xD14EFB40, 0xD14FFB40, 0xD150FB40, 0xD151FB40, 0xD152FB40, 0xD153FB40, 0xD154FB40, 0xD155FB40, 0xD156FB40, 0xD157FB40, 0xD158FB40, 0xD159FB40, 0xD15AFB40, 0xD15BFB40, 0xD15CFB40, 0xD15DFB40, 0xD15EFB40, 0xD15FFB40, 0xD160FB40, 0xD161FB40, 0xD162FB40, 0xD163FB40, 0xD164FB40, 0xD165FB40, 0xD166FB40, 0xD167FB40, 0xD168FB40, 0xD169FB40, 0xD16AFB40, 0xD16BFB40, 0xD16CFB40, 0xD16DFB40, /* 50C4 */
+ 0xD16EFB40, 0xD16FFB40, 0xD170FB40, 0xD171FB40, 0xD172FB40, 0xD173FB40, 0xD174FB40, 0xD175FB40, 0xD176FB40, 0xD177FB40, 0xD178FB40, 0xD179FB40, 0xD17AFB40, 0xD17BFB40, 0xD17CFB40, 0xD17DFB40, 0xD17EFB40, 0xD17FFB40, 0xD180FB40, 0xD181FB40, 0xD182FB40, 0xD183FB40, 0xD184FB40, 0xD185FB40, 0xD186FB40, 0xD187FB40, 0xD188FB40, 0xD189FB40, 0xD18AFB40, 0xD18BFB40, 0xD18CFB40, 0xD18DFB40, 0xD18EFB40, 0xD18FFB40, 0xD190FB40, 0xD191FB40, 0xD192FB40, 0xD193FB40, 0xD194FB40, 0xD195FB40, 0xD196FB40, 0xD197FB40, 0xD198FB40, 0xD199FB40, 0xD19AFB40, 0xD19BFB40, 0xD19CFB40, 0xD19DFB40, 0xD19EFB40, 0xD19FFB40, 0xD1A0FB40, 0xD1A1FB40, 0xD1A2FB40, 0xD1A3FB40, 0xD1A4FB40, 0xD1A5FB40, 0xD1A6FB40, 0xD1A7FB40, 0xD1A8FB40, 0xD1A9FB40, 0xD1AAFB40, 0xD1ABFB40, 0xD1ACFB40, 0xD1ADFB40, 0xD1AEFB40, 0xD1AFFB40, 0xD1B0FB40, 0xD1B1FB40, 0xD1B2FB40, 0xD1B3FB40, 0xD1B4FB40, 0xD1B5FB40, 0xD1B6FB40, 0xD1B7FB40, 0xD1B8FB40, 0xD1B9FB40, 0xD1BAFB40, 0xD1BBFB40, 0xD1BCFB40, 0xD1BDFB40, 0xD1BEFB40, 0xD1BFFB40, 0xD1C0FB40, 0xD1C1FB40, 0xD1C2FB40, 0xD1C3FB40, 0xD1C4FB40, 0xD1C5FB40, 0xD1C6FB40, 0xD1C7FB40, 0xD1C8FB40, 0xD1C9FB40, 0xD1CAFB40, 0xD1CBFB40, 0xD1CCFB40, 0xD1CDFB40, 0xD1CEFB40, 0xD1CFFB40, 0xD1D0FB40, 0xD1D1FB40, 0xD1D2FB40, 0xD1D3FB40, 0xD1D4FB40, 0xD1D5FB40, 0xD1D6FB40, 0xD1D7FB40, 0xD1D8FB40, 0xD1D9FB40, 0xD1DAFB40, 0xD1DBFB40, 0xD1DCFB40, 0xD1DDFB40, 0xD1DEFB40, 0xD1DFFB40, 0xD1E0FB40, 0xD1E1FB40, 0xD1E2FB40, 0xD1E3FB40, 0xD1E4FB40, 0xD1E5FB40, 0xD1E6FB40, 0xD1E7FB40, 0xD1E8FB40, 0xD1E9FB40, 0xD1EAFB40, 0xD1EBFB40, 0xD1ECFB40, 0xD1EDFB40, 0xD1EEFB40, 0xD1EFFB40, 0xD1F0FB40, 0xD1F1FB40, 0xD1F2FB40, 0xD1F3FB40, 0xD1F4FB40, 0xD1F5FB40, 0xD1F6FB40, 0xD1F7FB40, 0xD1F8FB40, 0xD1F9FB40, 0xD1FAFB40, 0xD1FBFB40, 0xD1FCFB40, 0xD1FDFB40, 0xD1FEFB40, 0xD1FFFB40, 0xD200FB40, 0xD201FB40, 0xD202FB40, 0xD203FB40, 0xD204FB40, 0xD205FB40, 0xD206FB40, 0xD207FB40, 0xD208FB40, 0xD209FB40, 0xD20AFB40, 0xD20BFB40, 0xD20CFB40, 0xD20DFB40, 0xD20EFB40, 0xD20FFB40, 0xD210FB40, 0xD211FB40, 0xD212FB40, 0xD213FB40, 0xD214FB40, 0xD215FB40, 0xD216FB40, 0xD217FB40, /* 516E */
+ 0xD218FB40, 0xD219FB40, 0xD21AFB40, 0xD21BFB40, 0xD21CFB40, 0xD21DFB40, 0xD21EFB40, 0xD21FFB40, 0xD220FB40, 0xD221FB40, 0xD222FB40, 0xD223FB40, 0xD224FB40, 0xD225FB40, 0xD226FB40, 0xD227FB40, 0xD228FB40, 0xD229FB40, 0xD22AFB40, 0xD22BFB40, 0xD22CFB40, 0xD22DFB40, 0xD22EFB40, 0xD22FFB40, 0xD230FB40, 0xD231FB40, 0xD232FB40, 0xD233FB40, 0xD234FB40, 0xD235FB40, 0xD236FB40, 0xD237FB40, 0xD238FB40, 0xD239FB40, 0xD23AFB40, 0xD23BFB40, 0xD23CFB40, 0xD23DFB40, 0xD23EFB40, 0xD23FFB40, 0xD240FB40, 0xD241FB40, 0xD242FB40, 0xD243FB40, 0xD244FB40, 0xD245FB40, 0xD246FB40, 0xD247FB40, 0xD248FB40, 0xD249FB40, 0xD24AFB40, 0xD24BFB40, 0xD24CFB40, 0xD24DFB40, 0xD24EFB40, 0xD24FFB40, 0xD250FB40, 0xD251FB40, 0xD252FB40, 0xD253FB40, 0xD254FB40, 0xD255FB40, 0xD256FB40, 0xD257FB40, 0xD258FB40, 0xD259FB40, 0xD25AFB40, 0xD25BFB40, 0xD25CFB40, 0xD25DFB40, 0xD25EFB40, 0xD25FFB40, 0xD260FB40, 0xD261FB40, 0xD262FB40, 0xD263FB40, 0xD264FB40, 0xD265FB40, 0xD266FB40, 0xD267FB40, 0xD268FB40, 0xD269FB40, 0xD26AFB40, 0xD26BFB40, 0xD26CFB40, 0xD26DFB40, 0xD26EFB40, 0xD26FFB40, 0xD270FB40, 0xD271FB40, 0xD272FB40, 0xD273FB40, 0xD274FB40, 0xD275FB40, 0xD276FB40, 0xD277FB40, 0xD278FB40, 0xD279FB40, 0xD27AFB40, 0xD27BFB40, 0xD27CFB40, 0xD27DFB40, 0xD27EFB40, 0xD27FFB40, 0xD280FB40, 0xD281FB40, 0xD282FB40, 0xD283FB40, 0xD284FB40, 0xD285FB40, 0xD286FB40, 0xD287FB40, 0xD288FB40, 0xD289FB40, 0xD28AFB40, 0xD28BFB40, 0xD28CFB40, 0xD28DFB40, 0xD28EFB40, 0xD28FFB40, 0xD290FB40, 0xD291FB40, 0xD292FB40, 0xD293FB40, 0xD294FB40, 0xD295FB40, 0xD296FB40, 0xD297FB40, 0xD298FB40, 0xD299FB40, 0xD29AFB40, 0xD29BFB40, 0xD29CFB40, 0xD29DFB40, 0xD29EFB40, 0xD29FFB40, 0xD2A0FB40, 0xD2A1FB40, 0xD2A2FB40, 0xD2A3FB40, 0xD2A4FB40, 0xD2A5FB40, 0xD2A6FB40, 0xD2A7FB40, 0xD2A8FB40, 0xD2A9FB40, 0xD2AAFB40, 0xD2ABFB40, 0xD2ACFB40, 0xD2ADFB40, 0xD2AEFB40, 0xD2AFFB40, 0xD2B0FB40, 0xD2B1FB40, 0xD2B2FB40, 0xD2B3FB40, 0xD2B4FB40, 0xD2B5FB40, 0xD2B6FB40, 0xD2B7FB40, 0xD2B8FB40, 0xD2B9FB40, 0xD2BAFB40, 0xD2BBFB40, 0xD2BCFB40, 0xD2BDFB40, 0xD2BEFB40, 0xD2BFFB40, 0xD2C0FB40, 0xD2C1FB40, /* 5218 */
+ 0xD2C2FB40, 0xD2C3FB40, 0xD2C4FB40, 0xD2C5FB40, 0xD2C6FB40, 0xD2C7FB40, 0xD2C8FB40, 0xD2C9FB40, 0xD2CAFB40, 0xD2CBFB40, 0xD2CCFB40, 0xD2CDFB40, 0xD2CEFB40, 0xD2CFFB40, 0xD2D0FB40, 0xD2D1FB40, 0xD2D2FB40, 0xD2D3FB40, 0xD2D4FB40, 0xD2D5FB40, 0xD2D6FB40, 0xD2D7FB40, 0xD2D8FB40, 0xD2D9FB40, 0xD2DAFB40, 0xD2DBFB40, 0xD2DCFB40, 0xD2DDFB40, 0xD2DEFB40, 0xD2DFFB40, 0xD2E0FB40, 0xD2E1FB40, 0xD2E2FB40, 0xD2E3FB40, 0xD2E4FB40, 0xD2E5FB40, 0xD2E6FB40, 0xD2E7FB40, 0xD2E8FB40, 0xD2E9FB40, 0xD2EAFB40, 0xD2EBFB40, 0xD2ECFB40, 0xD2EDFB40, 0xD2EEFB40, 0xD2EFFB40, 0xD2F0FB40, 0xD2F1FB40, 0xD2F2FB40, 0xD2F3FB40, 0xD2F4FB40, 0xD2F5FB40, 0xD2F6FB40, 0xD2F7FB40, 0xD2F8FB40, 0xD2F9FB40, 0xD2FAFB40, 0xD2FBFB40, 0xD2FCFB40, 0xD2FDFB40, 0xD2FEFB40, 0xD2FFFB40, 0xD300FB40, 0xD301FB40, 0xD302FB40, 0xD303FB40, 0xD304FB40, 0xD305FB40, 0xD306FB40, 0xD307FB40, 0xD308FB40, 0xD309FB40, 0xD30AFB40, 0xD30BFB40, 0xD30CFB40, 0xD30DFB40, 0xD30EFB40, 0xD30FFB40, 0xD310FB40, 0xD311FB40, 0xD312FB40, 0xD313FB40, 0xD314FB40, 0xD315FB40, 0xD316FB40, 0xD317FB40, 0xD318FB40, 0xD319FB40, 0xD31AFB40, 0xD31BFB40, 0xD31CFB40, 0xD31DFB40, 0xD31EFB40, 0xD31FFB40, 0xD320FB40, 0xD321FB40, 0xD322FB40, 0xD323FB40, 0xD324FB40, 0xD325FB40, 0xD326FB40, 0xD327FB40, 0xD328FB40, 0xD329FB40, 0xD32AFB40, 0xD32BFB40, 0xD32CFB40, 0xD32DFB40, 0xD32EFB40, 0xD32FFB40, 0xD330FB40, 0xD331FB40, 0xD332FB40, 0xD333FB40, 0xD334FB40, 0xD335FB40, 0xD336FB40, 0xD337FB40, 0xD338FB40, 0xD339FB40, 0xD33AFB40, 0xD33BFB40, 0xD33CFB40, 0xD33DFB40, 0xD33EFB40, 0xD33FFB40, 0xD340FB40, 0xD341FB40, 0xD342FB40, 0xD343FB40, 0xD344FB40, 0xD345FB40, 0xD346FB40, 0xD347FB40, 0xD348FB40, 0xD349FB40, 0xD34AFB40, 0xD34BFB40, 0xD34CFB40, 0xD34DFB40, 0xD34EFB40, 0xD34FFB40, 0xD350FB40, 0xD351FB40, 0xD352FB40, 0xD353FB40, 0xD354FB40, 0xD355FB40, 0xD356FB40, 0xD357FB40, 0xD358FB40, 0xD359FB40, 0xD35AFB40, 0xD35BFB40, 0xD35CFB40, 0xD35DFB40, 0xD35EFB40, 0xD35FFB40, 0xD360FB40, 0xD361FB40, 0xD362FB40, 0xD363FB40, 0xD364FB40, 0xD365FB40, 0xD366FB40, 0xD367FB40, 0xD368FB40, 0xD369FB40, 0xD36AFB40, 0xD36BFB40, /* 52C2 */
+ 0xD36CFB40, 0xD36DFB40, 0xD36EFB40, 0xD36FFB40, 0xD370FB40, 0xD371FB40, 0xD372FB40, 0xD373FB40, 0xD374FB40, 0xD375FB40, 0xD376FB40, 0xD377FB40, 0xD378FB40, 0xD379FB40, 0xD37AFB40, 0xD37BFB40, 0xD37CFB40, 0xD37DFB40, 0xD37EFB40, 0xD37FFB40, 0xD380FB40, 0xD381FB40, 0xD382FB40, 0xD383FB40, 0xD384FB40, 0xD385FB40, 0xD386FB40, 0xD387FB40, 0xD388FB40, 0xD389FB40, 0xD38AFB40, 0xD38BFB40, 0xD38CFB40, 0xD38DFB40, 0xD38EFB40, 0xD38FFB40, 0xD390FB40, 0xD391FB40, 0xD392FB40, 0xD393FB40, 0xD394FB40, 0xD395FB40, 0xD396FB40, 0xD397FB40, 0xD398FB40, 0xD399FB40, 0xD39AFB40, 0xD39BFB40, 0xD39CFB40, 0xD39DFB40, 0xD39EFB40, 0xD39FFB40, 0xD3A0FB40, 0xD3A1FB40, 0xD3A2FB40, 0xD3A3FB40, 0xD3A4FB40, 0xD3A5FB40, 0xD3A6FB40, 0xD3A7FB40, 0xD3A8FB40, 0xD3A9FB40, 0xD3AAFB40, 0xD3ABFB40, 0xD3ACFB40, 0xD3ADFB40, 0xD3AEFB40, 0xD3AFFB40, 0xD3B0FB40, 0xD3B1FB40, 0xD3B2FB40, 0xD3B3FB40, 0xD3B4FB40, 0xD3B5FB40, 0xD3B6FB40, 0xD3B7FB40, 0xD3B8FB40, 0xD3B9FB40, 0xD3BAFB40, 0xD3BBFB40, 0xD3BCFB40, 0xD3BDFB40, 0xD3BEFB40, 0xD3BFFB40, 0xD3C0FB40, 0xD3C1FB40, 0xD3C2FB40, 0xD3C3FB40, 0xD3C4FB40, 0xD3C5FB40, 0xD3C6FB40, 0xD3C7FB40, 0xD3C8FB40, 0xD3C9FB40, 0xD3CAFB40, 0xD3CBFB40, 0xD3CCFB40, 0xD3CDFB40, 0xD3CEFB40, 0xD3CFFB40, 0xD3D0FB40, 0xD3D1FB40, 0xD3D2FB40, 0xD3D3FB40, 0xD3D4FB40, 0xD3D5FB40, 0xD3D6FB40, 0xD3D7FB40, 0xD3D8FB40, 0xD3D9FB40, 0xD3DAFB40, 0xD3DBFB40, 0xD3DCFB40, 0xD3DDFB40, 0xD3DEFB40, 0xD3DFFB40, 0xD3E0FB40, 0xD3E1FB40, 0xD3E2FB40, 0xD3E3FB40, 0xD3E4FB40, 0xD3E5FB40, 0xD3E6FB40, 0xD3E7FB40, 0xD3E8FB40, 0xD3E9FB40, 0xD3EAFB40, 0xD3EBFB40, 0xD3ECFB40, 0xD3EDFB40, 0xD3EEFB40, 0xD3EFFB40, 0xD3F0FB40, 0xD3F1FB40, 0xD3F2FB40, 0xD3F3FB40, 0xD3F4FB40, 0xD3F5FB40, 0xD3F6FB40, 0xD3F7FB40, 0xD3F8FB40, 0xD3F9FB40, 0xD3FAFB40, 0xD3FBFB40, 0xD3FCFB40, 0xD3FDFB40, 0xD3FEFB40, 0xD3FFFB40, 0xD400FB40, 0xD401FB40, 0xD402FB40, 0xD403FB40, 0xD404FB40, 0xD405FB40, 0xD406FB40, 0xD407FB40, 0xD408FB40, 0xD409FB40, 0xD40AFB40, 0xD40BFB40, 0xD40CFB40, 0xD40DFB40, 0xD40EFB40, 0xD40FFB40, 0xD410FB40, 0xD411FB40, 0xD412FB40, 0xD413FB40, 0xD414FB40, 0xD415FB40, /* 536C */
+ 0xD416FB40, 0xD417FB40, 0xD418FB40, 0xD419FB40, 0xD41AFB40, 0xD41BFB40, 0xD41CFB40, 0xD41DFB40, 0xD41EFB40, 0xD41FFB40, 0xD420FB40, 0xD421FB40, 0xD422FB40, 0xD423FB40, 0xD424FB40, 0xD425FB40, 0xD426FB40, 0xD427FB40, 0xD428FB40, 0xD429FB40, 0xD42AFB40, 0xD42BFB40, 0xD42CFB40, 0xD42DFB40, 0xD42EFB40, 0xD42FFB40, 0xD430FB40, 0xD431FB40, 0xD432FB40, 0xD433FB40, 0xD434FB40, 0xD435FB40, 0xD436FB40, 0xD437FB40, 0xD438FB40, 0xD439FB40, 0xD43AFB40, 0xD43BFB40, 0xD43CFB40, 0xD43DFB40, 0xD43EFB40, 0xD43FFB40, 0xD440FB40, 0xD441FB40, 0xD442FB40, 0xD443FB40, 0xD444FB40, 0xD445FB40, 0xD446FB40, 0xD447FB40, 0xD448FB40, 0xD449FB40, 0xD44AFB40, 0xD44BFB40, 0xD44CFB40, 0xD44DFB40, 0xD44EFB40, 0xD44FFB40, 0xD450FB40, 0xD451FB40, 0xD452FB40, 0xD453FB40, 0xD454FB40, 0xD455FB40, 0xD456FB40, 0xD457FB40, 0xD458FB40, 0xD459FB40, 0xD45AFB40, 0xD45BFB40, 0xD45CFB40, 0xD45DFB40, 0xD45EFB40, 0xD45FFB40, 0xD460FB40, 0xD461FB40, 0xD462FB40, 0xD463FB40, 0xD464FB40, 0xD465FB40, 0xD466FB40, 0xD467FB40, 0xD468FB40, 0xD469FB40, 0xD46AFB40, 0xD46BFB40, 0xD46CFB40, 0xD46DFB40, 0xD46EFB40, 0xD46FFB40, 0xD470FB40, 0xD471FB40, 0xD472FB40, 0xD473FB40, 0xD474FB40, 0xD475FB40, 0xD476FB40, 0xD477FB40, 0xD478FB40, 0xD479FB40, 0xD47AFB40, 0xD47BFB40, 0xD47CFB40, 0xD47DFB40, 0xD47EFB40, 0xD47FFB40, 0xD480FB40, 0xD481FB40, 0xD482FB40, 0xD483FB40, 0xD484FB40, 0xD485FB40, 0xD486FB40, 0xD487FB40, 0xD488FB40, 0xD489FB40, 0xD48AFB40, 0xD48BFB40, 0xD48CFB40, 0xD48DFB40, 0xD48EFB40, 0xD48FFB40, 0xD490FB40, 0xD491FB40, 0xD492FB40, 0xD493FB40, 0xD494FB40, 0xD495FB40, 0xD496FB40, 0xD497FB40, 0xD498FB40, 0xD499FB40, 0xD49AFB40, 0xD49BFB40, 0xD49CFB40, 0xD49DFB40, 0xD49EFB40, 0xD49FFB40, 0xD4A0FB40, 0xD4A1FB40, 0xD4A2FB40, 0xD4A3FB40, 0xD4A4FB40, 0xD4A5FB40, 0xD4A6FB40, 0xD4A7FB40, 0xD4A8FB40, 0xD4A9FB40, 0xD4AAFB40, 0xD4ABFB40, 0xD4ACFB40, 0xD4ADFB40, 0xD4AEFB40, 0xD4AFFB40, 0xD4B0FB40, 0xD4B1FB40, 0xD4B2FB40, 0xD4B3FB40, 0xD4B4FB40, 0xD4B5FB40, 0xD4B6FB40, 0xD4B7FB40, 0xD4B8FB40, 0xD4B9FB40, 0xD4BAFB40, 0xD4BBFB40, 0xD4BCFB40, 0xD4BDFB40, 0xD4BEFB40, 0xD4BFFB40, /* 5416 */
+ 0xD4C0FB40, 0xD4C1FB40, 0xD4C2FB40, 0xD4C3FB40, 0xD4C4FB40, 0xD4C5FB40, 0xD4C6FB40, 0xD4C7FB40, 0xD4C8FB40, 0xD4C9FB40, 0xD4CAFB40, 0xD4CBFB40, 0xD4CCFB40, 0xD4CDFB40, 0xD4CEFB40, 0xD4CFFB40, 0xD4D0FB40, 0xD4D1FB40, 0xD4D2FB40, 0xD4D3FB40, 0xD4D4FB40, 0xD4D5FB40, 0xD4D6FB40, 0xD4D7FB40, 0xD4D8FB40, 0xD4D9FB40, 0xD4DAFB40, 0xD4DBFB40, 0xD4DCFB40, 0xD4DDFB40, 0xD4DEFB40, 0xD4DFFB40, 0xD4E0FB40, 0xD4E1FB40, 0xD4E2FB40, 0xD4E3FB40, 0xD4E4FB40, 0xD4E5FB40, 0xD4E6FB40, 0xD4E7FB40, 0xD4E8FB40, 0xD4E9FB40, 0xD4EAFB40, 0xD4EBFB40, 0xD4ECFB40, 0xD4EDFB40, 0xD4EEFB40, 0xD4EFFB40, 0xD4F0FB40, 0xD4F1FB40, 0xD4F2FB40, 0xD4F3FB40, 0xD4F4FB40, 0xD4F5FB40, 0xD4F6FB40, 0xD4F7FB40, 0xD4F8FB40, 0xD4F9FB40, 0xD4FAFB40, 0xD4FBFB40, 0xD4FCFB40, 0xD4FDFB40, 0xD4FEFB40, 0xD4FFFB40, 0xD500FB40, 0xD501FB40, 0xD502FB40, 0xD503FB40, 0xD504FB40, 0xD505FB40, 0xD506FB40, 0xD507FB40, 0xD508FB40, 0xD509FB40, 0xD50AFB40, 0xD50BFB40, 0xD50CFB40, 0xD50DFB40, 0xD50EFB40, 0xD50FFB40, 0xD510FB40, 0xD511FB40, 0xD512FB40, 0xD513FB40, 0xD514FB40, 0xD515FB40, 0xD516FB40, 0xD517FB40, 0xD518FB40, 0xD519FB40, 0xD51AFB40, 0xD51BFB40, 0xD51CFB40, 0xD51DFB40, 0xD51EFB40, 0xD51FFB40, 0xD520FB40, 0xD521FB40, 0xD522FB40, 0xD523FB40, 0xD524FB40, 0xD525FB40, 0xD526FB40, 0xD527FB40, 0xD528FB40, 0xD529FB40, 0xD52AFB40, 0xD52BFB40, 0xD52CFB40, 0xD52DFB40, 0xD52EFB40, 0xD52FFB40, 0xD530FB40, 0xD531FB40, 0xD532FB40, 0xD533FB40, 0xD534FB40, 0xD535FB40, 0xD536FB40, 0xD537FB40, 0xD538FB40, 0xD539FB40, 0xD53AFB40, 0xD53BFB40, 0xD53CFB40, 0xD53DFB40, 0xD53EFB40, 0xD53FFB40, 0xD540FB40, 0xD541FB40, 0xD542FB40, 0xD543FB40, 0xD544FB40, 0xD545FB40, 0xD546FB40, 0xD547FB40, 0xD548FB40, 0xD549FB40, 0xD54AFB40, 0xD54BFB40, 0xD54CFB40, 0xD54DFB40, 0xD54EFB40, 0xD54FFB40, 0xD550FB40, 0xD551FB40, 0xD552FB40, 0xD553FB40, 0xD554FB40, 0xD555FB40, 0xD556FB40, 0xD557FB40, 0xD558FB40, 0xD559FB40, 0xD55AFB40, 0xD55BFB40, 0xD55CFB40, 0xD55DFB40, 0xD55EFB40, 0xD55FFB40, 0xD560FB40, 0xD561FB40, 0xD562FB40, 0xD563FB40, 0xD564FB40, 0xD565FB40, 0xD566FB40, 0xD567FB40, 0xD568FB40, 0xD569FB40, /* 54C0 */
+ 0xD56AFB40, 0xD56BFB40, 0xD56CFB40, 0xD56DFB40, 0xD56EFB40, 0xD56FFB40, 0xD570FB40, 0xD571FB40, 0xD572FB40, 0xD573FB40, 0xD574FB40, 0xD575FB40, 0xD576FB40, 0xD577FB40, 0xD578FB40, 0xD579FB40, 0xD57AFB40, 0xD57BFB40, 0xD57CFB40, 0xD57DFB40, 0xD57EFB40, 0xD57FFB40, 0xD580FB40, 0xD581FB40, 0xD582FB40, 0xD583FB40, 0xD584FB40, 0xD585FB40, 0xD586FB40, 0xD587FB40, 0xD588FB40, 0xD589FB40, 0xD58AFB40, 0xD58BFB40, 0xD58CFB40, 0xD58DFB40, 0xD58EFB40, 0xD58FFB40, 0xD590FB40, 0xD591FB40, 0xD592FB40, 0xD593FB40, 0xD594FB40, 0xD595FB40, 0xD596FB40, 0xD597FB40, 0xD598FB40, 0xD599FB40, 0xD59AFB40, 0xD59BFB40, 0xD59CFB40, 0xD59DFB40, 0xD59EFB40, 0xD59FFB40, 0xD5A0FB40, 0xD5A1FB40, 0xD5A2FB40, 0xD5A3FB40, 0xD5A4FB40, 0xD5A5FB40, 0xD5A6FB40, 0xD5A7FB40, 0xD5A8FB40, 0xD5A9FB40, 0xD5AAFB40, 0xD5ABFB40, 0xD5ACFB40, 0xD5ADFB40, 0xD5AEFB40, 0xD5AFFB40, 0xD5B0FB40, 0xD5B1FB40, 0xD5B2FB40, 0xD5B3FB40, 0xD5B4FB40, 0xD5B5FB40, 0xD5B6FB40, 0xD5B7FB40, 0xD5B8FB40, 0xD5B9FB40, 0xD5BAFB40, 0xD5BBFB40, 0xD5BCFB40, 0xD5BDFB40, 0xD5BEFB40, 0xD5BFFB40, 0xD5C0FB40, 0xD5C1FB40, 0xD5C2FB40, 0xD5C3FB40, 0xD5C4FB40, 0xD5C5FB40, 0xD5C6FB40, 0xD5C7FB40, 0xD5C8FB40, 0xD5C9FB40, 0xD5CAFB40, 0xD5CBFB40, 0xD5CCFB40, 0xD5CDFB40, 0xD5CEFB40, 0xD5CFFB40, 0xD5D0FB40, 0xD5D1FB40, 0xD5D2FB40, 0xD5D3FB40, 0xD5D4FB40, 0xD5D5FB40, 0xD5D6FB40, 0xD5D7FB40, 0xD5D8FB40, 0xD5D9FB40, 0xD5DAFB40, 0xD5DBFB40, 0xD5DCFB40, 0xD5DDFB40, 0xD5DEFB40, 0xD5DFFB40, 0xD5E0FB40, 0xD5E1FB40, 0xD5E2FB40, 0xD5E3FB40, 0xD5E4FB40, 0xD5E5FB40, 0xD5E6FB40, 0xD5E7FB40, 0xD5E8FB40, 0xD5E9FB40, 0xD5EAFB40, 0xD5EBFB40, 0xD5ECFB40, 0xD5EDFB40, 0xD5EEFB40, 0xD5EFFB40, 0xD5F0FB40, 0xD5F1FB40, 0xD5F2FB40, 0xD5F3FB40, 0xD5F4FB40, 0xD5F5FB40, 0xD5F6FB40, 0xD5F7FB40, 0xD5F8FB40, 0xD5F9FB40, 0xD5FAFB40, 0xD5FBFB40, 0xD5FCFB40, 0xD5FDFB40, 0xD5FEFB40, 0xD5FFFB40, 0xD600FB40, 0xD601FB40, 0xD602FB40, 0xD603FB40, 0xD604FB40, 0xD605FB40, 0xD606FB40, 0xD607FB40, 0xD608FB40, 0xD609FB40, 0xD60AFB40, 0xD60BFB40, 0xD60CFB40, 0xD60DFB40, 0xD60EFB40, 0xD60FFB40, 0xD610FB40, 0xD611FB40, 0xD612FB40, 0xD613FB40, /* 556A */
+ 0xD614FB40, 0xD615FB40, 0xD616FB40, 0xD617FB40, 0xD618FB40, 0xD619FB40, 0xD61AFB40, 0xD61BFB40, 0xD61CFB40, 0xD61DFB40, 0xD61EFB40, 0xD61FFB40, 0xD620FB40, 0xD621FB40, 0xD622FB40, 0xD623FB40, 0xD624FB40, 0xD625FB40, 0xD626FB40, 0xD627FB40, 0xD628FB40, 0xD629FB40, 0xD62AFB40, 0xD62BFB40, 0xD62CFB40, 0xD62DFB40, 0xD62EFB40, 0xD62FFB40, 0xD630FB40, 0xD631FB40, 0xD632FB40, 0xD633FB40, 0xD634FB40, 0xD635FB40, 0xD636FB40, 0xD637FB40, 0xD638FB40, 0xD639FB40, 0xD63AFB40, 0xD63BFB40, 0xD63CFB40, 0xD63DFB40, 0xD63EFB40, 0xD63FFB40, 0xD640FB40, 0xD641FB40, 0xD642FB40, 0xD643FB40, 0xD644FB40, 0xD645FB40, 0xD646FB40, 0xD647FB40, 0xD648FB40, 0xD649FB40, 0xD64AFB40, 0xD64BFB40, 0xD64CFB40, 0xD64DFB40, 0xD64EFB40, 0xD64FFB40, 0xD650FB40, 0xD651FB40, 0xD652FB40, 0xD653FB40, 0xD654FB40, 0xD655FB40, 0xD656FB40, 0xD657FB40, 0xD658FB40, 0xD659FB40, 0xD65AFB40, 0xD65BFB40, 0xD65CFB40, 0xD65DFB40, 0xD65EFB40, 0xD65FFB40, 0xD660FB40, 0xD661FB40, 0xD662FB40, 0xD663FB40, 0xD664FB40, 0xD665FB40, 0xD666FB40, 0xD667FB40, 0xD668FB40, 0xD669FB40, 0xD66AFB40, 0xD66BFB40, 0xD66CFB40, 0xD66DFB40, 0xD66EFB40, 0xD66FFB40, 0xD670FB40, 0xD671FB40, 0xD672FB40, 0xD673FB40, 0xD674FB40, 0xD675FB40, 0xD676FB40, 0xD677FB40, 0xD678FB40, 0xD679FB40, 0xD67AFB40, 0xD67BFB40, 0xD67CFB40, 0xD67DFB40, 0xD67EFB40, 0xD67FFB40, 0xD680FB40, 0xD681FB40, 0xD682FB40, 0xD683FB40, 0xD684FB40, 0xD685FB40, 0xD686FB40, 0xD687FB40, 0xD688FB40, 0xD689FB40, 0xD68AFB40, 0xD68BFB40, 0xD68CFB40, 0xD68DFB40, 0xD68EFB40, 0xD68FFB40, 0xD690FB40, 0xD691FB40, 0xD692FB40, 0xD693FB40, 0xD694FB40, 0xD695FB40, 0xD696FB40, 0xD697FB40, 0xD698FB40, 0xD699FB40, 0xD69AFB40, 0xD69BFB40, 0xD69CFB40, 0xD69DFB40, 0xD69EFB40, 0xD69FFB40, 0xD6A0FB40, 0xD6A1FB40, 0xD6A2FB40, 0xD6A3FB40, 0xD6A4FB40, 0xD6A5FB40, 0xD6A6FB40, 0xD6A7FB40, 0xD6A8FB40, 0xD6A9FB40, 0xD6AAFB40, 0xD6ABFB40, 0xD6ACFB40, 0xD6ADFB40, 0xD6AEFB40, 0xD6AFFB40, 0xD6B0FB40, 0xD6B1FB40, 0xD6B2FB40, 0xD6B3FB40, 0xD6B4FB40, 0xD6B5FB40, 0xD6B6FB40, 0xD6B7FB40, 0xD6B8FB40, 0xD6B9FB40, 0xD6BAFB40, 0xD6BBFB40, 0xD6BCFB40, 0xD6BDFB40, /* 5614 */
+ 0xD6BEFB40, 0xD6BFFB40, 0xD6C0FB40, 0xD6C1FB40, 0xD6C2FB40, 0xD6C3FB40, 0xD6C4FB40, 0xD6C5FB40, 0xD6C6FB40, 0xD6C7FB40, 0xD6C8FB40, 0xD6C9FB40, 0xD6CAFB40, 0xD6CBFB40, 0xD6CCFB40, 0xD6CDFB40, 0xD6CEFB40, 0xD6CFFB40, 0xD6D0FB40, 0xD6D1FB40, 0xD6D2FB40, 0xD6D3FB40, 0xD6D4FB40, 0xD6D5FB40, 0xD6D6FB40, 0xD6D7FB40, 0xD6D8FB40, 0xD6D9FB40, 0xD6DAFB40, 0xD6DBFB40, 0xD6DCFB40, 0xD6DDFB40, 0xD6DEFB40, 0xD6DFFB40, 0xD6E0FB40, 0xD6E1FB40, 0xD6E2FB40, 0xD6E3FB40, 0xD6E4FB40, 0xD6E5FB40, 0xD6E6FB40, 0xD6E7FB40, 0xD6E8FB40, 0xD6E9FB40, 0xD6EAFB40, 0xD6EBFB40, 0xD6ECFB40, 0xD6EDFB40, 0xD6EEFB40, 0xD6EFFB40, 0xD6F0FB40, 0xD6F1FB40, 0xD6F2FB40, 0xD6F3FB40, 0xD6F4FB40, 0xD6F5FB40, 0xD6F6FB40, 0xD6F7FB40, 0xD6F8FB40, 0xD6F9FB40, 0xD6FAFB40, 0xD6FBFB40, 0xD6FCFB40, 0xD6FDFB40, 0xD6FEFB40, 0xD6FFFB40, 0xD700FB40, 0xD701FB40, 0xD702FB40, 0xD703FB40, 0xD704FB40, 0xD705FB40, 0xD706FB40, 0xD707FB40, 0xD708FB40, 0xD709FB40, 0xD70AFB40, 0xD70BFB40, 0xD70CFB40, 0xD70DFB40, 0xD70EFB40, 0xD70FFB40, 0xD710FB40, 0xD711FB40, 0xD712FB40, 0xD713FB40, 0xD714FB40, 0xD715FB40, 0xD716FB40, 0xD717FB40, 0xD718FB40, 0xD719FB40, 0xD71AFB40, 0xD71BFB40, 0xD71CFB40, 0xD71DFB40, 0xD71EFB40, 0xD71FFB40, 0xD720FB40, 0xD721FB40, 0xD722FB40, 0xD723FB40, 0xD724FB40, 0xD725FB40, 0xD726FB40, 0xD727FB40, 0xD728FB40, 0xD729FB40, 0xD72AFB40, 0xD72BFB40, 0xD72CFB40, 0xD72DFB40, 0xD72EFB40, 0xD72FFB40, 0xD730FB40, 0xD731FB40, 0xD732FB40, 0xD733FB40, 0xD734FB40, 0xD735FB40, 0xD736FB40, 0xD737FB40, 0xD738FB40, 0xD739FB40, 0xD73AFB40, 0xD73BFB40, 0xD73CFB40, 0xD73DFB40, 0xD73EFB40, 0xD73FFB40, 0xD740FB40, 0xD741FB40, 0xD742FB40, 0xD743FB40, 0xD744FB40, 0xD745FB40, 0xD746FB40, 0xD747FB40, 0xD748FB40, 0xD749FB40, 0xD74AFB40, 0xD74BFB40, 0xD74CFB40, 0xD74DFB40, 0xD74EFB40, 0xD74FFB40, 0xD750FB40, 0xD751FB40, 0xD752FB40, 0xD753FB40, 0xD754FB40, 0xD755FB40, 0xD756FB40, 0xD757FB40, 0xD758FB40, 0xD759FB40, 0xD75AFB40, 0xD75BFB40, 0xD75CFB40, 0xD75DFB40, 0xD75EFB40, 0xD75FFB40, 0xD760FB40, 0xD761FB40, 0xD762FB40, 0xD763FB40, 0xD764FB40, 0xD765FB40, 0xD766FB40, 0xD767FB40, /* 56BE */
+ 0xD768FB40, 0xD769FB40, 0xD76AFB40, 0xD76BFB40, 0xD76CFB40, 0xD76DFB40, 0xD76EFB40, 0xD76FFB40, 0xD770FB40, 0xD771FB40, 0xD772FB40, 0xD773FB40, 0xD774FB40, 0xD775FB40, 0xD776FB40, 0xD777FB40, 0xD778FB40, 0xD779FB40, 0xD77AFB40, 0xD77BFB40, 0xD77CFB40, 0xD77DFB40, 0xD77EFB40, 0xD77FFB40, 0xD780FB40, 0xD781FB40, 0xD782FB40, 0xD783FB40, 0xD784FB40, 0xD785FB40, 0xD786FB40, 0xD787FB40, 0xD788FB40, 0xD789FB40, 0xD78AFB40, 0xD78BFB40, 0xD78CFB40, 0xD78DFB40, 0xD78EFB40, 0xD78FFB40, 0xD790FB40, 0xD791FB40, 0xD792FB40, 0xD793FB40, 0xD794FB40, 0xD795FB40, 0xD796FB40, 0xD797FB40, 0xD798FB40, 0xD799FB40, 0xD79AFB40, 0xD79BFB40, 0xD79CFB40, 0xD79DFB40, 0xD79EFB40, 0xD79FFB40, 0xD7A0FB40, 0xD7A1FB40, 0xD7A2FB40, 0xD7A3FB40, 0xD7A4FB40, 0xD7A5FB40, 0xD7A6FB40, 0xD7A7FB40, 0xD7A8FB40, 0xD7A9FB40, 0xD7AAFB40, 0xD7ABFB40, 0xD7ACFB40, 0xD7ADFB40, 0xD7AEFB40, 0xD7AFFB40, 0xD7B0FB40, 0xD7B1FB40, 0xD7B2FB40, 0xD7B3FB40, 0xD7B4FB40, 0xD7B5FB40, 0xD7B6FB40, 0xD7B7FB40, 0xD7B8FB40, 0xD7B9FB40, 0xD7BAFB40, 0xD7BBFB40, 0xD7BCFB40, 0xD7BDFB40, 0xD7BEFB40, 0xD7BFFB40, 0xD7C0FB40, 0xD7C1FB40, 0xD7C2FB40, 0xD7C3FB40, 0xD7C4FB40, 0xD7C5FB40, 0xD7C6FB40, 0xD7C7FB40, 0xD7C8FB40, 0xD7C9FB40, 0xD7CAFB40, 0xD7CBFB40, 0xD7CCFB40, 0xD7CDFB40, 0xD7CEFB40, 0xD7CFFB40, 0xD7D0FB40, 0xD7D1FB40, 0xD7D2FB40, 0xD7D3FB40, 0xD7D4FB40, 0xD7D5FB40, 0xD7D6FB40, 0xD7D7FB40, 0xD7D8FB40, 0xD7D9FB40, 0xD7DAFB40, 0xD7DBFB40, 0xD7DCFB40, 0xD7DDFB40, 0xD7DEFB40, 0xD7DFFB40, 0xD7E0FB40, 0xD7E1FB40, 0xD7E2FB40, 0xD7E3FB40, 0xD7E4FB40, 0xD7E5FB40, 0xD7E6FB40, 0xD7E7FB40, 0xD7E8FB40, 0xD7E9FB40, 0xD7EAFB40, 0xD7EBFB40, 0xD7ECFB40, 0xD7EDFB40, 0xD7EEFB40, 0xD7EFFB40, 0xD7F0FB40, 0xD7F1FB40, 0xD7F2FB40, 0xD7F3FB40, 0xD7F4FB40, 0xD7F5FB40, 0xD7F6FB40, 0xD7F7FB40, 0xD7F8FB40, 0xD7F9FB40, 0xD7FAFB40, 0xD7FBFB40, 0xD7FCFB40, 0xD7FDFB40, 0xD7FEFB40, 0xD7FFFB40, 0xD800FB40, 0xD801FB40, 0xD802FB40, 0xD803FB40, 0xD804FB40, 0xD805FB40, 0xD806FB40, 0xD807FB40, 0xD808FB40, 0xD809FB40, 0xD80AFB40, 0xD80BFB40, 0xD80CFB40, 0xD80DFB40, 0xD80EFB40, 0xD80FFB40, 0xD810FB40, 0xD811FB40, /* 5768 */
+ 0xD812FB40, 0xD813FB40, 0xD814FB40, 0xD815FB40, 0xD816FB40, 0xD817FB40, 0xD818FB40, 0xD819FB40, 0xD81AFB40, 0xD81BFB40, 0xD81CFB40, 0xD81DFB40, 0xD81EFB40, 0xD81FFB40, 0xD820FB40, 0xD821FB40, 0xD822FB40, 0xD823FB40, 0xD824FB40, 0xD825FB40, 0xD826FB40, 0xD827FB40, 0xD828FB40, 0xD829FB40, 0xD82AFB40, 0xD82BFB40, 0xD82CFB40, 0xD82DFB40, 0xD82EFB40, 0xD82FFB40, 0xD830FB40, 0xD831FB40, 0xD832FB40, 0xD833FB40, 0xD834FB40, 0xD835FB40, 0xD836FB40, 0xD837FB40, 0xD838FB40, 0xD839FB40, 0xD83AFB40, 0xD83BFB40, 0xD83CFB40, 0xD83DFB40, 0xD83EFB40, 0xD83FFB40, 0xD840FB40, 0xD841FB40, 0xD842FB40, 0xD843FB40, 0xD844FB40, 0xD845FB40, 0xD846FB40, 0xD847FB40, 0xD848FB40, 0xD849FB40, 0xD84AFB40, 0xD84BFB40, 0xD84CFB40, 0xD84DFB40, 0xD84EFB40, 0xD84FFB40, 0xD850FB40, 0xD851FB40, 0xD852FB40, 0xD853FB40, 0xD854FB40, 0xD855FB40, 0xD856FB40, 0xD857FB40, 0xD858FB40, 0xD859FB40, 0xD85AFB40, 0xD85BFB40, 0xD85CFB40, 0xD85DFB40, 0xD85EFB40, 0xD85FFB40, 0xD860FB40, 0xD861FB40, 0xD862FB40, 0xD863FB40, 0xD864FB40, 0xD865FB40, 0xD866FB40, 0xD867FB40, 0xD868FB40, 0xD869FB40, 0xD86AFB40, 0xD86BFB40, 0xD86CFB40, 0xD86DFB40, 0xD86EFB40, 0xD86FFB40, 0xD870FB40, 0xD871FB40, 0xD872FB40, 0xD873FB40, 0xD874FB40, 0xD875FB40, 0xD876FB40, 0xD877FB40, 0xD878FB40, 0xD879FB40, 0xD87AFB40, 0xD87BFB40, 0xD87CFB40, 0xD87DFB40, 0xD87EFB40, 0xD87FFB40, 0xD880FB40, 0xD881FB40, 0xD882FB40, 0xD883FB40, 0xD884FB40, 0xD885FB40, 0xD886FB40, 0xD887FB40, 0xD888FB40, 0xD889FB40, 0xD88AFB40, 0xD88BFB40, 0xD88CFB40, 0xD88DFB40, 0xD88EFB40, 0xD88FFB40, 0xD890FB40, 0xD891FB40, 0xD892FB40, 0xD893FB40, 0xD894FB40, 0xD895FB40, 0xD896FB40, 0xD897FB40, 0xD898FB40, 0xD899FB40, 0xD89AFB40, 0xD89BFB40, 0xD89CFB40, 0xD89DFB40, 0xD89EFB40, 0xD89FFB40, 0xD8A0FB40, 0xD8A1FB40, 0xD8A2FB40, 0xD8A3FB40, 0xD8A4FB40, 0xD8A5FB40, 0xD8A6FB40, 0xD8A7FB40, 0xD8A8FB40, 0xD8A9FB40, 0xD8AAFB40, 0xD8ABFB40, 0xD8ACFB40, 0xD8ADFB40, 0xD8AEFB40, 0xD8AFFB40, 0xD8B0FB40, 0xD8B1FB40, 0xD8B2FB40, 0xD8B3FB40, 0xD8B4FB40, 0xD8B5FB40, 0xD8B6FB40, 0xD8B7FB40, 0xD8B8FB40, 0xD8B9FB40, 0xD8BAFB40, 0xD8BBFB40, /* 5812 */
+ 0xD8BCFB40, 0xD8BDFB40, 0xD8BEFB40, 0xD8BFFB40, 0xD8C0FB40, 0xD8C1FB40, 0xD8C2FB40, 0xD8C3FB40, 0xD8C4FB40, 0xD8C5FB40, 0xD8C6FB40, 0xD8C7FB40, 0xD8C8FB40, 0xD8C9FB40, 0xD8CAFB40, 0xD8CBFB40, 0xD8CCFB40, 0xD8CDFB40, 0xD8CEFB40, 0xD8CFFB40, 0xD8D0FB40, 0xD8D1FB40, 0xD8D2FB40, 0xD8D3FB40, 0xD8D4FB40, 0xD8D5FB40, 0xD8D6FB40, 0xD8D7FB40, 0xD8D8FB40, 0xD8D9FB40, 0xD8DAFB40, 0xD8DBFB40, 0xD8DCFB40, 0xD8DDFB40, 0xD8DEFB40, 0xD8DFFB40, 0xD8E0FB40, 0xD8E1FB40, 0xD8E2FB40, 0xD8E3FB40, 0xD8E4FB40, 0xD8E5FB40, 0xD8E6FB40, 0xD8E7FB40, 0xD8E8FB40, 0xD8E9FB40, 0xD8EAFB40, 0xD8EBFB40, 0xD8ECFB40, 0xD8EDFB40, 0xD8EEFB40, 0xD8EFFB40, 0xD8F0FB40, 0xD8F1FB40, 0xD8F2FB40, 0xD8F3FB40, 0xD8F4FB40, 0xD8F5FB40, 0xD8F6FB40, 0xD8F7FB40, 0xD8F8FB40, 0xD8F9FB40, 0xD8FAFB40, 0xD8FBFB40, 0xD8FCFB40, 0xD8FDFB40, 0xD8FEFB40, 0xD8FFFB40, 0xD900FB40, 0xD901FB40, 0xD902FB40, 0xD903FB40, 0xD904FB40, 0xD905FB40, 0xD906FB40, 0xD907FB40, 0xD908FB40, 0xD909FB40, 0xD90AFB40, 0xD90BFB40, 0xD90CFB40, 0xD90DFB40, 0xD90EFB40, 0xD90FFB40, 0xD910FB40, 0xD911FB40, 0xD912FB40, 0xD913FB40, 0xD914FB40, 0xD915FB40, 0xD916FB40, 0xD917FB40, 0xD918FB40, 0xD919FB40, 0xD91AFB40, 0xD91BFB40, 0xD91CFB40, 0xD91DFB40, 0xD91EFB40, 0xD91FFB40, 0xD920FB40, 0xD921FB40, 0xD922FB40, 0xD923FB40, 0xD924FB40, 0xD925FB40, 0xD926FB40, 0xD927FB40, 0xD928FB40, 0xD929FB40, 0xD92AFB40, 0xD92BFB40, 0xD92CFB40, 0xD92DFB40, 0xD92EFB40, 0xD92FFB40, 0xD930FB40, 0xD931FB40, 0xD932FB40, 0xD933FB40, 0xD934FB40, 0xD935FB40, 0xD936FB40, 0xD937FB40, 0xD938FB40, 0xD939FB40, 0xD93AFB40, 0xD93BFB40, 0xD93CFB40, 0xD93DFB40, 0xD93EFB40, 0xD93FFB40, 0xD940FB40, 0xD941FB40, 0xD942FB40, 0xD943FB40, 0xD944FB40, 0xD945FB40, 0xD946FB40, 0xD947FB40, 0xD948FB40, 0xD949FB40, 0xD94AFB40, 0xD94BFB40, 0xD94CFB40, 0xD94DFB40, 0xD94EFB40, 0xD94FFB40, 0xD950FB40, 0xD951FB40, 0xD952FB40, 0xD953FB40, 0xD954FB40, 0xD955FB40, 0xD956FB40, 0xD957FB40, 0xD958FB40, 0xD959FB40, 0xD95AFB40, 0xD95BFB40, 0xD95CFB40, 0xD95DFB40, 0xD95EFB40, 0xD95FFB40, 0xD960FB40, 0xD961FB40, 0xD962FB40, 0xD963FB40, 0xD964FB40, 0xD965FB40, /* 58BC */
+ 0xD966FB40, 0xD967FB40, 0xD968FB40, 0xD969FB40, 0xD96AFB40, 0xD96BFB40, 0xD96CFB40, 0xD96DFB40, 0xD96EFB40, 0xD96FFB40, 0xD970FB40, 0xD971FB40, 0xD972FB40, 0xD973FB40, 0xD974FB40, 0xD975FB40, 0xD976FB40, 0xD977FB40, 0xD978FB40, 0xD979FB40, 0xD97AFB40, 0xD97BFB40, 0xD97CFB40, 0xD97DFB40, 0xD97EFB40, 0xD97FFB40, 0xD980FB40, 0xD981FB40, 0xD982FB40, 0xD983FB40, 0xD984FB40, 0xD985FB40, 0xD986FB40, 0xD987FB40, 0xD988FB40, 0xD989FB40, 0xD98AFB40, 0xD98BFB40, 0xD98CFB40, 0xD98DFB40, 0xD98EFB40, 0xD98FFB40, 0xD990FB40, 0xD991FB40, 0xD992FB40, 0xD993FB40, 0xD994FB40, 0xD995FB40, 0xD996FB40, 0xD997FB40, 0xD998FB40, 0xD999FB40, 0xD99AFB40, 0xD99BFB40, 0xD99CFB40, 0xD99DFB40, 0xD99EFB40, 0xD99FFB40, 0xD9A0FB40, 0xD9A1FB40, 0xD9A2FB40, 0xD9A3FB40, 0xD9A4FB40, 0xD9A5FB40, 0xD9A6FB40, 0xD9A7FB40, 0xD9A8FB40, 0xD9A9FB40, 0xD9AAFB40, 0xD9ABFB40, 0xD9ACFB40, 0xD9ADFB40, 0xD9AEFB40, 0xD9AFFB40, 0xD9B0FB40, 0xD9B1FB40, 0xD9B2FB40, 0xD9B3FB40, 0xD9B4FB40, 0xD9B5FB40, 0xD9B6FB40, 0xD9B7FB40, 0xD9B8FB40, 0xD9B9FB40, 0xD9BAFB40, 0xD9BBFB40, 0xD9BCFB40, 0xD9BDFB40, 0xD9BEFB40, 0xD9BFFB40, 0xD9C0FB40, 0xD9C1FB40, 0xD9C2FB40, 0xD9C3FB40, 0xD9C4FB40, 0xD9C5FB40, 0xD9C6FB40, 0xD9C7FB40, 0xD9C8FB40, 0xD9C9FB40, 0xD9CAFB40, 0xD9CBFB40, 0xD9CCFB40, 0xD9CDFB40, 0xD9CEFB40, 0xD9CFFB40, 0xD9D0FB40, 0xD9D1FB40, 0xD9D2FB40, 0xD9D3FB40, 0xD9D4FB40, 0xD9D5FB40, 0xD9D6FB40, 0xD9D7FB40, 0xD9D8FB40, 0xD9D9FB40, 0xD9DAFB40, 0xD9DBFB40, 0xD9DCFB40, 0xD9DDFB40, 0xD9DEFB40, 0xD9DFFB40, 0xD9E0FB40, 0xD9E1FB40, 0xD9E2FB40, 0xD9E3FB40, 0xD9E4FB40, 0xD9E5FB40, 0xD9E6FB40, 0xD9E7FB40, 0xD9E8FB40, 0xD9E9FB40, 0xD9EAFB40, 0xD9EBFB40, 0xD9ECFB40, 0xD9EDFB40, 0xD9EEFB40, 0xD9EFFB40, 0xD9F0FB40, 0xD9F1FB40, 0xD9F2FB40, 0xD9F3FB40, 0xD9F4FB40, 0xD9F5FB40, 0xD9F6FB40, 0xD9F7FB40, 0xD9F8FB40, 0xD9F9FB40, 0xD9FAFB40, 0xD9FBFB40, 0xD9FCFB40, 0xD9FDFB40, 0xD9FEFB40, 0xD9FFFB40, 0xDA00FB40, 0xDA01FB40, 0xDA02FB40, 0xDA03FB40, 0xDA04FB40, 0xDA05FB40, 0xDA06FB40, 0xDA07FB40, 0xDA08FB40, 0xDA09FB40, 0xDA0AFB40, 0xDA0BFB40, 0xDA0CFB40, 0xDA0DFB40, 0xDA0EFB40, 0xDA0FFB40, /* 5966 */
+ 0xDA10FB40, 0xDA11FB40, 0xDA12FB40, 0xDA13FB40, 0xDA14FB40, 0xDA15FB40, 0xDA16FB40, 0xDA17FB40, 0xDA18FB40, 0xDA19FB40, 0xDA1AFB40, 0xDA1BFB40, 0xDA1CFB40, 0xDA1DFB40, 0xDA1EFB40, 0xDA1FFB40, 0xDA20FB40, 0xDA21FB40, 0xDA22FB40, 0xDA23FB40, 0xDA24FB40, 0xDA25FB40, 0xDA26FB40, 0xDA27FB40, 0xDA28FB40, 0xDA29FB40, 0xDA2AFB40, 0xDA2BFB40, 0xDA2CFB40, 0xDA2DFB40, 0xDA2EFB40, 0xDA2FFB40, 0xDA30FB40, 0xDA31FB40, 0xDA32FB40, 0xDA33FB40, 0xDA34FB40, 0xDA35FB40, 0xDA36FB40, 0xDA37FB40, 0xDA38FB40, 0xDA39FB40, 0xDA3AFB40, 0xDA3BFB40, 0xDA3CFB40, 0xDA3DFB40, 0xDA3EFB40, 0xDA3FFB40, 0xDA40FB40, 0xDA41FB40, 0xDA42FB40, 0xDA43FB40, 0xDA44FB40, 0xDA45FB40, 0xDA46FB40, 0xDA47FB40, 0xDA48FB40, 0xDA49FB40, 0xDA4AFB40, 0xDA4BFB40, 0xDA4CFB40, 0xDA4DFB40, 0xDA4EFB40, 0xDA4FFB40, 0xDA50FB40, 0xDA51FB40, 0xDA52FB40, 0xDA53FB40, 0xDA54FB40, 0xDA55FB40, 0xDA56FB40, 0xDA57FB40, 0xDA58FB40, 0xDA59FB40, 0xDA5AFB40, 0xDA5BFB40, 0xDA5CFB40, 0xDA5DFB40, 0xDA5EFB40, 0xDA5FFB40, 0xDA60FB40, 0xDA61FB40, 0xDA62FB40, 0xDA63FB40, 0xDA64FB40, 0xDA65FB40, 0xDA66FB40, 0xDA67FB40, 0xDA68FB40, 0xDA69FB40, 0xDA6AFB40, 0xDA6BFB40, 0xDA6CFB40, 0xDA6DFB40, 0xDA6EFB40, 0xDA6FFB40, 0xDA70FB40, 0xDA71FB40, 0xDA72FB40, 0xDA73FB40, 0xDA74FB40, 0xDA75FB40, 0xDA76FB40, 0xDA77FB40, 0xDA78FB40, 0xDA79FB40, 0xDA7AFB40, 0xDA7BFB40, 0xDA7CFB40, 0xDA7DFB40, 0xDA7EFB40, 0xDA7FFB40, 0xDA80FB40, 0xDA81FB40, 0xDA82FB40, 0xDA83FB40, 0xDA84FB40, 0xDA85FB40, 0xDA86FB40, 0xDA87FB40, 0xDA88FB40, 0xDA89FB40, 0xDA8AFB40, 0xDA8BFB40, 0xDA8CFB40, 0xDA8DFB40, 0xDA8EFB40, 0xDA8FFB40, 0xDA90FB40, 0xDA91FB40, 0xDA92FB40, 0xDA93FB40, 0xDA94FB40, 0xDA95FB40, 0xDA96FB40, 0xDA97FB40, 0xDA98FB40, 0xDA99FB40, 0xDA9AFB40, 0xDA9BFB40, 0xDA9CFB40, 0xDA9DFB40, 0xDA9EFB40, 0xDA9FFB40, 0xDAA0FB40, 0xDAA1FB40, 0xDAA2FB40, 0xDAA3FB40, 0xDAA4FB40, 0xDAA5FB40, 0xDAA6FB40, 0xDAA7FB40, 0xDAA8FB40, 0xDAA9FB40, 0xDAAAFB40, 0xDAABFB40, 0xDAACFB40, 0xDAADFB40, 0xDAAEFB40, 0xDAAFFB40, 0xDAB0FB40, 0xDAB1FB40, 0xDAB2FB40, 0xDAB3FB40, 0xDAB4FB40, 0xDAB5FB40, 0xDAB6FB40, 0xDAB7FB40, 0xDAB8FB40, 0xDAB9FB40, /* 5A10 */
+ 0xDABAFB40, 0xDABBFB40, 0xDABCFB40, 0xDABDFB40, 0xDABEFB40, 0xDABFFB40, 0xDAC0FB40, 0xDAC1FB40, 0xDAC2FB40, 0xDAC3FB40, 0xDAC4FB40, 0xDAC5FB40, 0xDAC6FB40, 0xDAC7FB40, 0xDAC8FB40, 0xDAC9FB40, 0xDACAFB40, 0xDACBFB40, 0xDACCFB40, 0xDACDFB40, 0xDACEFB40, 0xDACFFB40, 0xDAD0FB40, 0xDAD1FB40, 0xDAD2FB40, 0xDAD3FB40, 0xDAD4FB40, 0xDAD5FB40, 0xDAD6FB40, 0xDAD7FB40, 0xDAD8FB40, 0xDAD9FB40, 0xDADAFB40, 0xDADBFB40, 0xDADCFB40, 0xDADDFB40, 0xDADEFB40, 0xDADFFB40, 0xDAE0FB40, 0xDAE1FB40, 0xDAE2FB40, 0xDAE3FB40, 0xDAE4FB40, 0xDAE5FB40, 0xDAE6FB40, 0xDAE7FB40, 0xDAE8FB40, 0xDAE9FB40, 0xDAEAFB40, 0xDAEBFB40, 0xDAECFB40, 0xDAEDFB40, 0xDAEEFB40, 0xDAEFFB40, 0xDAF0FB40, 0xDAF1FB40, 0xDAF2FB40, 0xDAF3FB40, 0xDAF4FB40, 0xDAF5FB40, 0xDAF6FB40, 0xDAF7FB40, 0xDAF8FB40, 0xDAF9FB40, 0xDAFAFB40, 0xDAFBFB40, 0xDAFCFB40, 0xDAFDFB40, 0xDAFEFB40, 0xDAFFFB40, 0xDB00FB40, 0xDB01FB40, 0xDB02FB40, 0xDB03FB40, 0xDB04FB40, 0xDB05FB40, 0xDB06FB40, 0xDB07FB40, 0xDB08FB40, 0xDB09FB40, 0xDB0AFB40, 0xDB0BFB40, 0xDB0CFB40, 0xDB0DFB40, 0xDB0EFB40, 0xDB0FFB40, 0xDB10FB40, 0xDB11FB40, 0xDB12FB40, 0xDB13FB40, 0xDB14FB40, 0xDB15FB40, 0xDB16FB40, 0xDB17FB40, 0xDB18FB40, 0xDB19FB40, 0xDB1AFB40, 0xDB1BFB40, 0xDB1CFB40, 0xDB1DFB40, 0xDB1EFB40, 0xDB1FFB40, 0xDB20FB40, 0xDB21FB40, 0xDB22FB40, 0xDB23FB40, 0xDB24FB40, 0xDB25FB40, 0xDB26FB40, 0xDB27FB40, 0xDB28FB40, 0xDB29FB40, 0xDB2AFB40, 0xDB2BFB40, 0xDB2CFB40, 0xDB2DFB40, 0xDB2EFB40, 0xDB2FFB40, 0xDB30FB40, 0xDB31FB40, 0xDB32FB40, 0xDB33FB40, 0xDB34FB40, 0xDB35FB40, 0xDB36FB40, 0xDB37FB40, 0xDB38FB40, 0xDB39FB40, 0xDB3AFB40, 0xDB3BFB40, 0xDB3CFB40, 0xDB3DFB40, 0xDB3EFB40, 0xDB3FFB40, 0xDB40FB40, 0xDB41FB40, 0xDB42FB40, 0xDB43FB40, 0xDB44FB40, 0xDB45FB40, 0xDB46FB40, 0xDB47FB40, 0xDB48FB40, 0xDB49FB40, 0xDB4AFB40, 0xDB4BFB40, 0xDB4CFB40, 0xDB4DFB40, 0xDB4EFB40, 0xDB4FFB40, 0xDB50FB40, 0xDB51FB40, 0xDB52FB40, 0xDB53FB40, 0xDB54FB40, 0xDB55FB40, 0xDB56FB40, 0xDB57FB40, 0xDB58FB40, 0xDB59FB40, 0xDB5AFB40, 0xDB5BFB40, 0xDB5CFB40, 0xDB5DFB40, 0xDB5EFB40, 0xDB5FFB40, 0xDB60FB40, 0xDB61FB40, 0xDB62FB40, 0xDB63FB40, /* 5ABA */
+ 0xDB64FB40, 0xDB65FB40, 0xDB66FB40, 0xDB67FB40, 0xDB68FB40, 0xDB69FB40, 0xDB6AFB40, 0xDB6BFB40, 0xDB6CFB40, 0xDB6DFB40, 0xDB6EFB40, 0xDB6FFB40, 0xDB70FB40, 0xDB71FB40, 0xDB72FB40, 0xDB73FB40, 0xDB74FB40, 0xDB75FB40, 0xDB76FB40, 0xDB77FB40, 0xDB78FB40, 0xDB79FB40, 0xDB7AFB40, 0xDB7BFB40, 0xDB7CFB40, 0xDB7DFB40, 0xDB7EFB40, 0xDB7FFB40, 0xDB80FB40, 0xDB81FB40, 0xDB82FB40, 0xDB83FB40, 0xDB84FB40, 0xDB85FB40, 0xDB86FB40, 0xDB87FB40, 0xDB88FB40, 0xDB89FB40, 0xDB8AFB40, 0xDB8BFB40, 0xDB8CFB40, 0xDB8DFB40, 0xDB8EFB40, 0xDB8FFB40, 0xDB90FB40, 0xDB91FB40, 0xDB92FB40, 0xDB93FB40, 0xDB94FB40, 0xDB95FB40, 0xDB96FB40, 0xDB97FB40, 0xDB98FB40, 0xDB99FB40, 0xDB9AFB40, 0xDB9BFB40, 0xDB9CFB40, 0xDB9DFB40, 0xDB9EFB40, 0xDB9FFB40, 0xDBA0FB40, 0xDBA1FB40, 0xDBA2FB40, 0xDBA3FB40, 0xDBA4FB40, 0xDBA5FB40, 0xDBA6FB40, 0xDBA7FB40, 0xDBA8FB40, 0xDBA9FB40, 0xDBAAFB40, 0xDBABFB40, 0xDBACFB40, 0xDBADFB40, 0xDBAEFB40, 0xDBAFFB40, 0xDBB0FB40, 0xDBB1FB40, 0xDBB2FB40, 0xDBB3FB40, 0xDBB4FB40, 0xDBB5FB40, 0xDBB6FB40, 0xDBB7FB40, 0xDBB8FB40, 0xDBB9FB40, 0xDBBAFB40, 0xDBBBFB40, 0xDBBCFB40, 0xDBBDFB40, 0xDBBEFB40, 0xDBBFFB40, 0xDBC0FB40, 0xDBC1FB40, 0xDBC2FB40, 0xDBC3FB40, 0xDBC4FB40, 0xDBC5FB40, 0xDBC6FB40, 0xDBC7FB40, 0xDBC8FB40, 0xDBC9FB40, 0xDBCAFB40, 0xDBCBFB40, 0xDBCCFB40, 0xDBCDFB40, 0xDBCEFB40, 0xDBCFFB40, 0xDBD0FB40, 0xDBD1FB40, 0xDBD2FB40, 0xDBD3FB40, 0xDBD4FB40, 0xDBD5FB40, 0xDBD6FB40, 0xDBD7FB40, 0xDBD8FB40, 0xDBD9FB40, 0xDBDAFB40, 0xDBDBFB40, 0xDBDCFB40, 0xDBDDFB40, 0xDBDEFB40, 0xDBDFFB40, 0xDBE0FB40, 0xDBE1FB40, 0xDBE2FB40, 0xDBE3FB40, 0xDBE4FB40, 0xDBE5FB40, 0xDBE6FB40, 0xDBE7FB40, 0xDBE8FB40, 0xDBE9FB40, 0xDBEAFB40, 0xDBEBFB40, 0xDBECFB40, 0xDBEDFB40, 0xDBEEFB40, 0xDBEFFB40, 0xDBF0FB40, 0xDBF1FB40, 0xDBF2FB40, 0xDBF3FB40, 0xDBF4FB40, 0xDBF5FB40, 0xDBF6FB40, 0xDBF7FB40, 0xDBF8FB40, 0xDBF9FB40, 0xDBFAFB40, 0xDBFBFB40, 0xDBFCFB40, 0xDBFDFB40, 0xDBFEFB40, 0xDBFFFB40, 0xDC00FB40, 0xDC01FB40, 0xDC02FB40, 0xDC03FB40, 0xDC04FB40, 0xDC05FB40, 0xDC06FB40, 0xDC07FB40, 0xDC08FB40, 0xDC09FB40, 0xDC0AFB40, 0xDC0BFB40, 0xDC0CFB40, 0xDC0DFB40, /* 5B64 */
+ 0xDC0EFB40, 0xDC0FFB40, 0xDC10FB40, 0xDC11FB40, 0xDC12FB40, 0xDC13FB40, 0xDC14FB40, 0xDC15FB40, 0xDC16FB40, 0xDC17FB40, 0xDC18FB40, 0xDC19FB40, 0xDC1AFB40, 0xDC1BFB40, 0xDC1CFB40, 0xDC1DFB40, 0xDC1EFB40, 0xDC1FFB40, 0xDC20FB40, 0xDC21FB40, 0xDC22FB40, 0xDC23FB40, 0xDC24FB40, 0xDC25FB40, 0xDC26FB40, 0xDC27FB40, 0xDC28FB40, 0xDC29FB40, 0xDC2AFB40, 0xDC2BFB40, 0xDC2CFB40, 0xDC2DFB40, 0xDC2EFB40, 0xDC2FFB40, 0xDC30FB40, 0xDC31FB40, 0xDC32FB40, 0xDC33FB40, 0xDC34FB40, 0xDC35FB40, 0xDC36FB40, 0xDC37FB40, 0xDC38FB40, 0xDC39FB40, 0xDC3AFB40, 0xDC3BFB40, 0xDC3CFB40, 0xDC3DFB40, 0xDC3EFB40, 0xDC3FFB40, 0xDC40FB40, 0xDC41FB40, 0xDC42FB40, 0xDC43FB40, 0xDC44FB40, 0xDC45FB40, 0xDC46FB40, 0xDC47FB40, 0xDC48FB40, 0xDC49FB40, 0xDC4AFB40, 0xDC4BFB40, 0xDC4CFB40, 0xDC4DFB40, 0xDC4EFB40, 0xDC4FFB40, 0xDC50FB40, 0xDC51FB40, 0xDC52FB40, 0xDC53FB40, 0xDC54FB40, 0xDC55FB40, 0xDC56FB40, 0xDC57FB40, 0xDC58FB40, 0xDC59FB40, 0xDC5AFB40, 0xDC5BFB40, 0xDC5CFB40, 0xDC5DFB40, 0xDC5EFB40, 0xDC5FFB40, 0xDC60FB40, 0xDC61FB40, 0xDC62FB40, 0xDC63FB40, 0xDC64FB40, 0xDC65FB40, 0xDC66FB40, 0xDC67FB40, 0xDC68FB40, 0xDC69FB40, 0xDC6AFB40, 0xDC6BFB40, 0xDC6CFB40, 0xDC6DFB40, 0xDC6EFB40, 0xDC6FFB40, 0xDC70FB40, 0xDC71FB40, 0xDC72FB40, 0xDC73FB40, 0xDC74FB40, 0xDC75FB40, 0xDC76FB40, 0xDC77FB40, 0xDC78FB40, 0xDC79FB40, 0xDC7AFB40, 0xDC7BFB40, 0xDC7CFB40, 0xDC7DFB40, 0xDC7EFB40, 0xDC7FFB40, 0xDC80FB40, 0xDC81FB40, 0xDC82FB40, 0xDC83FB40, 0xDC84FB40, 0xDC85FB40, 0xDC86FB40, 0xDC87FB40, 0xDC88FB40, 0xDC89FB40, 0xDC8AFB40, 0xDC8BFB40, 0xDC8CFB40, 0xDC8DFB40, 0xDC8EFB40, 0xDC8FFB40, 0xDC90FB40, 0xDC91FB40, 0xDC92FB40, 0xDC93FB40, 0xDC94FB40, 0xDC95FB40, 0xDC96FB40, 0xDC97FB40, 0xDC98FB40, 0xDC99FB40, 0xDC9AFB40, 0xDC9BFB40, 0xDC9CFB40, 0xDC9DFB40, 0xDC9EFB40, 0xDC9FFB40, 0xDCA0FB40, 0xDCA1FB40, 0xDCA2FB40, 0xDCA3FB40, 0xDCA4FB40, 0xDCA5FB40, 0xDCA6FB40, 0xDCA7FB40, 0xDCA8FB40, 0xDCA9FB40, 0xDCAAFB40, 0xDCABFB40, 0xDCACFB40, 0xDCADFB40, 0xDCAEFB40, 0xDCAFFB40, 0xDCB0FB40, 0xDCB1FB40, 0xDCB2FB40, 0xDCB3FB40, 0xDCB4FB40, 0xDCB5FB40, 0xDCB6FB40, 0xDCB7FB40, /* 5C0E */
+ 0xDCB8FB40, 0xDCB9FB40, 0xDCBAFB40, 0xDCBBFB40, 0xDCBCFB40, 0xDCBDFB40, 0xDCBEFB40, 0xDCBFFB40, 0xDCC0FB40, 0xDCC1FB40, 0xDCC2FB40, 0xDCC3FB40, 0xDCC4FB40, 0xDCC5FB40, 0xDCC6FB40, 0xDCC7FB40, 0xDCC8FB40, 0xDCC9FB40, 0xDCCAFB40, 0xDCCBFB40, 0xDCCCFB40, 0xDCCDFB40, 0xDCCEFB40, 0xDCCFFB40, 0xDCD0FB40, 0xDCD1FB40, 0xDCD2FB40, 0xDCD3FB40, 0xDCD4FB40, 0xDCD5FB40, 0xDCD6FB40, 0xDCD7FB40, 0xDCD8FB40, 0xDCD9FB40, 0xDCDAFB40, 0xDCDBFB40, 0xDCDCFB40, 0xDCDDFB40, 0xDCDEFB40, 0xDCDFFB40, 0xDCE0FB40, 0xDCE1FB40, 0xDCE2FB40, 0xDCE3FB40, 0xDCE4FB40, 0xDCE5FB40, 0xDCE6FB40, 0xDCE7FB40, 0xDCE8FB40, 0xDCE9FB40, 0xDCEAFB40, 0xDCEBFB40, 0xDCECFB40, 0xDCEDFB40, 0xDCEEFB40, 0xDCEFFB40, 0xDCF0FB40, 0xDCF1FB40, 0xDCF2FB40, 0xDCF3FB40, 0xDCF4FB40, 0xDCF5FB40, 0xDCF6FB40, 0xDCF7FB40, 0xDCF8FB40, 0xDCF9FB40, 0xDCFAFB40, 0xDCFBFB40, 0xDCFCFB40, 0xDCFDFB40, 0xDCFEFB40, 0xDCFFFB40, 0xDD00FB40, 0xDD01FB40, 0xDD02FB40, 0xDD03FB40, 0xDD04FB40, 0xDD05FB40, 0xDD06FB40, 0xDD07FB40, 0xDD08FB40, 0xDD09FB40, 0xDD0AFB40, 0xDD0BFB40, 0xDD0CFB40, 0xDD0DFB40, 0xDD0EFB40, 0xDD0FFB40, 0xDD10FB40, 0xDD11FB40, 0xDD12FB40, 0xDD13FB40, 0xDD14FB40, 0xDD15FB40, 0xDD16FB40, 0xDD17FB40, 0xDD18FB40, 0xDD19FB40, 0xDD1AFB40, 0xDD1BFB40, 0xDD1CFB40, 0xDD1DFB40, 0xDD1EFB40, 0xDD1FFB40, 0xDD20FB40, 0xDD21FB40, 0xDD22FB40, 0xDD23FB40, 0xDD24FB40, 0xDD25FB40, 0xDD26FB40, 0xDD27FB40, 0xDD28FB40, 0xDD29FB40, 0xDD2AFB40, 0xDD2BFB40, 0xDD2CFB40, 0xDD2DFB40, 0xDD2EFB40, 0xDD2FFB40, 0xDD30FB40, 0xDD31FB40, 0xDD32FB40, 0xDD33FB40, 0xDD34FB40, 0xDD35FB40, 0xDD36FB40, 0xDD37FB40, 0xDD38FB40, 0xDD39FB40, 0xDD3AFB40, 0xDD3BFB40, 0xDD3CFB40, 0xDD3DFB40, 0xDD3EFB40, 0xDD3FFB40, 0xDD40FB40, 0xDD41FB40, 0xDD42FB40, 0xDD43FB40, 0xDD44FB40, 0xDD45FB40, 0xDD46FB40, 0xDD47FB40, 0xDD48FB40, 0xDD49FB40, 0xDD4AFB40, 0xDD4BFB40, 0xDD4CFB40, 0xDD4DFB40, 0xDD4EFB40, 0xDD4FFB40, 0xDD50FB40, 0xDD51FB40, 0xDD52FB40, 0xDD53FB40, 0xDD54FB40, 0xDD55FB40, 0xDD56FB40, 0xDD57FB40, 0xDD58FB40, 0xDD59FB40, 0xDD5AFB40, 0xDD5BFB40, 0xDD5CFB40, 0xDD5DFB40, 0xDD5EFB40, 0xDD5FFB40, 0xDD60FB40, 0xDD61FB40, /* 5CB8 */
+ 0xDD62FB40, 0xDD63FB40, 0xDD64FB40, 0xDD65FB40, 0xDD66FB40, 0xDD67FB40, 0xDD68FB40, 0xDD69FB40, 0xDD6AFB40, 0xDD6BFB40, 0xDD6CFB40, 0xDD6DFB40, 0xDD6EFB40, 0xDD6FFB40, 0xDD70FB40, 0xDD71FB40, 0xDD72FB40, 0xDD73FB40, 0xDD74FB40, 0xDD75FB40, 0xDD76FB40, 0xDD77FB40, 0xDD78FB40, 0xDD79FB40, 0xDD7AFB40, 0xDD7BFB40, 0xDD7CFB40, 0xDD7DFB40, 0xDD7EFB40, 0xDD7FFB40, 0xDD80FB40, 0xDD81FB40, 0xDD82FB40, 0xDD83FB40, 0xDD84FB40, 0xDD85FB40, 0xDD86FB40, 0xDD87FB40, 0xDD88FB40, 0xDD89FB40, 0xDD8AFB40, 0xDD8BFB40, 0xDD8CFB40, 0xDD8DFB40, 0xDD8EFB40, 0xDD8FFB40, 0xDD90FB40, 0xDD91FB40, 0xDD92FB40, 0xDD93FB40, 0xDD94FB40, 0xDD95FB40, 0xDD96FB40, 0xDD97FB40, 0xDD98FB40, 0xDD99FB40, 0xDD9AFB40, 0xDD9BFB40, 0xDD9CFB40, 0xDD9DFB40, 0xDD9EFB40, 0xDD9FFB40, 0xDDA0FB40, 0xDDA1FB40, 0xDDA2FB40, 0xDDA3FB40, 0xDDA4FB40, 0xDDA5FB40, 0xDDA6FB40, 0xDDA7FB40, 0xDDA8FB40, 0xDDA9FB40, 0xDDAAFB40, 0xDDABFB40, 0xDDACFB40, 0xDDADFB40, 0xDDAEFB40, 0xDDAFFB40, 0xDDB0FB40, 0xDDB1FB40, 0xDDB2FB40, 0xDDB3FB40, 0xDDB4FB40, 0xDDB5FB40, 0xDDB6FB40, 0xDDB7FB40, 0xDDB8FB40, 0xDDB9FB40, 0xDDBAFB40, 0xDDBBFB40, 0xDDBCFB40, 0xDDBDFB40, 0xDDBEFB40, 0xDDBFFB40, 0xDDC0FB40, 0xDDC1FB40, 0xDDC2FB40, 0xDDC3FB40, 0xDDC4FB40, 0xDDC5FB40, 0xDDC6FB40, 0xDDC7FB40, 0xDDC8FB40, 0xDDC9FB40, 0xDDCAFB40, 0xDDCBFB40, 0xDDCCFB40, 0xDDCDFB40, 0xDDCEFB40, 0xDDCFFB40, 0xDDD0FB40, 0xDDD1FB40, 0xDDD2FB40, 0xDDD3FB40, 0xDDD4FB40, 0xDDD5FB40, 0xDDD6FB40, 0xDDD7FB40, 0xDDD8FB40, 0xDDD9FB40, 0xDDDAFB40, 0xDDDBFB40, 0xDDDCFB40, 0xDDDDFB40, 0xDDDEFB40, 0xDDDFFB40, 0xDDE0FB40, 0xDDE1FB40, 0xDDE2FB40, 0xDDE3FB40, 0xDDE4FB40, 0xDDE5FB40, 0xDDE6FB40, 0xDDE7FB40, 0xDDE8FB40, 0xDDE9FB40, 0xDDEAFB40, 0xDDEBFB40, 0xDDECFB40, 0xDDEDFB40, 0xDDEEFB40, 0xDDEFFB40, 0xDDF0FB40, 0xDDF1FB40, 0xDDF2FB40, 0xDDF3FB40, 0xDDF4FB40, 0xDDF5FB40, 0xDDF6FB40, 0xDDF7FB40, 0xDDF8FB40, 0xDDF9FB40, 0xDDFAFB40, 0xDDFBFB40, 0xDDFCFB40, 0xDDFDFB40, 0xDDFEFB40, 0xDDFFFB40, 0xDE00FB40, 0xDE01FB40, 0xDE02FB40, 0xDE03FB40, 0xDE04FB40, 0xDE05FB40, 0xDE06FB40, 0xDE07FB40, 0xDE08FB40, 0xDE09FB40, 0xDE0AFB40, 0xDE0BFB40, /* 5D62 */
+ 0xDE0CFB40, 0xDE0DFB40, 0xDE0EFB40, 0xDE0FFB40, 0xDE10FB40, 0xDE11FB40, 0xDE12FB40, 0xDE13FB40, 0xDE14FB40, 0xDE15FB40, 0xDE16FB40, 0xDE17FB40, 0xDE18FB40, 0xDE19FB40, 0xDE1AFB40, 0xDE1BFB40, 0xDE1CFB40, 0xDE1DFB40, 0xDE1EFB40, 0xDE1FFB40, 0xDE20FB40, 0xDE21FB40, 0xDE22FB40, 0xDE23FB40, 0xDE24FB40, 0xDE25FB40, 0xDE26FB40, 0xDE27FB40, 0xDE28FB40, 0xDE29FB40, 0xDE2AFB40, 0xDE2BFB40, 0xDE2CFB40, 0xDE2DFB40, 0xDE2EFB40, 0xDE2FFB40, 0xDE30FB40, 0xDE31FB40, 0xDE32FB40, 0xDE33FB40, 0xDE34FB40, 0xDE35FB40, 0xDE36FB40, 0xDE37FB40, 0xDE38FB40, 0xDE39FB40, 0xDE3AFB40, 0xDE3BFB40, 0xDE3CFB40, 0xDE3DFB40, 0xDE3EFB40, 0xDE3FFB40, 0xDE40FB40, 0xDE41FB40, 0xDE42FB40, 0xDE43FB40, 0xDE44FB40, 0xDE45FB40, 0xDE46FB40, 0xDE47FB40, 0xDE48FB40, 0xDE49FB40, 0xDE4AFB40, 0xDE4BFB40, 0xDE4CFB40, 0xDE4DFB40, 0xDE4EFB40, 0xDE4FFB40, 0xDE50FB40, 0xDE51FB40, 0xDE52FB40, 0xDE53FB40, 0xDE54FB40, 0xDE55FB40, 0xDE56FB40, 0xDE57FB40, 0xDE58FB40, 0xDE59FB40, 0xDE5AFB40, 0xDE5BFB40, 0xDE5CFB40, 0xDE5DFB40, 0xDE5EFB40, 0xDE5FFB40, 0xDE60FB40, 0xDE61FB40, 0xDE62FB40, 0xDE63FB40, 0xDE64FB40, 0xDE65FB40, 0xDE66FB40, 0xDE67FB40, 0xDE68FB40, 0xDE69FB40, 0xDE6AFB40, 0xDE6BFB40, 0xDE6CFB40, 0xDE6DFB40, 0xDE6EFB40, 0xDE6FFB40, 0xDE70FB40, 0xDE71FB40, 0xDE72FB40, 0xDE73FB40, 0xDE74FB40, 0xDE75FB40, 0xDE76FB40, 0xDE77FB40, 0xDE78FB40, 0xDE79FB40, 0xDE7AFB40, 0xDE7BFB40, 0xDE7CFB40, 0xDE7DFB40, 0xDE7EFB40, 0xDE7FFB40, 0xDE80FB40, 0xDE81FB40, 0xDE82FB40, 0xDE83FB40, 0xDE84FB40, 0xDE85FB40, 0xDE86FB40, 0xDE87FB40, 0xDE88FB40, 0xDE89FB40, 0xDE8AFB40, 0xDE8BFB40, 0xDE8CFB40, 0xDE8DFB40, 0xDE8EFB40, 0xDE8FFB40, 0xDE90FB40, 0xDE91FB40, 0xDE92FB40, 0xDE93FB40, 0xDE94FB40, 0xDE95FB40, 0xDE96FB40, 0xDE97FB40, 0xDE98FB40, 0xDE99FB40, 0xDE9AFB40, 0xDE9BFB40, 0xDE9CFB40, 0xDE9DFB40, 0xDE9EFB40, 0xDE9FFB40, 0xDEA0FB40, 0xDEA1FB40, 0xDEA2FB40, 0xDEA3FB40, 0xDEA4FB40, 0xDEA5FB40, 0xDEA6FB40, 0xDEA7FB40, 0xDEA8FB40, 0xDEA9FB40, 0xDEAAFB40, 0xDEABFB40, 0xDEACFB40, 0xDEADFB40, 0xDEAEFB40, 0xDEAFFB40, 0xDEB0FB40, 0xDEB1FB40, 0xDEB2FB40, 0xDEB3FB40, 0xDEB4FB40, 0xDEB5FB40, /* 5E0C */
+ 0xDEB6FB40, 0xDEB7FB40, 0xDEB8FB40, 0xDEB9FB40, 0xDEBAFB40, 0xDEBBFB40, 0xDEBCFB40, 0xDEBDFB40, 0xDEBEFB40, 0xDEBFFB40, 0xDEC0FB40, 0xDEC1FB40, 0xDEC2FB40, 0xDEC3FB40, 0xDEC4FB40, 0xDEC5FB40, 0xDEC6FB40, 0xDEC7FB40, 0xDEC8FB40, 0xDEC9FB40, 0xDECAFB40, 0xDECBFB40, 0xDECCFB40, 0xDECDFB40, 0xDECEFB40, 0xDECFFB40, 0xDED0FB40, 0xDED1FB40, 0xDED2FB40, 0xDED3FB40, 0xDED4FB40, 0xDED5FB40, 0xDED6FB40, 0xDED7FB40, 0xDED8FB40, 0xDED9FB40, 0xDEDAFB40, 0xDEDBFB40, 0xDEDCFB40, 0xDEDDFB40, 0xDEDEFB40, 0xDEDFFB40, 0xDEE0FB40, 0xDEE1FB40, 0xDEE2FB40, 0xDEE3FB40, 0xDEE4FB40, 0xDEE5FB40, 0xDEE6FB40, 0xDEE7FB40, 0xDEE8FB40, 0xDEE9FB40, 0xDEEAFB40, 0xDEEBFB40, 0xDEECFB40, 0xDEEDFB40, 0xDEEEFB40, 0xDEEFFB40, 0xDEF0FB40, 0xDEF1FB40, 0xDEF2FB40, 0xDEF3FB40, 0xDEF4FB40, 0xDEF5FB40, 0xDEF6FB40, 0xDEF7FB40, 0xDEF8FB40, 0xDEF9FB40, 0xDEFAFB40, 0xDEFBFB40, 0xDEFCFB40, 0xDEFDFB40, 0xDEFEFB40, 0xDEFFFB40, 0xDF00FB40, 0xDF01FB40, 0xDF02FB40, 0xDF03FB40, 0xDF04FB40, 0xDF05FB40, 0xDF06FB40, 0xDF07FB40, 0xDF08FB40, 0xDF09FB40, 0xDF0AFB40, 0xDF0BFB40, 0xDF0CFB40, 0xDF0DFB40, 0xDF0EFB40, 0xDF0FFB40, 0xDF10FB40, 0xDF11FB40, 0xDF12FB40, 0xDF13FB40, 0xDF14FB40, 0xDF15FB40, 0xDF16FB40, 0xDF17FB40, 0xDF18FB40, 0xDF19FB40, 0xDF1AFB40, 0xDF1BFB40, 0xDF1CFB40, 0xDF1DFB40, 0xDF1EFB40, 0xDF1FFB40, 0xDF20FB40, 0xDF21FB40, 0xDF22FB40, 0xDF23FB40, 0xDF24FB40, 0xDF25FB40, 0xDF26FB40, 0xDF27FB40, 0xDF28FB40, 0xDF29FB40, 0xDF2AFB40, 0xDF2BFB40, 0xDF2CFB40, 0xDF2DFB40, 0xDF2EFB40, 0xDF2FFB40, 0xDF30FB40, 0xDF31FB40, 0xDF32FB40, 0xDF33FB40, 0xDF34FB40, 0xDF35FB40, 0xDF36FB40, 0xDF37FB40, 0xDF38FB40, 0xDF39FB40, 0xDF3AFB40, 0xDF3BFB40, 0xDF3CFB40, 0xDF3DFB40, 0xDF3EFB40, 0xDF3FFB40, 0xDF40FB40, 0xDF41FB40, 0xDF42FB40, 0xDF43FB40, 0xDF44FB40, 0xDF45FB40, 0xDF46FB40, 0xDF47FB40, 0xDF48FB40, 0xDF49FB40, 0xDF4AFB40, 0xDF4BFB40, 0xDF4CFB40, 0xDF4DFB40, 0xDF4EFB40, 0xDF4FFB40, 0xDF50FB40, 0xDF51FB40, 0xDF52FB40, 0xDF53FB40, 0xDF54FB40, 0xDF55FB40, 0xDF56FB40, 0xDF57FB40, 0xDF58FB40, 0xDF59FB40, 0xDF5AFB40, 0xDF5BFB40, 0xDF5CFB40, 0xDF5DFB40, 0xDF5EFB40, 0xDF5FFB40, /* 5EB6 */
+ 0xDF60FB40, 0xDF61FB40, 0xDF62FB40, 0xDF63FB40, 0xDF64FB40, 0xDF65FB40, 0xDF66FB40, 0xDF67FB40, 0xDF68FB40, 0xDF69FB40, 0xDF6AFB40, 0xDF6BFB40, 0xDF6CFB40, 0xDF6DFB40, 0xDF6EFB40, 0xDF6FFB40, 0xDF70FB40, 0xDF71FB40, 0xDF72FB40, 0xDF73FB40, 0xDF74FB40, 0xDF75FB40, 0xDF76FB40, 0xDF77FB40, 0xDF78FB40, 0xDF79FB40, 0xDF7AFB40, 0xDF7BFB40, 0xDF7CFB40, 0xDF7DFB40, 0xDF7EFB40, 0xDF7FFB40, 0xDF80FB40, 0xDF81FB40, 0xDF82FB40, 0xDF83FB40, 0xDF84FB40, 0xDF85FB40, 0xDF86FB40, 0xDF87FB40, 0xDF88FB40, 0xDF89FB40, 0xDF8AFB40, 0xDF8BFB40, 0xDF8CFB40, 0xDF8DFB40, 0xDF8EFB40, 0xDF8FFB40, 0xDF90FB40, 0xDF91FB40, 0xDF92FB40, 0xDF93FB40, 0xDF94FB40, 0xDF95FB40, 0xDF96FB40, 0xDF97FB40, 0xDF98FB40, 0xDF99FB40, 0xDF9AFB40, 0xDF9BFB40, 0xDF9CFB40, 0xDF9DFB40, 0xDF9EFB40, 0xDF9FFB40, 0xDFA0FB40, 0xDFA1FB40, 0xDFA2FB40, 0xDFA3FB40, 0xDFA4FB40, 0xDFA5FB40, 0xDFA6FB40, 0xDFA7FB40, 0xDFA8FB40, 0xDFA9FB40, 0xDFAAFB40, 0xDFABFB40, 0xDFACFB40, 0xDFADFB40, 0xDFAEFB40, 0xDFAFFB40, 0xDFB0FB40, 0xDFB1FB40, 0xDFB2FB40, 0xDFB3FB40, 0xDFB4FB40, 0xDFB5FB40, 0xDFB6FB40, 0xDFB7FB40, 0xDFB8FB40, 0xDFB9FB40, 0xDFBAFB40, 0xDFBBFB40, 0xDFBCFB40, 0xDFBDFB40, 0xDFBEFB40, 0xDFBFFB40, 0xDFC0FB40, 0xDFC1FB40, 0xDFC2FB40, 0xDFC3FB40, 0xDFC4FB40, 0xDFC5FB40, 0xDFC6FB40, 0xDFC7FB40, 0xDFC8FB40, 0xDFC9FB40, 0xDFCAFB40, 0xDFCBFB40, 0xDFCCFB40, 0xDFCDFB40, 0xDFCEFB40, 0xDFCFFB40, 0xDFD0FB40, 0xDFD1FB40, 0xDFD2FB40, 0xDFD3FB40, 0xDFD4FB40, 0xDFD5FB40, 0xDFD6FB40, 0xDFD7FB40, 0xDFD8FB40, 0xDFD9FB40, 0xDFDAFB40, 0xDFDBFB40, 0xDFDCFB40, 0xDFDDFB40, 0xDFDEFB40, 0xDFDFFB40, 0xDFE0FB40, 0xDFE1FB40, 0xDFE2FB40, 0xDFE3FB40, 0xDFE4FB40, 0xDFE5FB40, 0xDFE6FB40, 0xDFE7FB40, 0xDFE8FB40, 0xDFE9FB40, 0xDFEAFB40, 0xDFEBFB40, 0xDFECFB40, 0xDFEDFB40, 0xDFEEFB40, 0xDFEFFB40, 0xDFF0FB40, 0xDFF1FB40, 0xDFF2FB40, 0xDFF3FB40, 0xDFF4FB40, 0xDFF5FB40, 0xDFF6FB40, 0xDFF7FB40, 0xDFF8FB40, 0xDFF9FB40, 0xDFFAFB40, 0xDFFBFB40, 0xDFFCFB40, 0xDFFDFB40, 0xDFFEFB40, 0xDFFFFB40, 0xE000FB40, 0xE001FB40, 0xE002FB40, 0xE003FB40, 0xE004FB40, 0xE005FB40, 0xE006FB40, 0xE007FB40, 0xE008FB40, 0xE009FB40, /* 5F60 */
+ 0xE00AFB40, 0xE00BFB40, 0xE00CFB40, 0xE00DFB40, 0xE00EFB40, 0xE00FFB40, 0xE010FB40, 0xE011FB40, 0xE012FB40, 0xE013FB40, 0xE014FB40, 0xE015FB40, 0xE016FB40, 0xE017FB40, 0xE018FB40, 0xE019FB40, 0xE01AFB40, 0xE01BFB40, 0xE01CFB40, 0xE01DFB40, 0xE01EFB40, 0xE01FFB40, 0xE020FB40, 0xE021FB40, 0xE022FB40, 0xE023FB40, 0xE024FB40, 0xE025FB40, 0xE026FB40, 0xE027FB40, 0xE028FB40, 0xE029FB40, 0xE02AFB40, 0xE02BFB40, 0xE02CFB40, 0xE02DFB40, 0xE02EFB40, 0xE02FFB40, 0xE030FB40, 0xE031FB40, 0xE032FB40, 0xE033FB40, 0xE034FB40, 0xE035FB40, 0xE036FB40, 0xE037FB40, 0xE038FB40, 0xE039FB40, 0xE03AFB40, 0xE03BFB40, 0xE03CFB40, 0xE03DFB40, 0xE03EFB40, 0xE03FFB40, 0xE040FB40, 0xE041FB40, 0xE042FB40, 0xE043FB40, 0xE044FB40, 0xE045FB40, 0xE046FB40, 0xE047FB40, 0xE048FB40, 0xE049FB40, 0xE04AFB40, 0xE04BFB40, 0xE04CFB40, 0xE04DFB40, 0xE04EFB40, 0xE04FFB40, 0xE050FB40, 0xE051FB40, 0xE052FB40, 0xE053FB40, 0xE054FB40, 0xE055FB40, 0xE056FB40, 0xE057FB40, 0xE058FB40, 0xE059FB40, 0xE05AFB40, 0xE05BFB40, 0xE05CFB40, 0xE05DFB40, 0xE05EFB40, 0xE05FFB40, 0xE060FB40, 0xE061FB40, 0xE062FB40, 0xE063FB40, 0xE064FB40, 0xE065FB40, 0xE066FB40, 0xE067FB40, 0xE068FB40, 0xE069FB40, 0xE06AFB40, 0xE06BFB40, 0xE06CFB40, 0xE06DFB40, 0xE06EFB40, 0xE06FFB40, 0xE070FB40, 0xE071FB40, 0xE072FB40, 0xE073FB40, 0xE074FB40, 0xE075FB40, 0xE076FB40, 0xE077FB40, 0xE078FB40, 0xE079FB40, 0xE07AFB40, 0xE07BFB40, 0xE07CFB40, 0xE07DFB40, 0xE07EFB40, 0xE07FFB40, 0xE080FB40, 0xE081FB40, 0xE082FB40, 0xE083FB40, 0xE084FB40, 0xE085FB40, 0xE086FB40, 0xE087FB40, 0xE088FB40, 0xE089FB40, 0xE08AFB40, 0xE08BFB40, 0xE08CFB40, 0xE08DFB40, 0xE08EFB40, 0xE08FFB40, 0xE090FB40, 0xE091FB40, 0xE092FB40, 0xE093FB40, 0xE094FB40, 0xE095FB40, 0xE096FB40, 0xE097FB40, 0xE098FB40, 0xE099FB40, 0xE09AFB40, 0xE09BFB40, 0xE09CFB40, 0xE09DFB40, 0xE09EFB40, 0xE09FFB40, 0xE0A0FB40, 0xE0A1FB40, 0xE0A2FB40, 0xE0A3FB40, 0xE0A4FB40, 0xE0A5FB40, 0xE0A6FB40, 0xE0A7FB40, 0xE0A8FB40, 0xE0A9FB40, 0xE0AAFB40, 0xE0ABFB40, 0xE0ACFB40, 0xE0ADFB40, 0xE0AEFB40, 0xE0AFFB40, 0xE0B0FB40, 0xE0B1FB40, 0xE0B2FB40, 0xE0B3FB40, /* 600A */
+ 0xE0B4FB40, 0xE0B5FB40, 0xE0B6FB40, 0xE0B7FB40, 0xE0B8FB40, 0xE0B9FB40, 0xE0BAFB40, 0xE0BBFB40, 0xE0BCFB40, 0xE0BDFB40, 0xE0BEFB40, 0xE0BFFB40, 0xE0C0FB40, 0xE0C1FB40, 0xE0C2FB40, 0xE0C3FB40, 0xE0C4FB40, 0xE0C5FB40, 0xE0C6FB40, 0xE0C7FB40, 0xE0C8FB40, 0xE0C9FB40, 0xE0CAFB40, 0xE0CBFB40, 0xE0CCFB40, 0xE0CDFB40, 0xE0CEFB40, 0xE0CFFB40, 0xE0D0FB40, 0xE0D1FB40, 0xE0D2FB40, 0xE0D3FB40, 0xE0D4FB40, 0xE0D5FB40, 0xE0D6FB40, 0xE0D7FB40, 0xE0D8FB40, 0xE0D9FB40, 0xE0DAFB40, 0xE0DBFB40, 0xE0DCFB40, 0xE0DDFB40, 0xE0DEFB40, 0xE0DFFB40, 0xE0E0FB40, 0xE0E1FB40, 0xE0E2FB40, 0xE0E3FB40, 0xE0E4FB40, 0xE0E5FB40, 0xE0E6FB40, 0xE0E7FB40, 0xE0E8FB40, 0xE0E9FB40, 0xE0EAFB40, 0xE0EBFB40, 0xE0ECFB40, 0xE0EDFB40, 0xE0EEFB40, 0xE0EFFB40, 0xE0F0FB40, 0xE0F1FB40, 0xE0F2FB40, 0xE0F3FB40, 0xE0F4FB40, 0xE0F5FB40, 0xE0F6FB40, 0xE0F7FB40, 0xE0F8FB40, 0xE0F9FB40, 0xE0FAFB40, 0xE0FBFB40, 0xE0FCFB40, 0xE0FDFB40, 0xE0FEFB40, 0xE0FFFB40, 0xE100FB40, 0xE101FB40, 0xE102FB40, 0xE103FB40, 0xE104FB40, 0xE105FB40, 0xE106FB40, 0xE107FB40, 0xE108FB40, 0xE109FB40, 0xE10AFB40, 0xE10BFB40, 0xE10CFB40, 0xE10DFB40, 0xE10EFB40, 0xE10FFB40, 0xE110FB40, 0xE111FB40, 0xE112FB40, 0xE113FB40, 0xE114FB40, 0xE115FB40, 0xE116FB40, 0xE117FB40, 0xE118FB40, 0xE119FB40, 0xE11AFB40, 0xE11BFB40, 0xE11CFB40, 0xE11DFB40, 0xE11EFB40, 0xE11FFB40, 0xE120FB40, 0xE121FB40, 0xE122FB40, 0xE123FB40, 0xE124FB40, 0xE125FB40, 0xE126FB40, 0xE127FB40, 0xE128FB40, 0xE129FB40, 0xE12AFB40, 0xE12BFB40, 0xE12CFB40, 0xE12DFB40, 0xE12EFB40, 0xE12FFB40, 0xE130FB40, 0xE131FB40, 0xE132FB40, 0xE133FB40, 0xE134FB40, 0xE135FB40, 0xE136FB40, 0xE137FB40, 0xE138FB40, 0xE139FB40, 0xE13AFB40, 0xE13BFB40, 0xE13CFB40, 0xE13DFB40, 0xE13EFB40, 0xE13FFB40, 0xE140FB40, 0xE141FB40, 0xE142FB40, 0xE143FB40, 0xE144FB40, 0xE145FB40, 0xE146FB40, 0xE147FB40, 0xE148FB40, 0xE149FB40, 0xE14AFB40, 0xE14BFB40, 0xE14CFB40, 0xE14DFB40, 0xE14EFB40, 0xE14FFB40, 0xE150FB40, 0xE151FB40, 0xE152FB40, 0xE153FB40, 0xE154FB40, 0xE155FB40, 0xE156FB40, 0xE157FB40, 0xE158FB40, 0xE159FB40, 0xE15AFB40, 0xE15BFB40, 0xE15CFB40, 0xE15DFB40, /* 60B4 */
+ 0xE15EFB40, 0xE15FFB40, 0xE160FB40, 0xE161FB40, 0xE162FB40, 0xE163FB40, 0xE164FB40, 0xE165FB40, 0xE166FB40, 0xE167FB40, 0xE168FB40, 0xE169FB40, 0xE16AFB40, 0xE16BFB40, 0xE16CFB40, 0xE16DFB40, 0xE16EFB40, 0xE16FFB40, 0xE170FB40, 0xE171FB40, 0xE172FB40, 0xE173FB40, 0xE174FB40, 0xE175FB40, 0xE176FB40, 0xE177FB40, 0xE178FB40, 0xE179FB40, 0xE17AFB40, 0xE17BFB40, 0xE17CFB40, 0xE17DFB40, 0xE17EFB40, 0xE17FFB40, 0xE180FB40, 0xE181FB40, 0xE182FB40, 0xE183FB40, 0xE184FB40, 0xE185FB40, 0xE186FB40, 0xE187FB40, 0xE188FB40, 0xE189FB40, 0xE18AFB40, 0xE18BFB40, 0xE18CFB40, 0xE18DFB40, 0xE18EFB40, 0xE18FFB40, 0xE190FB40, 0xE191FB40, 0xE192FB40, 0xE193FB40, 0xE194FB40, 0xE195FB40, 0xE196FB40, 0xE197FB40, 0xE198FB40, 0xE199FB40, 0xE19AFB40, 0xE19BFB40, 0xE19CFB40, 0xE19DFB40, 0xE19EFB40, 0xE19FFB40, 0xE1A0FB40, 0xE1A1FB40, 0xE1A2FB40, 0xE1A3FB40, 0xE1A4FB40, 0xE1A5FB40, 0xE1A6FB40, 0xE1A7FB40, 0xE1A8FB40, 0xE1A9FB40, 0xE1AAFB40, 0xE1ABFB40, 0xE1ACFB40, 0xE1ADFB40, 0xE1AEFB40, 0xE1AFFB40, 0xE1B0FB40, 0xE1B1FB40, 0xE1B2FB40, 0xE1B3FB40, 0xE1B4FB40, 0xE1B5FB40, 0xE1B6FB40, 0xE1B7FB40, 0xE1B8FB40, 0xE1B9FB40, 0xE1BAFB40, 0xE1BBFB40, 0xE1BCFB40, 0xE1BDFB40, 0xE1BEFB40, 0xE1BFFB40, 0xE1C0FB40, 0xE1C1FB40, 0xE1C2FB40, 0xE1C3FB40, 0xE1C4FB40, 0xE1C5FB40, 0xE1C6FB40, 0xE1C7FB40, 0xE1C8FB40, 0xE1C9FB40, 0xE1CAFB40, 0xE1CBFB40, 0xE1CCFB40, 0xE1CDFB40, 0xE1CEFB40, 0xE1CFFB40, 0xE1D0FB40, 0xE1D1FB40, 0xE1D2FB40, 0xE1D3FB40, 0xE1D4FB40, 0xE1D5FB40, 0xE1D6FB40, 0xE1D7FB40, 0xE1D8FB40, 0xE1D9FB40, 0xE1DAFB40, 0xE1DBFB40, 0xE1DCFB40, 0xE1DDFB40, 0xE1DEFB40, 0xE1DFFB40, 0xE1E0FB40, 0xE1E1FB40, 0xE1E2FB40, 0xE1E3FB40, 0xE1E4FB40, 0xE1E5FB40, 0xE1E6FB40, 0xE1E7FB40, 0xE1E8FB40, 0xE1E9FB40, 0xE1EAFB40, 0xE1EBFB40, 0xE1ECFB40, 0xE1EDFB40, 0xE1EEFB40, 0xE1EFFB40, 0xE1F0FB40, 0xE1F1FB40, 0xE1F2FB40, 0xE1F3FB40, 0xE1F4FB40, 0xE1F5FB40, 0xE1F6FB40, 0xE1F7FB40, 0xE1F8FB40, 0xE1F9FB40, 0xE1FAFB40, 0xE1FBFB40, 0xE1FCFB40, 0xE1FDFB40, 0xE1FEFB40, 0xE1FFFB40, 0xE200FB40, 0xE201FB40, 0xE202FB40, 0xE203FB40, 0xE204FB40, 0xE205FB40, 0xE206FB40, 0xE207FB40, /* 615E */
+ 0xE208FB40, 0xE209FB40, 0xE20AFB40, 0xE20BFB40, 0xE20CFB40, 0xE20DFB40, 0xE20EFB40, 0xE20FFB40, 0xE210FB40, 0xE211FB40, 0xE212FB40, 0xE213FB40, 0xE214FB40, 0xE215FB40, 0xE216FB40, 0xE217FB40, 0xE218FB40, 0xE219FB40, 0xE21AFB40, 0xE21BFB40, 0xE21CFB40, 0xE21DFB40, 0xE21EFB40, 0xE21FFB40, 0xE220FB40, 0xE221FB40, 0xE222FB40, 0xE223FB40, 0xE224FB40, 0xE225FB40, 0xE226FB40, 0xE227FB40, 0xE228FB40, 0xE229FB40, 0xE22AFB40, 0xE22BFB40, 0xE22CFB40, 0xE22DFB40, 0xE22EFB40, 0xE22FFB40, 0xE230FB40, 0xE231FB40, 0xE232FB40, 0xE233FB40, 0xE234FB40, 0xE235FB40, 0xE236FB40, 0xE237FB40, 0xE238FB40, 0xE239FB40, 0xE23AFB40, 0xE23BFB40, 0xE23CFB40, 0xE23DFB40, 0xE23EFB40, 0xE23FFB40, 0xE240FB40, 0xE241FB40, 0xE242FB40, 0xE243FB40, 0xE244FB40, 0xE245FB40, 0xE246FB40, 0xE247FB40, 0xE248FB40, 0xE249FB40, 0xE24AFB40, 0xE24BFB40, 0xE24CFB40, 0xE24DFB40, 0xE24EFB40, 0xE24FFB40, 0xE250FB40, 0xE251FB40, 0xE252FB40, 0xE253FB40, 0xE254FB40, 0xE255FB40, 0xE256FB40, 0xE257FB40, 0xE258FB40, 0xE259FB40, 0xE25AFB40, 0xE25BFB40, 0xE25CFB40, 0xE25DFB40, 0xE25EFB40, 0xE25FFB40, 0xE260FB40, 0xE261FB40, 0xE262FB40, 0xE263FB40, 0xE264FB40, 0xE265FB40, 0xE266FB40, 0xE267FB40, 0xE268FB40, 0xE269FB40, 0xE26AFB40, 0xE26BFB40, 0xE26CFB40, 0xE26DFB40, 0xE26EFB40, 0xE26FFB40, 0xE270FB40, 0xE271FB40, 0xE272FB40, 0xE273FB40, 0xE274FB40, 0xE275FB40, 0xE276FB40, 0xE277FB40, 0xE278FB40, 0xE279FB40, 0xE27AFB40, 0xE27BFB40, 0xE27CFB40, 0xE27DFB40, 0xE27EFB40, 0xE27FFB40, 0xE280FB40, 0xE281FB40, 0xE282FB40, 0xE283FB40, 0xE284FB40, 0xE285FB40, 0xE286FB40, 0xE287FB40, 0xE288FB40, 0xE289FB40, 0xE28AFB40, 0xE28BFB40, 0xE28CFB40, 0xE28DFB40, 0xE28EFB40, 0xE28FFB40, 0xE290FB40, 0xE291FB40, 0xE292FB40, 0xE293FB40, 0xE294FB40, 0xE295FB40, 0xE296FB40, 0xE297FB40, 0xE298FB40, 0xE299FB40, 0xE29AFB40, 0xE29BFB40, 0xE29CFB40, 0xE29DFB40, 0xE29EFB40, 0xE29FFB40, 0xE2A0FB40, 0xE2A1FB40, 0xE2A2FB40, 0xE2A3FB40, 0xE2A4FB40, 0xE2A5FB40, 0xE2A6FB40, 0xE2A7FB40, 0xE2A8FB40, 0xE2A9FB40, 0xE2AAFB40, 0xE2ABFB40, 0xE2ACFB40, 0xE2ADFB40, 0xE2AEFB40, 0xE2AFFB40, 0xE2B0FB40, 0xE2B1FB40, /* 6208 */
+ 0xE2B2FB40, 0xE2B3FB40, 0xE2B4FB40, 0xE2B5FB40, 0xE2B6FB40, 0xE2B7FB40, 0xE2B8FB40, 0xE2B9FB40, 0xE2BAFB40, 0xE2BBFB40, 0xE2BCFB40, 0xE2BDFB40, 0xE2BEFB40, 0xE2BFFB40, 0xE2C0FB40, 0xE2C1FB40, 0xE2C2FB40, 0xE2C3FB40, 0xE2C4FB40, 0xE2C5FB40, 0xE2C6FB40, 0xE2C7FB40, 0xE2C8FB40, 0xE2C9FB40, 0xE2CAFB40, 0xE2CBFB40, 0xE2CCFB40, 0xE2CDFB40, 0xE2CEFB40, 0xE2CFFB40, 0xE2D0FB40, 0xE2D1FB40, 0xE2D2FB40, 0xE2D3FB40, 0xE2D4FB40, 0xE2D5FB40, 0xE2D6FB40, 0xE2D7FB40, 0xE2D8FB40, 0xE2D9FB40, 0xE2DAFB40, 0xE2DBFB40, 0xE2DCFB40, 0xE2DDFB40, 0xE2DEFB40, 0xE2DFFB40, 0xE2E0FB40, 0xE2E1FB40, 0xE2E2FB40, 0xE2E3FB40, 0xE2E4FB40, 0xE2E5FB40, 0xE2E6FB40, 0xE2E7FB40, 0xE2E8FB40, 0xE2E9FB40, 0xE2EAFB40, 0xE2EBFB40, 0xE2ECFB40, 0xE2EDFB40, 0xE2EEFB40, 0xE2EFFB40, 0xE2F0FB40, 0xE2F1FB40, 0xE2F2FB40, 0xE2F3FB40, 0xE2F4FB40, 0xE2F5FB40, 0xE2F6FB40, 0xE2F7FB40, 0xE2F8FB40, 0xE2F9FB40, 0xE2FAFB40, 0xE2FBFB40, 0xE2FCFB40, 0xE2FDFB40, 0xE2FEFB40, 0xE2FFFB40, 0xE300FB40, 0xE301FB40, 0xE302FB40, 0xE303FB40, 0xE304FB40, 0xE305FB40, 0xE306FB40, 0xE307FB40, 0xE308FB40, 0xE309FB40, 0xE30AFB40, 0xE30BFB40, 0xE30CFB40, 0xE30DFB40, 0xE30EFB40, 0xE30FFB40, 0xE310FB40, 0xE311FB40, 0xE312FB40, 0xE313FB40, 0xE314FB40, 0xE315FB40, 0xE316FB40, 0xE317FB40, 0xE318FB40, 0xE319FB40, 0xE31AFB40, 0xE31BFB40, 0xE31CFB40, 0xE31DFB40, 0xE31EFB40, 0xE31FFB40, 0xE320FB40, 0xE321FB40, 0xE322FB40, 0xE323FB40, 0xE324FB40, 0xE325FB40, 0xE326FB40, 0xE327FB40, 0xE328FB40, 0xE329FB40, 0xE32AFB40, 0xE32BFB40, 0xE32CFB40, 0xE32DFB40, 0xE32EFB40, 0xE32FFB40, 0xE330FB40, 0xE331FB40, 0xE332FB40, 0xE333FB40, 0xE334FB40, 0xE335FB40, 0xE336FB40, 0xE337FB40, 0xE338FB40, 0xE339FB40, 0xE33AFB40, 0xE33BFB40, 0xE33CFB40, 0xE33DFB40, 0xE33EFB40, 0xE33FFB40, 0xE340FB40, 0xE341FB40, 0xE342FB40, 0xE343FB40, 0xE344FB40, 0xE345FB40, 0xE346FB40, 0xE347FB40, 0xE348FB40, 0xE349FB40, 0xE34AFB40, 0xE34BFB40, 0xE34CFB40, 0xE34DFB40, 0xE34EFB40, 0xE34FFB40, 0xE350FB40, 0xE351FB40, 0xE352FB40, 0xE353FB40, 0xE354FB40, 0xE355FB40, 0xE356FB40, 0xE357FB40, 0xE358FB40, 0xE359FB40, 0xE35AFB40, 0xE35BFB40, /* 62B2 */
+ 0xE35CFB40, 0xE35DFB40, 0xE35EFB40, 0xE35FFB40, 0xE360FB40, 0xE361FB40, 0xE362FB40, 0xE363FB40, 0xE364FB40, 0xE365FB40, 0xE366FB40, 0xE367FB40, 0xE368FB40, 0xE369FB40, 0xE36AFB40, 0xE36BFB40, 0xE36CFB40, 0xE36DFB40, 0xE36EFB40, 0xE36FFB40, 0xE370FB40, 0xE371FB40, 0xE372FB40, 0xE373FB40, 0xE374FB40, 0xE375FB40, 0xE376FB40, 0xE377FB40, 0xE378FB40, 0xE379FB40, 0xE37AFB40, 0xE37BFB40, 0xE37CFB40, 0xE37DFB40, 0xE37EFB40, 0xE37FFB40, 0xE380FB40, 0xE381FB40, 0xE382FB40, 0xE383FB40, 0xE384FB40, 0xE385FB40, 0xE386FB40, 0xE387FB40, 0xE388FB40, 0xE389FB40, 0xE38AFB40, 0xE38BFB40, 0xE38CFB40, 0xE38DFB40, 0xE38EFB40, 0xE38FFB40, 0xE390FB40, 0xE391FB40, 0xE392FB40, 0xE393FB40, 0xE394FB40, 0xE395FB40, 0xE396FB40, 0xE397FB40, 0xE398FB40, 0xE399FB40, 0xE39AFB40, 0xE39BFB40, 0xE39CFB40, 0xE39DFB40, 0xE39EFB40, 0xE39FFB40, 0xE3A0FB40, 0xE3A1FB40, 0xE3A2FB40, 0xE3A3FB40, 0xE3A4FB40, 0xE3A5FB40, 0xE3A6FB40, 0xE3A7FB40, 0xE3A8FB40, 0xE3A9FB40, 0xE3AAFB40, 0xE3ABFB40, 0xE3ACFB40, 0xE3ADFB40, 0xE3AEFB40, 0xE3AFFB40, 0xE3B0FB40, 0xE3B1FB40, 0xE3B2FB40, 0xE3B3FB40, 0xE3B4FB40, 0xE3B5FB40, 0xE3B6FB40, 0xE3B7FB40, 0xE3B8FB40, 0xE3B9FB40, 0xE3BAFB40, 0xE3BBFB40, 0xE3BCFB40, 0xE3BDFB40, 0xE3BEFB40, 0xE3BFFB40, 0xE3C0FB40, 0xE3C1FB40, 0xE3C2FB40, 0xE3C3FB40, 0xE3C4FB40, 0xE3C5FB40, 0xE3C6FB40, 0xE3C7FB40, 0xE3C8FB40, 0xE3C9FB40, 0xE3CAFB40, 0xE3CBFB40, 0xE3CCFB40, 0xE3CDFB40, 0xE3CEFB40, 0xE3CFFB40, 0xE3D0FB40, 0xE3D1FB40, 0xE3D2FB40, 0xE3D3FB40, 0xE3D4FB40, 0xE3D5FB40, 0xE3D6FB40, 0xE3D7FB40, 0xE3D8FB40, 0xE3D9FB40, 0xE3DAFB40, 0xE3DBFB40, 0xE3DCFB40, 0xE3DDFB40, 0xE3DEFB40, 0xE3DFFB40, 0xE3E0FB40, 0xE3E1FB40, 0xE3E2FB40, 0xE3E3FB40, 0xE3E4FB40, 0xE3E5FB40, 0xE3E6FB40, 0xE3E7FB40, 0xE3E8FB40, 0xE3E9FB40, 0xE3EAFB40, 0xE3EBFB40, 0xE3ECFB40, 0xE3EDFB40, 0xE3EEFB40, 0xE3EFFB40, 0xE3F0FB40, 0xE3F1FB40, 0xE3F2FB40, 0xE3F3FB40, 0xE3F4FB40, 0xE3F5FB40, 0xE3F6FB40, 0xE3F7FB40, 0xE3F8FB40, 0xE3F9FB40, 0xE3FAFB40, 0xE3FBFB40, 0xE3FCFB40, 0xE3FDFB40, 0xE3FEFB40, 0xE3FFFB40, 0xE400FB40, 0xE401FB40, 0xE402FB40, 0xE403FB40, 0xE404FB40, 0xE405FB40, /* 635C */
+ 0xE406FB40, 0xE407FB40, 0xE408FB40, 0xE409FB40, 0xE40AFB40, 0xE40BFB40, 0xE40CFB40, 0xE40DFB40, 0xE40EFB40, 0xE40FFB40, 0xE410FB40, 0xE411FB40, 0xE412FB40, 0xE413FB40, 0xE414FB40, 0xE415FB40, 0xE416FB40, 0xE417FB40, 0xE418FB40, 0xE419FB40, 0xE41AFB40, 0xE41BFB40, 0xE41CFB40, 0xE41DFB40, 0xE41EFB40, 0xE41FFB40, 0xE420FB40, 0xE421FB40, 0xE422FB40, 0xE423FB40, 0xE424FB40, 0xE425FB40, 0xE426FB40, 0xE427FB40, 0xE428FB40, 0xE429FB40, 0xE42AFB40, 0xE42BFB40, 0xE42CFB40, 0xE42DFB40, 0xE42EFB40, 0xE42FFB40, 0xE430FB40, 0xE431FB40, 0xE432FB40, 0xE433FB40, 0xE434FB40, 0xE435FB40, 0xE436FB40, 0xE437FB40, 0xE438FB40, 0xE439FB40, 0xE43AFB40, 0xE43BFB40, 0xE43CFB40, 0xE43DFB40, 0xE43EFB40, 0xE43FFB40, 0xE440FB40, 0xE441FB40, 0xE442FB40, 0xE443FB40, 0xE444FB40, 0xE445FB40, 0xE446FB40, 0xE447FB40, 0xE448FB40, 0xE449FB40, 0xE44AFB40, 0xE44BFB40, 0xE44CFB40, 0xE44DFB40, 0xE44EFB40, 0xE44FFB40, 0xE450FB40, 0xE451FB40, 0xE452FB40, 0xE453FB40, 0xE454FB40, 0xE455FB40, 0xE456FB40, 0xE457FB40, 0xE458FB40, 0xE459FB40, 0xE45AFB40, 0xE45BFB40, 0xE45CFB40, 0xE45DFB40, 0xE45EFB40, 0xE45FFB40, 0xE460FB40, 0xE461FB40, 0xE462FB40, 0xE463FB40, 0xE464FB40, 0xE465FB40, 0xE466FB40, 0xE467FB40, 0xE468FB40, 0xE469FB40, 0xE46AFB40, 0xE46BFB40, 0xE46CFB40, 0xE46DFB40, 0xE46EFB40, 0xE46FFB40, 0xE470FB40, 0xE471FB40, 0xE472FB40, 0xE473FB40, 0xE474FB40, 0xE475FB40, 0xE476FB40, 0xE477FB40, 0xE478FB40, 0xE479FB40, 0xE47AFB40, 0xE47BFB40, 0xE47CFB40, 0xE47DFB40, 0xE47EFB40, 0xE47FFB40, 0xE480FB40, 0xE481FB40, 0xE482FB40, 0xE483FB40, 0xE484FB40, 0xE485FB40, 0xE486FB40, 0xE487FB40, 0xE488FB40, 0xE489FB40, 0xE48AFB40, 0xE48BFB40, 0xE48CFB40, 0xE48DFB40, 0xE48EFB40, 0xE48FFB40, 0xE490FB40, 0xE491FB40, 0xE492FB40, 0xE493FB40, 0xE494FB40, 0xE495FB40, 0xE496FB40, 0xE497FB40, 0xE498FB40, 0xE499FB40, 0xE49AFB40, 0xE49BFB40, 0xE49CFB40, 0xE49DFB40, 0xE49EFB40, 0xE49FFB40, 0xE4A0FB40, 0xE4A1FB40, 0xE4A2FB40, 0xE4A3FB40, 0xE4A4FB40, 0xE4A5FB40, 0xE4A6FB40, 0xE4A7FB40, 0xE4A8FB40, 0xE4A9FB40, 0xE4AAFB40, 0xE4ABFB40, 0xE4ACFB40, 0xE4ADFB40, 0xE4AEFB40, 0xE4AFFB40, /* 6406 */
+ 0xE4B0FB40, 0xE4B1FB40, 0xE4B2FB40, 0xE4B3FB40, 0xE4B4FB40, 0xE4B5FB40, 0xE4B6FB40, 0xE4B7FB40, 0xE4B8FB40, 0xE4B9FB40, 0xE4BAFB40, 0xE4BBFB40, 0xE4BCFB40, 0xE4BDFB40, 0xE4BEFB40, 0xE4BFFB40, 0xE4C0FB40, 0xE4C1FB40, 0xE4C2FB40, 0xE4C3FB40, 0xE4C4FB40, 0xE4C5FB40, 0xE4C6FB40, 0xE4C7FB40, 0xE4C8FB40, 0xE4C9FB40, 0xE4CAFB40, 0xE4CBFB40, 0xE4CCFB40, 0xE4CDFB40, 0xE4CEFB40, 0xE4CFFB40, 0xE4D0FB40, 0xE4D1FB40, 0xE4D2FB40, 0xE4D3FB40, 0xE4D4FB40, 0xE4D5FB40, 0xE4D6FB40, 0xE4D7FB40, 0xE4D8FB40, 0xE4D9FB40, 0xE4DAFB40, 0xE4DBFB40, 0xE4DCFB40, 0xE4DDFB40, 0xE4DEFB40, 0xE4DFFB40, 0xE4E0FB40, 0xE4E1FB40, 0xE4E2FB40, 0xE4E3FB40, 0xE4E4FB40, 0xE4E5FB40, 0xE4E6FB40, 0xE4E7FB40, 0xE4E8FB40, 0xE4E9FB40, 0xE4EAFB40, 0xE4EBFB40, 0xE4ECFB40, 0xE4EDFB40, 0xE4EEFB40, 0xE4EFFB40, 0xE4F0FB40, 0xE4F1FB40, 0xE4F2FB40, 0xE4F3FB40, 0xE4F4FB40, 0xE4F5FB40, 0xE4F6FB40, 0xE4F7FB40, 0xE4F8FB40, 0xE4F9FB40, 0xE4FAFB40, 0xE4FBFB40, 0xE4FCFB40, 0xE4FDFB40, 0xE4FEFB40, 0xE4FFFB40, 0xE500FB40, 0xE501FB40, 0xE502FB40, 0xE503FB40, 0xE504FB40, 0xE505FB40, 0xE506FB40, 0xE507FB40, 0xE508FB40, 0xE509FB40, 0xE50AFB40, 0xE50BFB40, 0xE50CFB40, 0xE50DFB40, 0xE50EFB40, 0xE50FFB40, 0xE510FB40, 0xE511FB40, 0xE512FB40, 0xE513FB40, 0xE514FB40, 0xE515FB40, 0xE516FB40, 0xE517FB40, 0xE518FB40, 0xE519FB40, 0xE51AFB40, 0xE51BFB40, 0xE51CFB40, 0xE51DFB40, 0xE51EFB40, 0xE51FFB40, 0xE520FB40, 0xE521FB40, 0xE522FB40, 0xE523FB40, 0xE524FB40, 0xE525FB40, 0xE526FB40, 0xE527FB40, 0xE528FB40, 0xE529FB40, 0xE52AFB40, 0xE52BFB40, 0xE52CFB40, 0xE52DFB40, 0xE52EFB40, 0xE52FFB40, 0xE530FB40, 0xE531FB40, 0xE532FB40, 0xE533FB40, 0xE534FB40, 0xE535FB40, 0xE536FB40, 0xE537FB40, 0xE538FB40, 0xE539FB40, 0xE53AFB40, 0xE53BFB40, 0xE53CFB40, 0xE53DFB40, 0xE53EFB40, 0xE53FFB40, 0xE540FB40, 0xE541FB40, 0xE542FB40, 0xE543FB40, 0xE544FB40, 0xE545FB40, 0xE546FB40, 0xE547FB40, 0xE548FB40, 0xE549FB40, 0xE54AFB40, 0xE54BFB40, 0xE54CFB40, 0xE54DFB40, 0xE54EFB40, 0xE54FFB40, 0xE550FB40, 0xE551FB40, 0xE552FB40, 0xE553FB40, 0xE554FB40, 0xE555FB40, 0xE556FB40, 0xE557FB40, 0xE558FB40, 0xE559FB40, /* 64B0 */
+ 0xE55AFB40, 0xE55BFB40, 0xE55CFB40, 0xE55DFB40, 0xE55EFB40, 0xE55FFB40, 0xE560FB40, 0xE561FB40, 0xE562FB40, 0xE563FB40, 0xE564FB40, 0xE565FB40, 0xE566FB40, 0xE567FB40, 0xE568FB40, 0xE569FB40, 0xE56AFB40, 0xE56BFB40, 0xE56CFB40, 0xE56DFB40, 0xE56EFB40, 0xE56FFB40, 0xE570FB40, 0xE571FB40, 0xE572FB40, 0xE573FB40, 0xE574FB40, 0xE575FB40, 0xE576FB40, 0xE577FB40, 0xE578FB40, 0xE579FB40, 0xE57AFB40, 0xE57BFB40, 0xE57CFB40, 0xE57DFB40, 0xE57EFB40, 0xE57FFB40, 0xE580FB40, 0xE581FB40, 0xE582FB40, 0xE583FB40, 0xE584FB40, 0xE585FB40, 0xE586FB40, 0xE587FB40, 0xE588FB40, 0xE589FB40, 0xE58AFB40, 0xE58BFB40, 0xE58CFB40, 0xE58DFB40, 0xE58EFB40, 0xE58FFB40, 0xE590FB40, 0xE591FB40, 0xE592FB40, 0xE593FB40, 0xE594FB40, 0xE595FB40, 0xE596FB40, 0xE597FB40, 0xE598FB40, 0xE599FB40, 0xE59AFB40, 0xE59BFB40, 0xE59CFB40, 0xE59DFB40, 0xE59EFB40, 0xE59FFB40, 0xE5A0FB40, 0xE5A1FB40, 0xE5A2FB40, 0xE5A3FB40, 0xE5A4FB40, 0xE5A5FB40, 0xE5A6FB40, 0xE5A7FB40, 0xE5A8FB40, 0xE5A9FB40, 0xE5AAFB40, 0xE5ABFB40, 0xE5ACFB40, 0xE5ADFB40, 0xE5AEFB40, 0xE5AFFB40, 0xE5B0FB40, 0xE5B1FB40, 0xE5B2FB40, 0xE5B3FB40, 0xE5B4FB40, 0xE5B5FB40, 0xE5B6FB40, 0xE5B7FB40, 0xE5B8FB40, 0xE5B9FB40, 0xE5BAFB40, 0xE5BBFB40, 0xE5BCFB40, 0xE5BDFB40, 0xE5BEFB40, 0xE5BFFB40, 0xE5C0FB40, 0xE5C1FB40, 0xE5C2FB40, 0xE5C3FB40, 0xE5C4FB40, 0xE5C5FB40, 0xE5C6FB40, 0xE5C7FB40, 0xE5C8FB40, 0xE5C9FB40, 0xE5CAFB40, 0xE5CBFB40, 0xE5CCFB40, 0xE5CDFB40, 0xE5CEFB40, 0xE5CFFB40, 0xE5D0FB40, 0xE5D1FB40, 0xE5D2FB40, 0xE5D3FB40, 0xE5D4FB40, 0xE5D5FB40, 0xE5D6FB40, 0xE5D7FB40, 0xE5D8FB40, 0xE5D9FB40, 0xE5DAFB40, 0xE5DBFB40, 0xE5DCFB40, 0xE5DDFB40, 0xE5DEFB40, 0xE5DFFB40, 0xE5E0FB40, 0xE5E1FB40, 0xE5E2FB40, 0xE5E3FB40, 0xE5E4FB40, 0xE5E5FB40, 0xE5E6FB40, 0xE5E7FB40, 0xE5E8FB40, 0xE5E9FB40, 0xE5EAFB40, 0xE5EBFB40, 0xE5ECFB40, 0xE5EDFB40, 0xE5EEFB40, 0xE5EFFB40, 0xE5F0FB40, 0xE5F1FB40, 0xE5F2FB40, 0xE5F3FB40, 0xE5F4FB40, 0xE5F5FB40, 0xE5F6FB40, 0xE5F7FB40, 0xE5F8FB40, 0xE5F9FB40, 0xE5FAFB40, 0xE5FBFB40, 0xE5FCFB40, 0xE5FDFB40, 0xE5FEFB40, 0xE5FFFB40, 0xE600FB40, 0xE601FB40, 0xE602FB40, 0xE603FB40, /* 655A */
+ 0xE604FB40, 0xE605FB40, 0xE606FB40, 0xE607FB40, 0xE608FB40, 0xE609FB40, 0xE60AFB40, 0xE60BFB40, 0xE60CFB40, 0xE60DFB40, 0xE60EFB40, 0xE60FFB40, 0xE610FB40, 0xE611FB40, 0xE612FB40, 0xE613FB40, 0xE614FB40, 0xE615FB40, 0xE616FB40, 0xE617FB40, 0xE618FB40, 0xE619FB40, 0xE61AFB40, 0xE61BFB40, 0xE61CFB40, 0xE61DFB40, 0xE61EFB40, 0xE61FFB40, 0xE620FB40, 0xE621FB40, 0xE622FB40, 0xE623FB40, 0xE624FB40, 0xE625FB40, 0xE626FB40, 0xE627FB40, 0xE628FB40, 0xE629FB40, 0xE62AFB40, 0xE62BFB40, 0xE62CFB40, 0xE62DFB40, 0xE62EFB40, 0xE62FFB40, 0xE630FB40, 0xE631FB40, 0xE632FB40, 0xE633FB40, 0xE634FB40, 0xE635FB40, 0xE636FB40, 0xE637FB40, 0xE638FB40, 0xE639FB40, 0xE63AFB40, 0xE63BFB40, 0xE63CFB40, 0xE63DFB40, 0xE63EFB40, 0xE63FFB40, 0xE640FB40, 0xE641FB40, 0xE642FB40, 0xE643FB40, 0xE644FB40, 0xE645FB40, 0xE646FB40, 0xE647FB40, 0xE648FB40, 0xE649FB40, 0xE64AFB40, 0xE64BFB40, 0xE64CFB40, 0xE64DFB40, 0xE64EFB40, 0xE64FFB40, 0xE650FB40, 0xE651FB40, 0xE652FB40, 0xE653FB40, 0xE654FB40, 0xE655FB40, 0xE656FB40, 0xE657FB40, 0xE658FB40, 0xE659FB40, 0xE65AFB40, 0xE65BFB40, 0xE65CFB40, 0xE65DFB40, 0xE65EFB40, 0xE65FFB40, 0xE660FB40, 0xE661FB40, 0xE662FB40, 0xE663FB40, 0xE664FB40, 0xE665FB40, 0xE666FB40, 0xE667FB40, 0xE668FB40, 0xE669FB40, 0xE66AFB40, 0xE66BFB40, 0xE66CFB40, 0xE66DFB40, 0xE66EFB40, 0xE66FFB40, 0xE670FB40, 0xE671FB40, 0xE672FB40, 0xE673FB40, 0xE674FB40, 0xE675FB40, 0xE676FB40, 0xE677FB40, 0xE678FB40, 0xE679FB40, 0xE67AFB40, 0xE67BFB40, 0xE67CFB40, 0xE67DFB40, 0xE67EFB40, 0xE67FFB40, 0xE680FB40, 0xE681FB40, 0xE682FB40, 0xE683FB40, 0xE684FB40, 0xE685FB40, 0xE686FB40, 0xE687FB40, 0xE688FB40, 0xE689FB40, 0xE68AFB40, 0xE68BFB40, 0xE68CFB40, 0xE68DFB40, 0xE68EFB40, 0xE68FFB40, 0xE690FB40, 0xE691FB40, 0xE692FB40, 0xE693FB40, 0xE694FB40, 0xE695FB40, 0xE696FB40, 0xE697FB40, 0xE698FB40, 0xE699FB40, 0xE69AFB40, 0xE69BFB40, 0xE69CFB40, 0xE69DFB40, 0xE69EFB40, 0xE69FFB40, 0xE6A0FB40, 0xE6A1FB40, 0xE6A2FB40, 0xE6A3FB40, 0xE6A4FB40, 0xE6A5FB40, 0xE6A6FB40, 0xE6A7FB40, 0xE6A8FB40, 0xE6A9FB40, 0xE6AAFB40, 0xE6ABFB40, 0xE6ACFB40, 0xE6ADFB40, /* 6604 */
+ 0xE6AEFB40, 0xE6AFFB40, 0xE6B0FB40, 0xE6B1FB40, 0xE6B2FB40, 0xE6B3FB40, 0xE6B4FB40, 0xE6B5FB40, 0xE6B6FB40, 0xE6B7FB40, 0xE6B8FB40, 0xE6B9FB40, 0xE6BAFB40, 0xE6BBFB40, 0xE6BCFB40, 0xE6BDFB40, 0xE6BEFB40, 0xE6BFFB40, 0xE6C0FB40, 0xE6C1FB40, 0xE6C2FB40, 0xE6C3FB40, 0xE6C4FB40, 0xE6C5FB40, 0xE6C6FB40, 0xE6C7FB40, 0xE6C8FB40, 0xE6C9FB40, 0xE6CAFB40, 0xE6CBFB40, 0xE6CCFB40, 0xE6CDFB40, 0xE6CEFB40, 0xE6CFFB40, 0xE6D0FB40, 0xE6D1FB40, 0xE6D2FB40, 0xE6D3FB40, 0xE6D4FB40, 0xE6D5FB40, 0xE6D6FB40, 0xE6D7FB40, 0xE6D8FB40, 0xE6D9FB40, 0xE6DAFB40, 0xE6DBFB40, 0xE6DCFB40, 0xE6DDFB40, 0xE6DEFB40, 0xE6DFFB40, 0xE6E0FB40, 0xE6E1FB40, 0xE6E2FB40, 0xE6E3FB40, 0xE6E4FB40, 0xE6E5FB40, 0xE6E6FB40, 0xE6E7FB40, 0xE6E8FB40, 0xE6E9FB40, 0xE6EAFB40, 0xE6EBFB40, 0xE6ECFB40, 0xE6EDFB40, 0xE6EEFB40, 0xE6EFFB40, 0xE6F0FB40, 0xE6F1FB40, 0xE6F2FB40, 0xE6F3FB40, 0xE6F4FB40, 0xE6F5FB40, 0xE6F6FB40, 0xE6F7FB40, 0xE6F8FB40, 0xE6F9FB40, 0xE6FAFB40, 0xE6FBFB40, 0xE6FCFB40, 0xE6FDFB40, 0xE6FEFB40, 0xE6FFFB40, 0xE700FB40, 0xE701FB40, 0xE702FB40, 0xE703FB40, 0xE704FB40, 0xE705FB40, 0xE706FB40, 0xE707FB40, 0xE708FB40, 0xE709FB40, 0xE70AFB40, 0xE70BFB40, 0xE70CFB40, 0xE70DFB40, 0xE70EFB40, 0xE70FFB40, 0xE710FB40, 0xE711FB40, 0xE712FB40, 0xE713FB40, 0xE714FB40, 0xE715FB40, 0xE716FB40, 0xE717FB40, 0xE718FB40, 0xE719FB40, 0xE71AFB40, 0xE71BFB40, 0xE71CFB40, 0xE71DFB40, 0xE71EFB40, 0xE71FFB40, 0xE720FB40, 0xE721FB40, 0xE722FB40, 0xE723FB40, 0xE724FB40, 0xE725FB40, 0xE726FB40, 0xE727FB40, 0xE728FB40, 0xE729FB40, 0xE72AFB40, 0xE72BFB40, 0xE72CFB40, 0xE72DFB40, 0xE72EFB40, 0xE72FFB40, 0xE730FB40, 0xE731FB40, 0xE732FB40, 0xE733FB40, 0xE734FB40, 0xE735FB40, 0xE736FB40, 0xE737FB40, 0xE738FB40, 0xE739FB40, 0xE73AFB40, 0xE73BFB40, 0xE73CFB40, 0xE73DFB40, 0xE73EFB40, 0xE73FFB40, 0xE740FB40, 0xE741FB40, 0xE742FB40, 0xE743FB40, 0xE744FB40, 0xE745FB40, 0xE746FB40, 0xE747FB40, 0xE748FB40, 0xE749FB40, 0xE74AFB40, 0xE74BFB40, 0xE74CFB40, 0xE74DFB40, 0xE74EFB40, 0xE74FFB40, 0xE750FB40, 0xE751FB40, 0xE752FB40, 0xE753FB40, 0xE754FB40, 0xE755FB40, 0xE756FB40, 0xE757FB40, /* 66AE */
+ 0xE758FB40, 0xE759FB40, 0xE75AFB40, 0xE75BFB40, 0xE75CFB40, 0xE75DFB40, 0xE75EFB40, 0xE75FFB40, 0xE760FB40, 0xE761FB40, 0xE762FB40, 0xE763FB40, 0xE764FB40, 0xE765FB40, 0xE766FB40, 0xE767FB40, 0xE768FB40, 0xE769FB40, 0xE76AFB40, 0xE76BFB40, 0xE76CFB40, 0xE76DFB40, 0xE76EFB40, 0xE76FFB40, 0xE770FB40, 0xE771FB40, 0xE772FB40, 0xE773FB40, 0xE774FB40, 0xE775FB40, 0xE776FB40, 0xE777FB40, 0xE778FB40, 0xE779FB40, 0xE77AFB40, 0xE77BFB40, 0xE77CFB40, 0xE77DFB40, 0xE77EFB40, 0xE77FFB40, 0xE780FB40, 0xE781FB40, 0xE782FB40, 0xE783FB40, 0xE784FB40, 0xE785FB40, 0xE786FB40, 0xE787FB40, 0xE788FB40, 0xE789FB40, 0xE78AFB40, 0xE78BFB40, 0xE78CFB40, 0xE78DFB40, 0xE78EFB40, 0xE78FFB40, 0xE790FB40, 0xE791FB40, 0xE792FB40, 0xE793FB40, 0xE794FB40, 0xE795FB40, 0xE796FB40, 0xE797FB40, 0xE798FB40, 0xE799FB40, 0xE79AFB40, 0xE79BFB40, 0xE79CFB40, 0xE79DFB40, 0xE79EFB40, 0xE79FFB40, 0xE7A0FB40, 0xE7A1FB40, 0xE7A2FB40, 0xE7A3FB40, 0xE7A4FB40, 0xE7A5FB40, 0xE7A6FB40, 0xE7A7FB40, 0xE7A8FB40, 0xE7A9FB40, 0xE7AAFB40, 0xE7ABFB40, 0xE7ACFB40, 0xE7ADFB40, 0xE7AEFB40, 0xE7AFFB40, 0xE7B0FB40, 0xE7B1FB40, 0xE7B2FB40, 0xE7B3FB40, 0xE7B4FB40, 0xE7B5FB40, 0xE7B6FB40, 0xE7B7FB40, 0xE7B8FB40, 0xE7B9FB40, 0xE7BAFB40, 0xE7BBFB40, 0xE7BCFB40, 0xE7BDFB40, 0xE7BEFB40, 0xE7BFFB40, 0xE7C0FB40, 0xE7C1FB40, 0xE7C2FB40, 0xE7C3FB40, 0xE7C4FB40, 0xE7C5FB40, 0xE7C6FB40, 0xE7C7FB40, 0xE7C8FB40, 0xE7C9FB40, 0xE7CAFB40, 0xE7CBFB40, 0xE7CCFB40, 0xE7CDFB40, 0xE7CEFB40, 0xE7CFFB40, 0xE7D0FB40, 0xE7D1FB40, 0xE7D2FB40, 0xE7D3FB40, 0xE7D4FB40, 0xE7D5FB40, 0xE7D6FB40, 0xE7D7FB40, 0xE7D8FB40, 0xE7D9FB40, 0xE7DAFB40, 0xE7DBFB40, 0xE7DCFB40, 0xE7DDFB40, 0xE7DEFB40, 0xE7DFFB40, 0xE7E0FB40, 0xE7E1FB40, 0xE7E2FB40, 0xE7E3FB40, 0xE7E4FB40, 0xE7E5FB40, 0xE7E6FB40, 0xE7E7FB40, 0xE7E8FB40, 0xE7E9FB40, 0xE7EAFB40, 0xE7EBFB40, 0xE7ECFB40, 0xE7EDFB40, 0xE7EEFB40, 0xE7EFFB40, 0xE7F0FB40, 0xE7F1FB40, 0xE7F2FB40, 0xE7F3FB40, 0xE7F4FB40, 0xE7F5FB40, 0xE7F6FB40, 0xE7F7FB40, 0xE7F8FB40, 0xE7F9FB40, 0xE7FAFB40, 0xE7FBFB40, 0xE7FCFB40, 0xE7FDFB40, 0xE7FEFB40, 0xE7FFFB40, 0xE800FB40, 0xE801FB40, /* 6758 */
+ 0xE802FB40, 0xE803FB40, 0xE804FB40, 0xE805FB40, 0xE806FB40, 0xE807FB40, 0xE808FB40, 0xE809FB40, 0xE80AFB40, 0xE80BFB40, 0xE80CFB40, 0xE80DFB40, 0xE80EFB40, 0xE80FFB40, 0xE810FB40, 0xE811FB40, 0xE812FB40, 0xE813FB40, 0xE814FB40, 0xE815FB40, 0xE816FB40, 0xE817FB40, 0xE818FB40, 0xE819FB40, 0xE81AFB40, 0xE81BFB40, 0xE81CFB40, 0xE81DFB40, 0xE81EFB40, 0xE81FFB40, 0xE820FB40, 0xE821FB40, 0xE822FB40, 0xE823FB40, 0xE824FB40, 0xE825FB40, 0xE826FB40, 0xE827FB40, 0xE828FB40, 0xE829FB40, 0xE82AFB40, 0xE82BFB40, 0xE82CFB40, 0xE82DFB40, 0xE82EFB40, 0xE82FFB40, 0xE830FB40, 0xE831FB40, 0xE832FB40, 0xE833FB40, 0xE834FB40, 0xE835FB40, 0xE836FB40, 0xE837FB40, 0xE838FB40, 0xE839FB40, 0xE83AFB40, 0xE83BFB40, 0xE83CFB40, 0xE83DFB40, 0xE83EFB40, 0xE83FFB40, 0xE840FB40, 0xE841FB40, 0xE842FB40, 0xE843FB40, 0xE844FB40, 0xE845FB40, 0xE846FB40, 0xE847FB40, 0xE848FB40, 0xE849FB40, 0xE84AFB40, 0xE84BFB40, 0xE84CFB40, 0xE84DFB40, 0xE84EFB40, 0xE84FFB40, 0xE850FB40, 0xE851FB40, 0xE852FB40, 0xE853FB40, 0xE854FB40, 0xE855FB40, 0xE856FB40, 0xE857FB40, 0xE858FB40, 0xE859FB40, 0xE85AFB40, 0xE85BFB40, 0xE85CFB40, 0xE85DFB40, 0xE85EFB40, 0xE85FFB40, 0xE860FB40, 0xE861FB40, 0xE862FB40, 0xE863FB40, 0xE864FB40, 0xE865FB40, 0xE866FB40, 0xE867FB40, 0xE868FB40, 0xE869FB40, 0xE86AFB40, 0xE86BFB40, 0xE86CFB40, 0xE86DFB40, 0xE86EFB40, 0xE86FFB40, 0xE870FB40, 0xE871FB40, 0xE872FB40, 0xE873FB40, 0xE874FB40, 0xE875FB40, 0xE876FB40, 0xE877FB40, 0xE878FB40, 0xE879FB40, 0xE87AFB40, 0xE87BFB40, 0xE87CFB40, 0xE87DFB40, 0xE87EFB40, 0xE87FFB40, 0xE880FB40, 0xE881FB40, 0xE882FB40, 0xE883FB40, 0xE884FB40, 0xE885FB40, 0xE886FB40, 0xE887FB40, 0xE888FB40, 0xE889FB40, 0xE88AFB40, 0xE88BFB40, 0xE88CFB40, 0xE88DFB40, 0xE88EFB40, 0xE88FFB40, 0xE890FB40, 0xE891FB40, 0xE892FB40, 0xE893FB40, 0xE894FB40, 0xE895FB40, 0xE896FB40, 0xE897FB40, 0xE898FB40, 0xE899FB40, 0xE89AFB40, 0xE89BFB40, 0xE89CFB40, 0xE89DFB40, 0xE89EFB40, 0xE89FFB40, 0xE8A0FB40, 0xE8A1FB40, 0xE8A2FB40, 0xE8A3FB40, 0xE8A4FB40, 0xE8A5FB40, 0xE8A6FB40, 0xE8A7FB40, 0xE8A8FB40, 0xE8A9FB40, 0xE8AAFB40, 0xE8ABFB40, /* 6802 */
+ 0xE8ACFB40, 0xE8ADFB40, 0xE8AEFB40, 0xE8AFFB40, 0xE8B0FB40, 0xE8B1FB40, 0xE8B2FB40, 0xE8B3FB40, 0xE8B4FB40, 0xE8B5FB40, 0xE8B6FB40, 0xE8B7FB40, 0xE8B8FB40, 0xE8B9FB40, 0xE8BAFB40, 0xE8BBFB40, 0xE8BCFB40, 0xE8BDFB40, 0xE8BEFB40, 0xE8BFFB40, 0xE8C0FB40, 0xE8C1FB40, 0xE8C2FB40, 0xE8C3FB40, 0xE8C4FB40, 0xE8C5FB40, 0xE8C6FB40, 0xE8C7FB40, 0xE8C8FB40, 0xE8C9FB40, 0xE8CAFB40, 0xE8CBFB40, 0xE8CCFB40, 0xE8CDFB40, 0xE8CEFB40, 0xE8CFFB40, 0xE8D0FB40, 0xE8D1FB40, 0xE8D2FB40, 0xE8D3FB40, 0xE8D4FB40, 0xE8D5FB40, 0xE8D6FB40, 0xE8D7FB40, 0xE8D8FB40, 0xE8D9FB40, 0xE8DAFB40, 0xE8DBFB40, 0xE8DCFB40, 0xE8DDFB40, 0xE8DEFB40, 0xE8DFFB40, 0xE8E0FB40, 0xE8E1FB40, 0xE8E2FB40, 0xE8E3FB40, 0xE8E4FB40, 0xE8E5FB40, 0xE8E6FB40, 0xE8E7FB40, 0xE8E8FB40, 0xE8E9FB40, 0xE8EAFB40, 0xE8EBFB40, 0xE8ECFB40, 0xE8EDFB40, 0xE8EEFB40, 0xE8EFFB40, 0xE8F0FB40, 0xE8F1FB40, 0xE8F2FB40, 0xE8F3FB40, 0xE8F4FB40, 0xE8F5FB40, 0xE8F6FB40, 0xE8F7FB40, 0xE8F8FB40, 0xE8F9FB40, 0xE8FAFB40, 0xE8FBFB40, 0xE8FCFB40, 0xE8FDFB40, 0xE8FEFB40, 0xE8FFFB40, 0xE900FB40, 0xE901FB40, 0xE902FB40, 0xE903FB40, 0xE904FB40, 0xE905FB40, 0xE906FB40, 0xE907FB40, 0xE908FB40, 0xE909FB40, 0xE90AFB40, 0xE90BFB40, 0xE90CFB40, 0xE90DFB40, 0xE90EFB40, 0xE90FFB40, 0xE910FB40, 0xE911FB40, 0xE912FB40, 0xE913FB40, 0xE914FB40, 0xE915FB40, 0xE916FB40, 0xE917FB40, 0xE918FB40, 0xE919FB40, 0xE91AFB40, 0xE91BFB40, 0xE91CFB40, 0xE91DFB40, 0xE91EFB40, 0xE91FFB40, 0xE920FB40, 0xE921FB40, 0xE922FB40, 0xE923FB40, 0xE924FB40, 0xE925FB40, 0xE926FB40, 0xE927FB40, 0xE928FB40, 0xE929FB40, 0xE92AFB40, 0xE92BFB40, 0xE92CFB40, 0xE92DFB40, 0xE92EFB40, 0xE92FFB40, 0xE930FB40, 0xE931FB40, 0xE932FB40, 0xE933FB40, 0xE934FB40, 0xE935FB40, 0xE936FB40, 0xE937FB40, 0xE938FB40, 0xE939FB40, 0xE93AFB40, 0xE93BFB40, 0xE93CFB40, 0xE93DFB40, 0xE93EFB40, 0xE93FFB40, 0xE940FB40, 0xE941FB40, 0xE942FB40, 0xE943FB40, 0xE944FB40, 0xE945FB40, 0xE946FB40, 0xE947FB40, 0xE948FB40, 0xE949FB40, 0xE94AFB40, 0xE94BFB40, 0xE94CFB40, 0xE94DFB40, 0xE94EFB40, 0xE94FFB40, 0xE950FB40, 0xE951FB40, 0xE952FB40, 0xE953FB40, 0xE954FB40, 0xE955FB40, /* 68AC */
+ 0xE956FB40, 0xE957FB40, 0xE958FB40, 0xE959FB40, 0xE95AFB40, 0xE95BFB40, 0xE95CFB40, 0xE95DFB40, 0xE95EFB40, 0xE95FFB40, 0xE960FB40, 0xE961FB40, 0xE962FB40, 0xE963FB40, 0xE964FB40, 0xE965FB40, 0xE966FB40, 0xE967FB40, 0xE968FB40, 0xE969FB40, 0xE96AFB40, 0xE96BFB40, 0xE96CFB40, 0xE96DFB40, 0xE96EFB40, 0xE96FFB40, 0xE970FB40, 0xE971FB40, 0xE972FB40, 0xE973FB40, 0xE974FB40, 0xE975FB40, 0xE976FB40, 0xE977FB40, 0xE978FB40, 0xE979FB40, 0xE97AFB40, 0xE97BFB40, 0xE97CFB40, 0xE97DFB40, 0xE97EFB40, 0xE97FFB40, 0xE980FB40, 0xE981FB40, 0xE982FB40, 0xE983FB40, 0xE984FB40, 0xE985FB40, 0xE986FB40, 0xE987FB40, 0xE988FB40, 0xE989FB40, 0xE98AFB40, 0xE98BFB40, 0xE98CFB40, 0xE98DFB40, 0xE98EFB40, 0xE98FFB40, 0xE990FB40, 0xE991FB40, 0xE992FB40, 0xE993FB40, 0xE994FB40, 0xE995FB40, 0xE996FB40, 0xE997FB40, 0xE998FB40, 0xE999FB40, 0xE99AFB40, 0xE99BFB40, 0xE99CFB40, 0xE99DFB40, 0xE99EFB40, 0xE99FFB40, 0xE9A0FB40, 0xE9A1FB40, 0xE9A2FB40, 0xE9A3FB40, 0xE9A4FB40, 0xE9A5FB40, 0xE9A6FB40, 0xE9A7FB40, 0xE9A8FB40, 0xE9A9FB40, 0xE9AAFB40, 0xE9ABFB40, 0xE9ACFB40, 0xE9ADFB40, 0xE9AEFB40, 0xE9AFFB40, 0xE9B0FB40, 0xE9B1FB40, 0xE9B2FB40, 0xE9B3FB40, 0xE9B4FB40, 0xE9B5FB40, 0xE9B6FB40, 0xE9B7FB40, 0xE9B8FB40, 0xE9B9FB40, 0xE9BAFB40, 0xE9BBFB40, 0xE9BCFB40, 0xE9BDFB40, 0xE9BEFB40, 0xE9BFFB40, 0xE9C0FB40, 0xE9C1FB40, 0xE9C2FB40, 0xE9C3FB40, 0xE9C4FB40, 0xE9C5FB40, 0xE9C6FB40, 0xE9C7FB40, 0xE9C8FB40, 0xE9C9FB40, 0xE9CAFB40, 0xE9CBFB40, 0xE9CCFB40, 0xE9CDFB40, 0xE9CEFB40, 0xE9CFFB40, 0xE9D0FB40, 0xE9D1FB40, 0xE9D2FB40, 0xE9D3FB40, 0xE9D4FB40, 0xE9D5FB40, 0xE9D6FB40, 0xE9D7FB40, 0xE9D8FB40, 0xE9D9FB40, 0xE9DAFB40, 0xE9DBFB40, 0xE9DCFB40, 0xE9DDFB40, 0xE9DEFB40, 0xE9DFFB40, 0xE9E0FB40, 0xE9E1FB40, 0xE9E2FB40, 0xE9E3FB40, 0xE9E4FB40, 0xE9E5FB40, 0xE9E6FB40, 0xE9E7FB40, 0xE9E8FB40, 0xE9E9FB40, 0xE9EAFB40, 0xE9EBFB40, 0xE9ECFB40, 0xE9EDFB40, 0xE9EEFB40, 0xE9EFFB40, 0xE9F0FB40, 0xE9F1FB40, 0xE9F2FB40, 0xE9F3FB40, 0xE9F4FB40, 0xE9F5FB40, 0xE9F6FB40, 0xE9F7FB40, 0xE9F8FB40, 0xE9F9FB40, 0xE9FAFB40, 0xE9FBFB40, 0xE9FCFB40, 0xE9FDFB40, 0xE9FEFB40, 0xE9FFFB40, /* 6956 */
+ 0xEA00FB40, 0xEA01FB40, 0xEA02FB40, 0xEA03FB40, 0xEA04FB40, 0xEA05FB40, 0xEA06FB40, 0xEA07FB40, 0xEA08FB40, 0xEA09FB40, 0xEA0AFB40, 0xEA0BFB40, 0xEA0CFB40, 0xEA0DFB40, 0xEA0EFB40, 0xEA0FFB40, 0xEA10FB40, 0xEA11FB40, 0xEA12FB40, 0xEA13FB40, 0xEA14FB40, 0xEA15FB40, 0xEA16FB40, 0xEA17FB40, 0xEA18FB40, 0xEA19FB40, 0xEA1AFB40, 0xEA1BFB40, 0xEA1CFB40, 0xEA1DFB40, 0xEA1EFB40, 0xEA1FFB40, 0xEA20FB40, 0xEA21FB40, 0xEA22FB40, 0xEA23FB40, 0xEA24FB40, 0xEA25FB40, 0xEA26FB40, 0xEA27FB40, 0xEA28FB40, 0xEA29FB40, 0xEA2AFB40, 0xEA2BFB40, 0xEA2CFB40, 0xEA2DFB40, 0xEA2EFB40, 0xEA2FFB40, 0xEA30FB40, 0xEA31FB40, 0xEA32FB40, 0xEA33FB40, 0xEA34FB40, 0xEA35FB40, 0xEA36FB40, 0xEA37FB40, 0xEA38FB40, 0xEA39FB40, 0xEA3AFB40, 0xEA3BFB40, 0xEA3CFB40, 0xEA3DFB40, 0xEA3EFB40, 0xEA3FFB40, 0xEA40FB40, 0xEA41FB40, 0xEA42FB40, 0xEA43FB40, 0xEA44FB40, 0xEA45FB40, 0xEA46FB40, 0xEA47FB40, 0xEA48FB40, 0xEA49FB40, 0xEA4AFB40, 0xEA4BFB40, 0xEA4CFB40, 0xEA4DFB40, 0xEA4EFB40, 0xEA4FFB40, 0xEA50FB40, 0xEA51FB40, 0xEA52FB40, 0xEA53FB40, 0xEA54FB40, 0xEA55FB40, 0xEA56FB40, 0xEA57FB40, 0xEA58FB40, 0xEA59FB40, 0xEA5AFB40, 0xEA5BFB40, 0xEA5CFB40, 0xEA5DFB40, 0xEA5EFB40, 0xEA5FFB40, 0xEA60FB40, 0xEA61FB40, 0xEA62FB40, 0xEA63FB40, 0xEA64FB40, 0xEA65FB40, 0xEA66FB40, 0xEA67FB40, 0xEA68FB40, 0xEA69FB40, 0xEA6AFB40, 0xEA6BFB40, 0xEA6CFB40, 0xEA6DFB40, 0xEA6EFB40, 0xEA6FFB40, 0xEA70FB40, 0xEA71FB40, 0xEA72FB40, 0xEA73FB40, 0xEA74FB40, 0xEA75FB40, 0xEA76FB40, 0xEA77FB40, 0xEA78FB40, 0xEA79FB40, 0xEA7AFB40, 0xEA7BFB40, 0xEA7CFB40, 0xEA7DFB40, 0xEA7EFB40, 0xEA7FFB40, 0xEA80FB40, 0xEA81FB40, 0xEA82FB40, 0xEA83FB40, 0xEA84FB40, 0xEA85FB40, 0xEA86FB40, 0xEA87FB40, 0xEA88FB40, 0xEA89FB40, 0xEA8AFB40, 0xEA8BFB40, 0xEA8CFB40, 0xEA8DFB40, 0xEA8EFB40, 0xEA8FFB40, 0xEA90FB40, 0xEA91FB40, 0xEA92FB40, 0xEA93FB40, 0xEA94FB40, 0xEA95FB40, 0xEA96FB40, 0xEA97FB40, 0xEA98FB40, 0xEA99FB40, 0xEA9AFB40, 0xEA9BFB40, 0xEA9CFB40, 0xEA9DFB40, 0xEA9EFB40, 0xEA9FFB40, 0xEAA0FB40, 0xEAA1FB40, 0xEAA2FB40, 0xEAA3FB40, 0xEAA4FB40, 0xEAA5FB40, 0xEAA6FB40, 0xEAA7FB40, 0xEAA8FB40, 0xEAA9FB40, /* 6A00 */
+ 0xEAAAFB40, 0xEAABFB40, 0xEAACFB40, 0xEAADFB40, 0xEAAEFB40, 0xEAAFFB40, 0xEAB0FB40, 0xEAB1FB40, 0xEAB2FB40, 0xEAB3FB40, 0xEAB4FB40, 0xEAB5FB40, 0xEAB6FB40, 0xEAB7FB40, 0xEAB8FB40, 0xEAB9FB40, 0xEABAFB40, 0xEABBFB40, 0xEABCFB40, 0xEABDFB40, 0xEABEFB40, 0xEABFFB40, 0xEAC0FB40, 0xEAC1FB40, 0xEAC2FB40, 0xEAC3FB40, 0xEAC4FB40, 0xEAC5FB40, 0xEAC6FB40, 0xEAC7FB40, 0xEAC8FB40, 0xEAC9FB40, 0xEACAFB40, 0xEACBFB40, 0xEACCFB40, 0xEACDFB40, 0xEACEFB40, 0xEACFFB40, 0xEAD0FB40, 0xEAD1FB40, 0xEAD2FB40, 0xEAD3FB40, 0xEAD4FB40, 0xEAD5FB40, 0xEAD6FB40, 0xEAD7FB40, 0xEAD8FB40, 0xEAD9FB40, 0xEADAFB40, 0xEADBFB40, 0xEADCFB40, 0xEADDFB40, 0xEADEFB40, 0xEADFFB40, 0xEAE0FB40, 0xEAE1FB40, 0xEAE2FB40, 0xEAE3FB40, 0xEAE4FB40, 0xEAE5FB40, 0xEAE6FB40, 0xEAE7FB40, 0xEAE8FB40, 0xEAE9FB40, 0xEAEAFB40, 0xEAEBFB40, 0xEAECFB40, 0xEAEDFB40, 0xEAEEFB40, 0xEAEFFB40, 0xEAF0FB40, 0xEAF1FB40, 0xEAF2FB40, 0xEAF3FB40, 0xEAF4FB40, 0xEAF5FB40, 0xEAF6FB40, 0xEAF7FB40, 0xEAF8FB40, 0xEAF9FB40, 0xEAFAFB40, 0xEAFBFB40, 0xEAFCFB40, 0xEAFDFB40, 0xEAFEFB40, 0xEAFFFB40, 0xEB00FB40, 0xEB01FB40, 0xEB02FB40, 0xEB03FB40, 0xEB04FB40, 0xEB05FB40, 0xEB06FB40, 0xEB07FB40, 0xEB08FB40, 0xEB09FB40, 0xEB0AFB40, 0xEB0BFB40, 0xEB0CFB40, 0xEB0DFB40, 0xEB0EFB40, 0xEB0FFB40, 0xEB10FB40, 0xEB11FB40, 0xEB12FB40, 0xEB13FB40, 0xEB14FB40, 0xEB15FB40, 0xEB16FB40, 0xEB17FB40, 0xEB18FB40, 0xEB19FB40, 0xEB1AFB40, 0xEB1BFB40, 0xEB1CFB40, 0xEB1DFB40, 0xEB1EFB40, 0xEB1FFB40, 0xEB20FB40, 0xEB21FB40, 0xEB22FB40, 0xEB23FB40, 0xEB24FB40, 0xEB25FB40, 0xEB26FB40, 0xEB27FB40, 0xEB28FB40, 0xEB29FB40, 0xEB2AFB40, 0xEB2BFB40, 0xEB2CFB40, 0xEB2DFB40, 0xEB2EFB40, 0xEB2FFB40, 0xEB30FB40, 0xEB31FB40, 0xEB32FB40, 0xEB33FB40, 0xEB34FB40, 0xEB35FB40, 0xEB36FB40, 0xEB37FB40, 0xEB38FB40, 0xEB39FB40, 0xEB3AFB40, 0xEB3BFB40, 0xEB3CFB40, 0xEB3DFB40, 0xEB3EFB40, 0xEB3FFB40, 0xEB40FB40, 0xEB41FB40, 0xEB42FB40, 0xEB43FB40, 0xEB44FB40, 0xEB45FB40, 0xEB46FB40, 0xEB47FB40, 0xEB48FB40, 0xEB49FB40, 0xEB4AFB40, 0xEB4BFB40, 0xEB4CFB40, 0xEB4DFB40, 0xEB4EFB40, 0xEB4FFB40, 0xEB50FB40, 0xEB51FB40, 0xEB52FB40, 0xEB53FB40, /* 6AAA */
+ 0xEB54FB40, 0xEB55FB40, 0xEB56FB40, 0xEB57FB40, 0xEB58FB40, 0xEB59FB40, 0xEB5AFB40, 0xEB5BFB40, 0xEB5CFB40, 0xEB5DFB40, 0xEB5EFB40, 0xEB5FFB40, 0xEB60FB40, 0xEB61FB40, 0xEB62FB40, 0xEB63FB40, 0xEB64FB40, 0xEB65FB40, 0xEB66FB40, 0xEB67FB40, 0xEB68FB40, 0xEB69FB40, 0xEB6AFB40, 0xEB6BFB40, 0xEB6CFB40, 0xEB6DFB40, 0xEB6EFB40, 0xEB6FFB40, 0xEB70FB40, 0xEB71FB40, 0xEB72FB40, 0xEB73FB40, 0xEB74FB40, 0xEB75FB40, 0xEB76FB40, 0xEB77FB40, 0xEB78FB40, 0xEB79FB40, 0xEB7AFB40, 0xEB7BFB40, 0xEB7CFB40, 0xEB7DFB40, 0xEB7EFB40, 0xEB7FFB40, 0xEB80FB40, 0xEB81FB40, 0xEB82FB40, 0xEB83FB40, 0xEB84FB40, 0xEB85FB40, 0xEB86FB40, 0xEB87FB40, 0xEB88FB40, 0xEB89FB40, 0xEB8AFB40, 0xEB8BFB40, 0xEB8CFB40, 0xEB8DFB40, 0xEB8EFB40, 0xEB8FFB40, 0xEB90FB40, 0xEB91FB40, 0xEB92FB40, 0xEB93FB40, 0xEB94FB40, 0xEB95FB40, 0xEB96FB40, 0xEB97FB40, 0xEB98FB40, 0xEB99FB40, 0xEB9AFB40, 0xEB9BFB40, 0xEB9CFB40, 0xEB9DFB40, 0xEB9EFB40, 0xEB9FFB40, 0xEBA0FB40, 0xEBA1FB40, 0xEBA2FB40, 0xEBA3FB40, 0xEBA4FB40, 0xEBA5FB40, 0xEBA6FB40, 0xEBA7FB40, 0xEBA8FB40, 0xEBA9FB40, 0xEBAAFB40, 0xEBABFB40, 0xEBACFB40, 0xEBADFB40, 0xEBAEFB40, 0xEBAFFB40, 0xEBB0FB40, 0xEBB1FB40, 0xEBB2FB40, 0xEBB3FB40, 0xEBB4FB40, 0xEBB5FB40, 0xEBB6FB40, 0xEBB7FB40, 0xEBB8FB40, 0xEBB9FB40, 0xEBBAFB40, 0xEBBBFB40, 0xEBBCFB40, 0xEBBDFB40, 0xEBBEFB40, 0xEBBFFB40, 0xEBC0FB40, 0xEBC1FB40, 0xEBC2FB40, 0xEBC3FB40, 0xEBC4FB40, 0xEBC5FB40, 0xEBC6FB40, 0xEBC7FB40, 0xEBC8FB40, 0xEBC9FB40, 0xEBCAFB40, 0xEBCBFB40, 0xEBCCFB40, 0xEBCDFB40, 0xEBCEFB40, 0xEBCFFB40, 0xEBD0FB40, 0xEBD1FB40, 0xEBD2FB40, 0xEBD3FB40, 0xEBD4FB40, 0xEBD5FB40, 0xEBD6FB40, 0xEBD7FB40, 0xEBD8FB40, 0xEBD9FB40, 0xEBDAFB40, 0xEBDBFB40, 0xEBDCFB40, 0xEBDDFB40, 0xEBDEFB40, 0xEBDFFB40, 0xEBE0FB40, 0xEBE1FB40, 0xEBE2FB40, 0xEBE3FB40, 0xEBE4FB40, 0xEBE5FB40, 0xEBE6FB40, 0xEBE7FB40, 0xEBE8FB40, 0xEBE9FB40, 0xEBEAFB40, 0xEBEBFB40, 0xEBECFB40, 0xEBEDFB40, 0xEBEEFB40, 0xEBEFFB40, 0xEBF0FB40, 0xEBF1FB40, 0xEBF2FB40, 0xEBF3FB40, 0xEBF4FB40, 0xEBF5FB40, 0xEBF6FB40, 0xEBF7FB40, 0xEBF8FB40, 0xEBF9FB40, 0xEBFAFB40, 0xEBFBFB40, 0xEBFCFB40, 0xEBFDFB40, /* 6B54 */
+ 0xEBFEFB40, 0xEBFFFB40, 0xEC00FB40, 0xEC01FB40, 0xEC02FB40, 0xEC03FB40, 0xEC04FB40, 0xEC05FB40, 0xEC06FB40, 0xEC07FB40, 0xEC08FB40, 0xEC09FB40, 0xEC0AFB40, 0xEC0BFB40, 0xEC0CFB40, 0xEC0DFB40, 0xEC0EFB40, 0xEC0FFB40, 0xEC10FB40, 0xEC11FB40, 0xEC12FB40, 0xEC13FB40, 0xEC14FB40, 0xEC15FB40, 0xEC16FB40, 0xEC17FB40, 0xEC18FB40, 0xEC19FB40, 0xEC1AFB40, 0xEC1BFB40, 0xEC1CFB40, 0xEC1DFB40, 0xEC1EFB40, 0xEC1FFB40, 0xEC20FB40, 0xEC21FB40, 0xEC22FB40, 0xEC23FB40, 0xEC24FB40, 0xEC25FB40, 0xEC26FB40, 0xEC27FB40, 0xEC28FB40, 0xEC29FB40, 0xEC2AFB40, 0xEC2BFB40, 0xEC2CFB40, 0xEC2DFB40, 0xEC2EFB40, 0xEC2FFB40, 0xEC30FB40, 0xEC31FB40, 0xEC32FB40, 0xEC33FB40, 0xEC34FB40, 0xEC35FB40, 0xEC36FB40, 0xEC37FB40, 0xEC38FB40, 0xEC39FB40, 0xEC3AFB40, 0xEC3BFB40, 0xEC3CFB40, 0xEC3DFB40, 0xEC3EFB40, 0xEC3FFB40, 0xEC40FB40, 0xEC41FB40, 0xEC42FB40, 0xEC43FB40, 0xEC44FB40, 0xEC45FB40, 0xEC46FB40, 0xEC47FB40, 0xEC48FB40, 0xEC49FB40, 0xEC4AFB40, 0xEC4BFB40, 0xEC4CFB40, 0xEC4DFB40, 0xEC4EFB40, 0xEC4FFB40, 0xEC50FB40, 0xEC51FB40, 0xEC52FB40, 0xEC53FB40, 0xEC54FB40, 0xEC55FB40, 0xEC56FB40, 0xEC57FB40, 0xEC58FB40, 0xEC59FB40, 0xEC5AFB40, 0xEC5BFB40, 0xEC5CFB40, 0xEC5DFB40, 0xEC5EFB40, 0xEC5FFB40, 0xEC60FB40, 0xEC61FB40, 0xEC62FB40, 0xEC63FB40, 0xEC64FB40, 0xEC65FB40, 0xEC66FB40, 0xEC67FB40, 0xEC68FB40, 0xEC69FB40, 0xEC6AFB40, 0xEC6BFB40, 0xEC6CFB40, 0xEC6DFB40, 0xEC6EFB40, 0xEC6FFB40, 0xEC70FB40, 0xEC71FB40, 0xEC72FB40, 0xEC73FB40, 0xEC74FB40, 0xEC75FB40, 0xEC76FB40, 0xEC77FB40, 0xEC78FB40, 0xEC79FB40, 0xEC7AFB40, 0xEC7BFB40, 0xEC7CFB40, 0xEC7DFB40, 0xEC7EFB40, 0xEC7FFB40, 0xEC80FB40, 0xEC81FB40, 0xEC82FB40, 0xEC83FB40, 0xEC84FB40, 0xEC85FB40, 0xEC86FB40, 0xEC87FB40, 0xEC88FB40, 0xEC89FB40, 0xEC8AFB40, 0xEC8BFB40, 0xEC8CFB40, 0xEC8DFB40, 0xEC8EFB40, 0xEC8FFB40, 0xEC90FB40, 0xEC91FB40, 0xEC92FB40, 0xEC93FB40, 0xEC94FB40, 0xEC95FB40, 0xEC96FB40, 0xEC97FB40, 0xEC98FB40, 0xEC99FB40, 0xEC9AFB40, 0xEC9BFB40, 0xEC9CFB40, 0xEC9DFB40, 0xEC9EFB40, 0xEC9FFB40, 0xECA0FB40, 0xECA1FB40, 0xECA2FB40, 0xECA3FB40, 0xECA4FB40, 0xECA5FB40, 0xECA6FB40, 0xECA7FB40, /* 6BFE */
+ 0xECA8FB40, 0xECA9FB40, 0xECAAFB40, 0xECABFB40, 0xECACFB40, 0xECADFB40, 0xECAEFB40, 0xECAFFB40, 0xECB0FB40, 0xECB1FB40, 0xECB2FB40, 0xECB3FB40, 0xECB4FB40, 0xECB5FB40, 0xECB6FB40, 0xECB7FB40, 0xECB8FB40, 0xECB9FB40, 0xECBAFB40, 0xECBBFB40, 0xECBCFB40, 0xECBDFB40, 0xECBEFB40, 0xECBFFB40, 0xECC0FB40, 0xECC1FB40, 0xECC2FB40, 0xECC3FB40, 0xECC4FB40, 0xECC5FB40, 0xECC6FB40, 0xECC7FB40, 0xECC8FB40, 0xECC9FB40, 0xECCAFB40, 0xECCBFB40, 0xECCCFB40, 0xECCDFB40, 0xECCEFB40, 0xECCFFB40, 0xECD0FB40, 0xECD1FB40, 0xECD2FB40, 0xECD3FB40, 0xECD4FB40, 0xECD5FB40, 0xECD6FB40, 0xECD7FB40, 0xECD8FB40, 0xECD9FB40, 0xECDAFB40, 0xECDBFB40, 0xECDCFB40, 0xECDDFB40, 0xECDEFB40, 0xECDFFB40, 0xECE0FB40, 0xECE1FB40, 0xECE2FB40, 0xECE3FB40, 0xECE4FB40, 0xECE5FB40, 0xECE6FB40, 0xECE7FB40, 0xECE8FB40, 0xECE9FB40, 0xECEAFB40, 0xECEBFB40, 0xECECFB40, 0xECEDFB40, 0xECEEFB40, 0xECEFFB40, 0xECF0FB40, 0xECF1FB40, 0xECF2FB40, 0xECF3FB40, 0xECF4FB40, 0xECF5FB40, 0xECF6FB40, 0xECF7FB40, 0xECF8FB40, 0xECF9FB40, 0xECFAFB40, 0xECFBFB40, 0xECFCFB40, 0xECFDFB40, 0xECFEFB40, 0xECFFFB40, 0xED00FB40, 0xED01FB40, 0xED02FB40, 0xED03FB40, 0xED04FB40, 0xED05FB40, 0xED06FB40, 0xED07FB40, 0xED08FB40, 0xED09FB40, 0xED0AFB40, 0xED0BFB40, 0xED0CFB40, 0xED0DFB40, 0xED0EFB40, 0xED0FFB40, 0xED10FB40, 0xED11FB40, 0xED12FB40, 0xED13FB40, 0xED14FB40, 0xED15FB40, 0xED16FB40, 0xED17FB40, 0xED18FB40, 0xED19FB40, 0xED1AFB40, 0xED1BFB40, 0xED1CFB40, 0xED1DFB40, 0xED1EFB40, 0xED1FFB40, 0xED20FB40, 0xED21FB40, 0xED22FB40, 0xED23FB40, 0xED24FB40, 0xED25FB40, 0xED26FB40, 0xED27FB40, 0xED28FB40, 0xED29FB40, 0xED2AFB40, 0xED2BFB40, 0xED2CFB40, 0xED2DFB40, 0xED2EFB40, 0xED2FFB40, 0xED30FB40, 0xED31FB40, 0xED32FB40, 0xED33FB40, 0xED34FB40, 0xED35FB40, 0xED36FB40, 0xED37FB40, 0xED38FB40, 0xED39FB40, 0xED3AFB40, 0xED3BFB40, 0xED3CFB40, 0xED3DFB40, 0xED3EFB40, 0xED3FFB40, 0xED40FB40, 0xED41FB40, 0xED42FB40, 0xED43FB40, 0xED44FB40, 0xED45FB40, 0xED46FB40, 0xED47FB40, 0xED48FB40, 0xED49FB40, 0xED4AFB40, 0xED4BFB40, 0xED4CFB40, 0xED4DFB40, 0xED4EFB40, 0xED4FFB40, 0xED50FB40, 0xED51FB40, /* 6CA8 */
+ 0xED52FB40, 0xED53FB40, 0xED54FB40, 0xED55FB40, 0xED56FB40, 0xED57FB40, 0xED58FB40, 0xED59FB40, 0xED5AFB40, 0xED5BFB40, 0xED5CFB40, 0xED5DFB40, 0xED5EFB40, 0xED5FFB40, 0xED60FB40, 0xED61FB40, 0xED62FB40, 0xED63FB40, 0xED64FB40, 0xED65FB40, 0xED66FB40, 0xED67FB40, 0xED68FB40, 0xED69FB40, 0xED6AFB40, 0xED6BFB40, 0xED6CFB40, 0xED6DFB40, 0xED6EFB40, 0xED6FFB40, 0xED70FB40, 0xED71FB40, 0xED72FB40, 0xED73FB40, 0xED74FB40, 0xED75FB40, 0xED76FB40, 0xED77FB40, 0xED78FB40, 0xED79FB40, 0xED7AFB40, 0xED7BFB40, 0xED7CFB40, 0xED7DFB40, 0xED7EFB40, 0xED7FFB40, 0xED80FB40, 0xED81FB40, 0xED82FB40, 0xED83FB40, 0xED84FB40, 0xED85FB40, 0xED86FB40, 0xED87FB40, 0xED88FB40, 0xED89FB40, 0xED8AFB40, 0xED8BFB40, 0xED8CFB40, 0xED8DFB40, 0xED8EFB40, 0xED8FFB40, 0xED90FB40, 0xED91FB40, 0xED92FB40, 0xED93FB40, 0xED94FB40, 0xED95FB40, 0xED96FB40, 0xED97FB40, 0xED98FB40, 0xED99FB40, 0xED9AFB40, 0xED9BFB40, 0xED9CFB40, 0xED9DFB40, 0xED9EFB40, 0xED9FFB40, 0xEDA0FB40, 0xEDA1FB40, 0xEDA2FB40, 0xEDA3FB40, 0xEDA4FB40, 0xEDA5FB40, 0xEDA6FB40, 0xEDA7FB40, 0xEDA8FB40, 0xEDA9FB40, 0xEDAAFB40, 0xEDABFB40, 0xEDACFB40, 0xEDADFB40, 0xEDAEFB40, 0xEDAFFB40, 0xEDB0FB40, 0xEDB1FB40, 0xEDB2FB40, 0xEDB3FB40, 0xEDB4FB40, 0xEDB5FB40, 0xEDB6FB40, 0xEDB7FB40, 0xEDB8FB40, 0xEDB9FB40, 0xEDBAFB40, 0xEDBBFB40, 0xEDBCFB40, 0xEDBDFB40, 0xEDBEFB40, 0xEDBFFB40, 0xEDC0FB40, 0xEDC1FB40, 0xEDC2FB40, 0xEDC3FB40, 0xEDC4FB40, 0xEDC5FB40, 0xEDC6FB40, 0xEDC7FB40, 0xEDC8FB40, 0xEDC9FB40, 0xEDCAFB40, 0xEDCBFB40, 0xEDCCFB40, 0xEDCDFB40, 0xEDCEFB40, 0xEDCFFB40, 0xEDD0FB40, 0xEDD1FB40, 0xEDD2FB40, 0xEDD3FB40, 0xEDD4FB40, 0xEDD5FB40, 0xEDD6FB40, 0xEDD7FB40, 0xEDD8FB40, 0xEDD9FB40, 0xEDDAFB40, 0xEDDBFB40, 0xEDDCFB40, 0xEDDDFB40, 0xEDDEFB40, 0xEDDFFB40, 0xEDE0FB40, 0xEDE1FB40, 0xEDE2FB40, 0xEDE3FB40, 0xEDE4FB40, 0xEDE5FB40, 0xEDE6FB40, 0xEDE7FB40, 0xEDE8FB40, 0xEDE9FB40, 0xEDEAFB40, 0xEDEBFB40, 0xEDECFB40, 0xEDEDFB40, 0xEDEEFB40, 0xEDEFFB40, 0xEDF0FB40, 0xEDF1FB40, 0xEDF2FB40, 0xEDF3FB40, 0xEDF4FB40, 0xEDF5FB40, 0xEDF6FB40, 0xEDF7FB40, 0xEDF8FB40, 0xEDF9FB40, 0xEDFAFB40, 0xEDFBFB40, /* 6D52 */
+ 0xEDFCFB40, 0xEDFDFB40, 0xEDFEFB40, 0xEDFFFB40, 0xEE00FB40, 0xEE01FB40, 0xEE02FB40, 0xEE03FB40, 0xEE04FB40, 0xEE05FB40, 0xEE06FB40, 0xEE07FB40, 0xEE08FB40, 0xEE09FB40, 0xEE0AFB40, 0xEE0BFB40, 0xEE0CFB40, 0xEE0DFB40, 0xEE0EFB40, 0xEE0FFB40, 0xEE10FB40, 0xEE11FB40, 0xEE12FB40, 0xEE13FB40, 0xEE14FB40, 0xEE15FB40, 0xEE16FB40, 0xEE17FB40, 0xEE18FB40, 0xEE19FB40, 0xEE1AFB40, 0xEE1BFB40, 0xEE1CFB40, 0xEE1DFB40, 0xEE1EFB40, 0xEE1FFB40, 0xEE20FB40, 0xEE21FB40, 0xEE22FB40, 0xEE23FB40, 0xEE24FB40, 0xEE25FB40, 0xEE26FB40, 0xEE27FB40, 0xEE28FB40, 0xEE29FB40, 0xEE2AFB40, 0xEE2BFB40, 0xEE2CFB40, 0xEE2DFB40, 0xEE2EFB40, 0xEE2FFB40, 0xEE30FB40, 0xEE31FB40, 0xEE32FB40, 0xEE33FB40, 0xEE34FB40, 0xEE35FB40, 0xEE36FB40, 0xEE37FB40, 0xEE38FB40, 0xEE39FB40, 0xEE3AFB40, 0xEE3BFB40, 0xEE3CFB40, 0xEE3DFB40, 0xEE3EFB40, 0xEE3FFB40, 0xEE40FB40, 0xEE41FB40, 0xEE42FB40, 0xEE43FB40, 0xEE44FB40, 0xEE45FB40, 0xEE46FB40, 0xEE47FB40, 0xEE48FB40, 0xEE49FB40, 0xEE4AFB40, 0xEE4BFB40, 0xEE4CFB40, 0xEE4DFB40, 0xEE4EFB40, 0xEE4FFB40, 0xEE50FB40, 0xEE51FB40, 0xEE52FB40, 0xEE53FB40, 0xEE54FB40, 0xEE55FB40, 0xEE56FB40, 0xEE57FB40, 0xEE58FB40, 0xEE59FB40, 0xEE5AFB40, 0xEE5BFB40, 0xEE5CFB40, 0xEE5DFB40, 0xEE5EFB40, 0xEE5FFB40, 0xEE60FB40, 0xEE61FB40, 0xEE62FB40, 0xEE63FB40, 0xEE64FB40, 0xEE65FB40, 0xEE66FB40, 0xEE67FB40, 0xEE68FB40, 0xEE69FB40, 0xEE6AFB40, 0xEE6BFB40, 0xEE6CFB40, 0xEE6DFB40, 0xEE6EFB40, 0xEE6FFB40, 0xEE70FB40, 0xEE71FB40, 0xEE72FB40, 0xEE73FB40, 0xEE74FB40, 0xEE75FB40, 0xEE76FB40, 0xEE77FB40, 0xEE78FB40, 0xEE79FB40, 0xEE7AFB40, 0xEE7BFB40, 0xEE7CFB40, 0xEE7DFB40, 0xEE7EFB40, 0xEE7FFB40, 0xEE80FB40, 0xEE81FB40, 0xEE82FB40, 0xEE83FB40, 0xEE84FB40, 0xEE85FB40, 0xEE86FB40, 0xEE87FB40, 0xEE88FB40, 0xEE89FB40, 0xEE8AFB40, 0xEE8BFB40, 0xEE8CFB40, 0xEE8DFB40, 0xEE8EFB40, 0xEE8FFB40, 0xEE90FB40, 0xEE91FB40, 0xEE92FB40, 0xEE93FB40, 0xEE94FB40, 0xEE95FB40, 0xEE96FB40, 0xEE97FB40, 0xEE98FB40, 0xEE99FB40, 0xEE9AFB40, 0xEE9BFB40, 0xEE9CFB40, 0xEE9DFB40, 0xEE9EFB40, 0xEE9FFB40, 0xEEA0FB40, 0xEEA1FB40, 0xEEA2FB40, 0xEEA3FB40, 0xEEA4FB40, 0xEEA5FB40, /* 6DFC */
+ 0xEEA6FB40, 0xEEA7FB40, 0xEEA8FB40, 0xEEA9FB40, 0xEEAAFB40, 0xEEABFB40, 0xEEACFB40, 0xEEADFB40, 0xEEAEFB40, 0xEEAFFB40, 0xEEB0FB40, 0xEEB1FB40, 0xEEB2FB40, 0xEEB3FB40, 0xEEB4FB40, 0xEEB5FB40, 0xEEB6FB40, 0xEEB7FB40, 0xEEB8FB40, 0xEEB9FB40, 0xEEBAFB40, 0xEEBBFB40, 0xEEBCFB40, 0xEEBDFB40, 0xEEBEFB40, 0xEEBFFB40, 0xEEC0FB40, 0xEEC1FB40, 0xEEC2FB40, 0xEEC3FB40, 0xEEC4FB40, 0xEEC5FB40, 0xEEC6FB40, 0xEEC7FB40, 0xEEC8FB40, 0xEEC9FB40, 0xEECAFB40, 0xEECBFB40, 0xEECCFB40, 0xEECDFB40, 0xEECEFB40, 0xEECFFB40, 0xEED0FB40, 0xEED1FB40, 0xEED2FB40, 0xEED3FB40, 0xEED4FB40, 0xEED5FB40, 0xEED6FB40, 0xEED7FB40, 0xEED8FB40, 0xEED9FB40, 0xEEDAFB40, 0xEEDBFB40, 0xEEDCFB40, 0xEEDDFB40, 0xEEDEFB40, 0xEEDFFB40, 0xEEE0FB40, 0xEEE1FB40, 0xEEE2FB40, 0xEEE3FB40, 0xEEE4FB40, 0xEEE5FB40, 0xEEE6FB40, 0xEEE7FB40, 0xEEE8FB40, 0xEEE9FB40, 0xEEEAFB40, 0xEEEBFB40, 0xEEECFB40, 0xEEEDFB40, 0xEEEEFB40, 0xEEEFFB40, 0xEEF0FB40, 0xEEF1FB40, 0xEEF2FB40, 0xEEF3FB40, 0xEEF4FB40, 0xEEF5FB40, 0xEEF6FB40, 0xEEF7FB40, 0xEEF8FB40, 0xEEF9FB40, 0xEEFAFB40, 0xEEFBFB40, 0xEEFCFB40, 0xEEFDFB40, 0xEEFEFB40, 0xEEFFFB40, 0xEF00FB40, 0xEF01FB40, 0xEF02FB40, 0xEF03FB40, 0xEF04FB40, 0xEF05FB40, 0xEF06FB40, 0xEF07FB40, 0xEF08FB40, 0xEF09FB40, 0xEF0AFB40, 0xEF0BFB40, 0xEF0CFB40, 0xEF0DFB40, 0xEF0EFB40, 0xEF0FFB40, 0xEF10FB40, 0xEF11FB40, 0xEF12FB40, 0xEF13FB40, 0xEF14FB40, 0xEF15FB40, 0xEF16FB40, 0xEF17FB40, 0xEF18FB40, 0xEF19FB40, 0xEF1AFB40, 0xEF1BFB40, 0xEF1CFB40, 0xEF1DFB40, 0xEF1EFB40, 0xEF1FFB40, 0xEF20FB40, 0xEF21FB40, 0xEF22FB40, 0xEF23FB40, 0xEF24FB40, 0xEF25FB40, 0xEF26FB40, 0xEF27FB40, 0xEF28FB40, 0xEF29FB40, 0xEF2AFB40, 0xEF2BFB40, 0xEF2CFB40, 0xEF2DFB40, 0xEF2EFB40, 0xEF2FFB40, 0xEF30FB40, 0xEF31FB40, 0xEF32FB40, 0xEF33FB40, 0xEF34FB40, 0xEF35FB40, 0xEF36FB40, 0xEF37FB40, 0xEF38FB40, 0xEF39FB40, 0xEF3AFB40, 0xEF3BFB40, 0xEF3CFB40, 0xEF3DFB40, 0xEF3EFB40, 0xEF3FFB40, 0xEF40FB40, 0xEF41FB40, 0xEF42FB40, 0xEF43FB40, 0xEF44FB40, 0xEF45FB40, 0xEF46FB40, 0xEF47FB40, 0xEF48FB40, 0xEF49FB40, 0xEF4AFB40, 0xEF4BFB40, 0xEF4CFB40, 0xEF4DFB40, 0xEF4EFB40, 0xEF4FFB40, /* 6EA6 */
+ 0xEF50FB40, 0xEF51FB40, 0xEF52FB40, 0xEF53FB40, 0xEF54FB40, 0xEF55FB40, 0xEF56FB40, 0xEF57FB40, 0xEF58FB40, 0xEF59FB40, 0xEF5AFB40, 0xEF5BFB40, 0xEF5CFB40, 0xEF5DFB40, 0xEF5EFB40, 0xEF5FFB40, 0xEF60FB40, 0xEF61FB40, 0xEF62FB40, 0xEF63FB40, 0xEF64FB40, 0xEF65FB40, 0xEF66FB40, 0xEF67FB40, 0xEF68FB40, 0xEF69FB40, 0xEF6AFB40, 0xEF6BFB40, 0xEF6CFB40, 0xEF6DFB40, 0xEF6EFB40, 0xEF6FFB40, 0xEF70FB40, 0xEF71FB40, 0xEF72FB40, 0xEF73FB40, 0xEF74FB40, 0xEF75FB40, 0xEF76FB40, 0xEF77FB40, 0xEF78FB40, 0xEF79FB40, 0xEF7AFB40, 0xEF7BFB40, 0xEF7CFB40, 0xEF7DFB40, 0xEF7EFB40, 0xEF7FFB40, 0xEF80FB40, 0xEF81FB40, 0xEF82FB40, 0xEF83FB40, 0xEF84FB40, 0xEF85FB40, 0xEF86FB40, 0xEF87FB40, 0xEF88FB40, 0xEF89FB40, 0xEF8AFB40, 0xEF8BFB40, 0xEF8CFB40, 0xEF8DFB40, 0xEF8EFB40, 0xEF8FFB40, 0xEF90FB40, 0xEF91FB40, 0xEF92FB40, 0xEF93FB40, 0xEF94FB40, 0xEF95FB40, 0xEF96FB40, 0xEF97FB40, 0xEF98FB40, 0xEF99FB40, 0xEF9AFB40, 0xEF9BFB40, 0xEF9CFB40, 0xEF9DFB40, 0xEF9EFB40, 0xEF9FFB40, 0xEFA0FB40, 0xEFA1FB40, 0xEFA2FB40, 0xEFA3FB40, 0xEFA4FB40, 0xEFA5FB40, 0xEFA6FB40, 0xEFA7FB40, 0xEFA8FB40, 0xEFA9FB40, 0xEFAAFB40, 0xEFABFB40, 0xEFACFB40, 0xEFADFB40, 0xEFAEFB40, 0xEFAFFB40, 0xEFB0FB40, 0xEFB1FB40, 0xEFB2FB40, 0xEFB3FB40, 0xEFB4FB40, 0xEFB5FB40, 0xEFB6FB40, 0xEFB7FB40, 0xEFB8FB40, 0xEFB9FB40, 0xEFBAFB40, 0xEFBBFB40, 0xEFBCFB40, 0xEFBDFB40, 0xEFBEFB40, 0xEFBFFB40, 0xEFC0FB40, 0xEFC1FB40, 0xEFC2FB40, 0xEFC3FB40, 0xEFC4FB40, 0xEFC5FB40, 0xEFC6FB40, 0xEFC7FB40, 0xEFC8FB40, 0xEFC9FB40, 0xEFCAFB40, 0xEFCBFB40, 0xEFCCFB40, 0xEFCDFB40, 0xEFCEFB40, 0xEFCFFB40, 0xEFD0FB40, 0xEFD1FB40, 0xEFD2FB40, 0xEFD3FB40, 0xEFD4FB40, 0xEFD5FB40, 0xEFD6FB40, 0xEFD7FB40, 0xEFD8FB40, 0xEFD9FB40, 0xEFDAFB40, 0xEFDBFB40, 0xEFDCFB40, 0xEFDDFB40, 0xEFDEFB40, 0xEFDFFB40, 0xEFE0FB40, 0xEFE1FB40, 0xEFE2FB40, 0xEFE3FB40, 0xEFE4FB40, 0xEFE5FB40, 0xEFE6FB40, 0xEFE7FB40, 0xEFE8FB40, 0xEFE9FB40, 0xEFEAFB40, 0xEFEBFB40, 0xEFECFB40, 0xEFEDFB40, 0xEFEEFB40, 0xEFEFFB40, 0xEFF0FB40, 0xEFF1FB40, 0xEFF2FB40, 0xEFF3FB40, 0xEFF4FB40, 0xEFF5FB40, 0xEFF6FB40, 0xEFF7FB40, 0xEFF8FB40, 0xEFF9FB40, /* 6F50 */
+ 0xEFFAFB40, 0xEFFBFB40, 0xEFFCFB40, 0xEFFDFB40, 0xEFFEFB40, 0xEFFFFB40, 0xF000FB40, 0xF001FB40, 0xF002FB40, 0xF003FB40, 0xF004FB40, 0xF005FB40, 0xF006FB40, 0xF007FB40, 0xF008FB40, 0xF009FB40, 0xF00AFB40, 0xF00BFB40, 0xF00CFB40, 0xF00DFB40, 0xF00EFB40, 0xF00FFB40, 0xF010FB40, 0xF011FB40, 0xF012FB40, 0xF013FB40, 0xF014FB40, 0xF015FB40, 0xF016FB40, 0xF017FB40, 0xF018FB40, 0xF019FB40, 0xF01AFB40, 0xF01BFB40, 0xF01CFB40, 0xF01DFB40, 0xF01EFB40, 0xF01FFB40, 0xF020FB40, 0xF021FB40, 0xF022FB40, 0xF023FB40, 0xF024FB40, 0xF025FB40, 0xF026FB40, 0xF027FB40, 0xF028FB40, 0xF029FB40, 0xF02AFB40, 0xF02BFB40, 0xF02CFB40, 0xF02DFB40, 0xF02EFB40, 0xF02FFB40, 0xF030FB40, 0xF031FB40, 0xF032FB40, 0xF033FB40, 0xF034FB40, 0xF035FB40, 0xF036FB40, 0xF037FB40, 0xF038FB40, 0xF039FB40, 0xF03AFB40, 0xF03BFB40, 0xF03CFB40, 0xF03DFB40, 0xF03EFB40, 0xF03FFB40, 0xF040FB40, 0xF041FB40, 0xF042FB40, 0xF043FB40, 0xF044FB40, 0xF045FB40, 0xF046FB40, 0xF047FB40, 0xF048FB40, 0xF049FB40, 0xF04AFB40, 0xF04BFB40, 0xF04CFB40, 0xF04DFB40, 0xF04EFB40, 0xF04FFB40, 0xF050FB40, 0xF051FB40, 0xF052FB40, 0xF053FB40, 0xF054FB40, 0xF055FB40, 0xF056FB40, 0xF057FB40, 0xF058FB40, 0xF059FB40, 0xF05AFB40, 0xF05BFB40, 0xF05CFB40, 0xF05DFB40, 0xF05EFB40, 0xF05FFB40, 0xF060FB40, 0xF061FB40, 0xF062FB40, 0xF063FB40, 0xF064FB40, 0xF065FB40, 0xF066FB40, 0xF067FB40, 0xF068FB40, 0xF069FB40, 0xF06AFB40, 0xF06BFB40, 0xF06CFB40, 0xF06DFB40, 0xF06EFB40, 0xF06FFB40, 0xF070FB40, 0xF071FB40, 0xF072FB40, 0xF073FB40, 0xF074FB40, 0xF075FB40, 0xF076FB40, 0xF077FB40, 0xF078FB40, 0xF079FB40, 0xF07AFB40, 0xF07BFB40, 0xF07CFB40, 0xF07DFB40, 0xF07EFB40, 0xF07FFB40, 0xF080FB40, 0xF081FB40, 0xF082FB40, 0xF083FB40, 0xF084FB40, 0xF085FB40, 0xF086FB40, 0xF087FB40, 0xF088FB40, 0xF089FB40, 0xF08AFB40, 0xF08BFB40, 0xF08CFB40, 0xF08DFB40, 0xF08EFB40, 0xF08FFB40, 0xF090FB40, 0xF091FB40, 0xF092FB40, 0xF093FB40, 0xF094FB40, 0xF095FB40, 0xF096FB40, 0xF097FB40, 0xF098FB40, 0xF099FB40, 0xF09AFB40, 0xF09BFB40, 0xF09CFB40, 0xF09DFB40, 0xF09EFB40, 0xF09FFB40, 0xF0A0FB40, 0xF0A1FB40, 0xF0A2FB40, 0xF0A3FB40, /* 6FFA */
+ 0xF0A4FB40, 0xF0A5FB40, 0xF0A6FB40, 0xF0A7FB40, 0xF0A8FB40, 0xF0A9FB40, 0xF0AAFB40, 0xF0ABFB40, 0xF0ACFB40, 0xF0ADFB40, 0xF0AEFB40, 0xF0AFFB40, 0xF0B0FB40, 0xF0B1FB40, 0xF0B2FB40, 0xF0B3FB40, 0xF0B4FB40, 0xF0B5FB40, 0xF0B6FB40, 0xF0B7FB40, 0xF0B8FB40, 0xF0B9FB40, 0xF0BAFB40, 0xF0BBFB40, 0xF0BCFB40, 0xF0BDFB40, 0xF0BEFB40, 0xF0BFFB40, 0xF0C0FB40, 0xF0C1FB40, 0xF0C2FB40, 0xF0C3FB40, 0xF0C4FB40, 0xF0C5FB40, 0xF0C6FB40, 0xF0C7FB40, 0xF0C8FB40, 0xF0C9FB40, 0xF0CAFB40, 0xF0CBFB40, 0xF0CCFB40, 0xF0CDFB40, 0xF0CEFB40, 0xF0CFFB40, 0xF0D0FB40, 0xF0D1FB40, 0xF0D2FB40, 0xF0D3FB40, 0xF0D4FB40, 0xF0D5FB40, 0xF0D6FB40, 0xF0D7FB40, 0xF0D8FB40, 0xF0D9FB40, 0xF0DAFB40, 0xF0DBFB40, 0xF0DCFB40, 0xF0DDFB40, 0xF0DEFB40, 0xF0DFFB40, 0xF0E0FB40, 0xF0E1FB40, 0xF0E2FB40, 0xF0E3FB40, 0xF0E4FB40, 0xF0E5FB40, 0xF0E6FB40, 0xF0E7FB40, 0xF0E8FB40, 0xF0E9FB40, 0xF0EAFB40, 0xF0EBFB40, 0xF0ECFB40, 0xF0EDFB40, 0xF0EEFB40, 0xF0EFFB40, 0xF0F0FB40, 0xF0F1FB40, 0xF0F2FB40, 0xF0F3FB40, 0xF0F4FB40, 0xF0F5FB40, 0xF0F6FB40, 0xF0F7FB40, 0xF0F8FB40, 0xF0F9FB40, 0xF0FAFB40, 0xF0FBFB40, 0xF0FCFB40, 0xF0FDFB40, 0xF0FEFB40, 0xF0FFFB40, 0xF100FB40, 0xF101FB40, 0xF102FB40, 0xF103FB40, 0xF104FB40, 0xF105FB40, 0xF106FB40, 0xF107FB40, 0xF108FB40, 0xF109FB40, 0xF10AFB40, 0xF10BFB40, 0xF10CFB40, 0xF10DFB40, 0xF10EFB40, 0xF10FFB40, 0xF110FB40, 0xF111FB40, 0xF112FB40, 0xF113FB40, 0xF114FB40, 0xF115FB40, 0xF116FB40, 0xF117FB40, 0xF118FB40, 0xF119FB40, 0xF11AFB40, 0xF11BFB40, 0xF11CFB40, 0xF11DFB40, 0xF11EFB40, 0xF11FFB40, 0xF120FB40, 0xF121FB40, 0xF122FB40, 0xF123FB40, 0xF124FB40, 0xF125FB40, 0xF126FB40, 0xF127FB40, 0xF128FB40, 0xF129FB40, 0xF12AFB40, 0xF12BFB40, 0xF12CFB40, 0xF12DFB40, 0xF12EFB40, 0xF12FFB40, 0xF130FB40, 0xF131FB40, 0xF132FB40, 0xF133FB40, 0xF134FB40, 0xF135FB40, 0xF136FB40, 0xF137FB40, 0xF138FB40, 0xF139FB40, 0xF13AFB40, 0xF13BFB40, 0xF13CFB40, 0xF13DFB40, 0xF13EFB40, 0xF13FFB40, 0xF140FB40, 0xF141FB40, 0xF142FB40, 0xF143FB40, 0xF144FB40, 0xF145FB40, 0xF146FB40, 0xF147FB40, 0xF148FB40, 0xF149FB40, 0xF14AFB40, 0xF14BFB40, 0xF14CFB40, 0xF14DFB40, /* 70A4 */
+ 0xF14EFB40, 0xF14FFB40, 0xF150FB40, 0xF151FB40, 0xF152FB40, 0xF153FB40, 0xF154FB40, 0xF155FB40, 0xF156FB40, 0xF157FB40, 0xF158FB40, 0xF159FB40, 0xF15AFB40, 0xF15BFB40, 0xF15CFB40, 0xF15DFB40, 0xF15EFB40, 0xF15FFB40, 0xF160FB40, 0xF161FB40, 0xF162FB40, 0xF163FB40, 0xF164FB40, 0xF165FB40, 0xF166FB40, 0xF167FB40, 0xF168FB40, 0xF169FB40, 0xF16AFB40, 0xF16BFB40, 0xF16CFB40, 0xF16DFB40, 0xF16EFB40, 0xF16FFB40, 0xF170FB40, 0xF171FB40, 0xF172FB40, 0xF173FB40, 0xF174FB40, 0xF175FB40, 0xF176FB40, 0xF177FB40, 0xF178FB40, 0xF179FB40, 0xF17AFB40, 0xF17BFB40, 0xF17CFB40, 0xF17DFB40, 0xF17EFB40, 0xF17FFB40, 0xF180FB40, 0xF181FB40, 0xF182FB40, 0xF183FB40, 0xF184FB40, 0xF185FB40, 0xF186FB40, 0xF187FB40, 0xF188FB40, 0xF189FB40, 0xF18AFB40, 0xF18BFB40, 0xF18CFB40, 0xF18DFB40, 0xF18EFB40, 0xF18FFB40, 0xF190FB40, 0xF191FB40, 0xF192FB40, 0xF193FB40, 0xF194FB40, 0xF195FB40, 0xF196FB40, 0xF197FB40, 0xF198FB40, 0xF199FB40, 0xF19AFB40, 0xF19BFB40, 0xF19CFB40, 0xF19DFB40, 0xF19EFB40, 0xF19FFB40, 0xF1A0FB40, 0xF1A1FB40, 0xF1A2FB40, 0xF1A3FB40, 0xF1A4FB40, 0xF1A5FB40, 0xF1A6FB40, 0xF1A7FB40, 0xF1A8FB40, 0xF1A9FB40, 0xF1AAFB40, 0xF1ABFB40, 0xF1ACFB40, 0xF1ADFB40, 0xF1AEFB40, 0xF1AFFB40, 0xF1B0FB40, 0xF1B1FB40, 0xF1B2FB40, 0xF1B3FB40, 0xF1B4FB40, 0xF1B5FB40, 0xF1B6FB40, 0xF1B7FB40, 0xF1B8FB40, 0xF1B9FB40, 0xF1BAFB40, 0xF1BBFB40, 0xF1BCFB40, 0xF1BDFB40, 0xF1BEFB40, 0xF1BFFB40, 0xF1C0FB40, 0xF1C1FB40, 0xF1C2FB40, 0xF1C3FB40, 0xF1C4FB40, 0xF1C5FB40, 0xF1C6FB40, 0xF1C7FB40, 0xF1C8FB40, 0xF1C9FB40, 0xF1CAFB40, 0xF1CBFB40, 0xF1CCFB40, 0xF1CDFB40, 0xF1CEFB40, 0xF1CFFB40, 0xF1D0FB40, 0xF1D1FB40, 0xF1D2FB40, 0xF1D3FB40, 0xF1D4FB40, 0xF1D5FB40, 0xF1D6FB40, 0xF1D7FB40, 0xF1D8FB40, 0xF1D9FB40, 0xF1DAFB40, 0xF1DBFB40, 0xF1DCFB40, 0xF1DDFB40, 0xF1DEFB40, 0xF1DFFB40, 0xF1E0FB40, 0xF1E1FB40, 0xF1E2FB40, 0xF1E3FB40, 0xF1E4FB40, 0xF1E5FB40, 0xF1E6FB40, 0xF1E7FB40, 0xF1E8FB40, 0xF1E9FB40, 0xF1EAFB40, 0xF1EBFB40, 0xF1ECFB40, 0xF1EDFB40, 0xF1EEFB40, 0xF1EFFB40, 0xF1F0FB40, 0xF1F1FB40, 0xF1F2FB40, 0xF1F3FB40, 0xF1F4FB40, 0xF1F5FB40, 0xF1F6FB40, 0xF1F7FB40, /* 714E */
+ 0xF1F8FB40, 0xF1F9FB40, 0xF1FAFB40, 0xF1FBFB40, 0xF1FCFB40, 0xF1FDFB40, 0xF1FEFB40, 0xF1FFFB40, 0xF200FB40, 0xF201FB40, 0xF202FB40, 0xF203FB40, 0xF204FB40, 0xF205FB40, 0xF206FB40, 0xF207FB40, 0xF208FB40, 0xF209FB40, 0xF20AFB40, 0xF20BFB40, 0xF20CFB40, 0xF20DFB40, 0xF20EFB40, 0xF20FFB40, 0xF210FB40, 0xF211FB40, 0xF212FB40, 0xF213FB40, 0xF214FB40, 0xF215FB40, 0xF216FB40, 0xF217FB40, 0xF218FB40, 0xF219FB40, 0xF21AFB40, 0xF21BFB40, 0xF21CFB40, 0xF21DFB40, 0xF21EFB40, 0xF21FFB40, 0xF220FB40, 0xF221FB40, 0xF222FB40, 0xF223FB40, 0xF224FB40, 0xF225FB40, 0xF226FB40, 0xF227FB40, 0xF228FB40, 0xF229FB40, 0xF22AFB40, 0xF22BFB40, 0xF22CFB40, 0xF22DFB40, 0xF22EFB40, 0xF22FFB40, 0xF230FB40, 0xF231FB40, 0xF232FB40, 0xF233FB40, 0xF234FB40, 0xF235FB40, 0xF236FB40, 0xF237FB40, 0xF238FB40, 0xF239FB40, 0xF23AFB40, 0xF23BFB40, 0xF23CFB40, 0xF23DFB40, 0xF23EFB40, 0xF23FFB40, 0xF240FB40, 0xF241FB40, 0xF242FB40, 0xF243FB40, 0xF244FB40, 0xF245FB40, 0xF246FB40, 0xF247FB40, 0xF248FB40, 0xF249FB40, 0xF24AFB40, 0xF24BFB40, 0xF24CFB40, 0xF24DFB40, 0xF24EFB40, 0xF24FFB40, 0xF250FB40, 0xF251FB40, 0xF252FB40, 0xF253FB40, 0xF254FB40, 0xF255FB40, 0xF256FB40, 0xF257FB40, 0xF258FB40, 0xF259FB40, 0xF25AFB40, 0xF25BFB40, 0xF25CFB40, 0xF25DFB40, 0xF25EFB40, 0xF25FFB40, 0xF260FB40, 0xF261FB40, 0xF262FB40, 0xF263FB40, 0xF264FB40, 0xF265FB40, 0xF266FB40, 0xF267FB40, 0xF268FB40, 0xF269FB40, 0xF26AFB40, 0xF26BFB40, 0xF26CFB40, 0xF26DFB40, 0xF26EFB40, 0xF26FFB40, 0xF270FB40, 0xF271FB40, 0xF272FB40, 0xF273FB40, 0xF274FB40, 0xF275FB40, 0xF276FB40, 0xF277FB40, 0xF278FB40, 0xF279FB40, 0xF27AFB40, 0xF27BFB40, 0xF27CFB40, 0xF27DFB40, 0xF27EFB40, 0xF27FFB40, 0xF280FB40, 0xF281FB40, 0xF282FB40, 0xF283FB40, 0xF284FB40, 0xF285FB40, 0xF286FB40, 0xF287FB40, 0xF288FB40, 0xF289FB40, 0xF28AFB40, 0xF28BFB40, 0xF28CFB40, 0xF28DFB40, 0xF28EFB40, 0xF28FFB40, 0xF290FB40, 0xF291FB40, 0xF292FB40, 0xF293FB40, 0xF294FB40, 0xF295FB40, 0xF296FB40, 0xF297FB40, 0xF298FB40, 0xF299FB40, 0xF29AFB40, 0xF29BFB40, 0xF29CFB40, 0xF29DFB40, 0xF29EFB40, 0xF29FFB40, 0xF2A0FB40, 0xF2A1FB40, /* 71F8 */
+ 0xF2A2FB40, 0xF2A3FB40, 0xF2A4FB40, 0xF2A5FB40, 0xF2A6FB40, 0xF2A7FB40, 0xF2A8FB40, 0xF2A9FB40, 0xF2AAFB40, 0xF2ABFB40, 0xF2ACFB40, 0xF2ADFB40, 0xF2AEFB40, 0xF2AFFB40, 0xF2B0FB40, 0xF2B1FB40, 0xF2B2FB40, 0xF2B3FB40, 0xF2B4FB40, 0xF2B5FB40, 0xF2B6FB40, 0xF2B7FB40, 0xF2B8FB40, 0xF2B9FB40, 0xF2BAFB40, 0xF2BBFB40, 0xF2BCFB40, 0xF2BDFB40, 0xF2BEFB40, 0xF2BFFB40, 0xF2C0FB40, 0xF2C1FB40, 0xF2C2FB40, 0xF2C3FB40, 0xF2C4FB40, 0xF2C5FB40, 0xF2C6FB40, 0xF2C7FB40, 0xF2C8FB40, 0xF2C9FB40, 0xF2CAFB40, 0xF2CBFB40, 0xF2CCFB40, 0xF2CDFB40, 0xF2CEFB40, 0xF2CFFB40, 0xF2D0FB40, 0xF2D1FB40, 0xF2D2FB40, 0xF2D3FB40, 0xF2D4FB40, 0xF2D5FB40, 0xF2D6FB40, 0xF2D7FB40, 0xF2D8FB40, 0xF2D9FB40, 0xF2DAFB40, 0xF2DBFB40, 0xF2DCFB40, 0xF2DDFB40, 0xF2DEFB40, 0xF2DFFB40, 0xF2E0FB40, 0xF2E1FB40, 0xF2E2FB40, 0xF2E3FB40, 0xF2E4FB40, 0xF2E5FB40, 0xF2E6FB40, 0xF2E7FB40, 0xF2E8FB40, 0xF2E9FB40, 0xF2EAFB40, 0xF2EBFB40, 0xF2ECFB40, 0xF2EDFB40, 0xF2EEFB40, 0xF2EFFB40, 0xF2F0FB40, 0xF2F1FB40, 0xF2F2FB40, 0xF2F3FB40, 0xF2F4FB40, 0xF2F5FB40, 0xF2F6FB40, 0xF2F7FB40, 0xF2F8FB40, 0xF2F9FB40, 0xF2FAFB40, 0xF2FBFB40, 0xF2FCFB40, 0xF2FDFB40, 0xF2FEFB40, 0xF2FFFB40, 0xF300FB40, 0xF301FB40, 0xF302FB40, 0xF303FB40, 0xF304FB40, 0xF305FB40, 0xF306FB40, 0xF307FB40, 0xF308FB40, 0xF309FB40, 0xF30AFB40, 0xF30BFB40, 0xF30CFB40, 0xF30DFB40, 0xF30EFB40, 0xF30FFB40, 0xF310FB40, 0xF311FB40, 0xF312FB40, 0xF313FB40, 0xF314FB40, 0xF315FB40, 0xF316FB40, 0xF317FB40, 0xF318FB40, 0xF319FB40, 0xF31AFB40, 0xF31BFB40, 0xF31CFB40, 0xF31DFB40, 0xF31EFB40, 0xF31FFB40, 0xF320FB40, 0xF321FB40, 0xF322FB40, 0xF323FB40, 0xF324FB40, 0xF325FB40, 0xF326FB40, 0xF327FB40, 0xF328FB40, 0xF329FB40, 0xF32AFB40, 0xF32BFB40, 0xF32CFB40, 0xF32DFB40, 0xF32EFB40, 0xF32FFB40, 0xF330FB40, 0xF331FB40, 0xF332FB40, 0xF333FB40, 0xF334FB40, 0xF335FB40, 0xF336FB40, 0xF337FB40, 0xF338FB40, 0xF339FB40, 0xF33AFB40, 0xF33BFB40, 0xF33CFB40, 0xF33DFB40, 0xF33EFB40, 0xF33FFB40, 0xF340FB40, 0xF341FB40, 0xF342FB40, 0xF343FB40, 0xF344FB40, 0xF345FB40, 0xF346FB40, 0xF347FB40, 0xF348FB40, 0xF349FB40, 0xF34AFB40, 0xF34BFB40, /* 72A2 */
+ 0xF34CFB40, 0xF34DFB40, 0xF34EFB40, 0xF34FFB40, 0xF350FB40, 0xF351FB40, 0xF352FB40, 0xF353FB40, 0xF354FB40, 0xF355FB40, 0xF356FB40, 0xF357FB40, 0xF358FB40, 0xF359FB40, 0xF35AFB40, 0xF35BFB40, 0xF35CFB40, 0xF35DFB40, 0xF35EFB40, 0xF35FFB40, 0xF360FB40, 0xF361FB40, 0xF362FB40, 0xF363FB40, 0xF364FB40, 0xF365FB40, 0xF366FB40, 0xF367FB40, 0xF368FB40, 0xF369FB40, 0xF36AFB40, 0xF36BFB40, 0xF36CFB40, 0xF36DFB40, 0xF36EFB40, 0xF36FFB40, 0xF370FB40, 0xF371FB40, 0xF372FB40, 0xF373FB40, 0xF374FB40, 0xF375FB40, 0xF376FB40, 0xF377FB40, 0xF378FB40, 0xF379FB40, 0xF37AFB40, 0xF37BFB40, 0xF37CFB40, 0xF37DFB40, 0xF37EFB40, 0xF37FFB40, 0xF380FB40, 0xF381FB40, 0xF382FB40, 0xF383FB40, 0xF384FB40, 0xF385FB40, 0xF386FB40, 0xF387FB40, 0xF388FB40, 0xF389FB40, 0xF38AFB40, 0xF38BFB40, 0xF38CFB40, 0xF38DFB40, 0xF38EFB40, 0xF38FFB40, 0xF390FB40, 0xF391FB40, 0xF392FB40, 0xF393FB40, 0xF394FB40, 0xF395FB40, 0xF396FB40, 0xF397FB40, 0xF398FB40, 0xF399FB40, 0xF39AFB40, 0xF39BFB40, 0xF39CFB40, 0xF39DFB40, 0xF39EFB40, 0xF39FFB40, 0xF3A0FB40, 0xF3A1FB40, 0xF3A2FB40, 0xF3A3FB40, 0xF3A4FB40, 0xF3A5FB40, 0xF3A6FB40, 0xF3A7FB40, 0xF3A8FB40, 0xF3A9FB40, 0xF3AAFB40, 0xF3ABFB40, 0xF3ACFB40, 0xF3ADFB40, 0xF3AEFB40, 0xF3AFFB40, 0xF3B0FB40, 0xF3B1FB40, 0xF3B2FB40, 0xF3B3FB40, 0xF3B4FB40, 0xF3B5FB40, 0xF3B6FB40, 0xF3B7FB40, 0xF3B8FB40, 0xF3B9FB40, 0xF3BAFB40, 0xF3BBFB40, 0xF3BCFB40, 0xF3BDFB40, 0xF3BEFB40, 0xF3BFFB40, 0xF3C0FB40, 0xF3C1FB40, 0xF3C2FB40, 0xF3C3FB40, 0xF3C4FB40, 0xF3C5FB40, 0xF3C6FB40, 0xF3C7FB40, 0xF3C8FB40, 0xF3C9FB40, 0xF3CAFB40, 0xF3CBFB40, 0xF3CCFB40, 0xF3CDFB40, 0xF3CEFB40, 0xF3CFFB40, 0xF3D0FB40, 0xF3D1FB40, 0xF3D2FB40, 0xF3D3FB40, 0xF3D4FB40, 0xF3D5FB40, 0xF3D6FB40, 0xF3D7FB40, 0xF3D8FB40, 0xF3D9FB40, 0xF3DAFB40, 0xF3DBFB40, 0xF3DCFB40, 0xF3DDFB40, 0xF3DEFB40, 0xF3DFFB40, 0xF3E0FB40, 0xF3E1FB40, 0xF3E2FB40, 0xF3E3FB40, 0xF3E4FB40, 0xF3E5FB40, 0xF3E6FB40, 0xF3E7FB40, 0xF3E8FB40, 0xF3E9FB40, 0xF3EAFB40, 0xF3EBFB40, 0xF3ECFB40, 0xF3EDFB40, 0xF3EEFB40, 0xF3EFFB40, 0xF3F0FB40, 0xF3F1FB40, 0xF3F2FB40, 0xF3F3FB40, 0xF3F4FB40, 0xF3F5FB40, /* 734C */
+ 0xF3F6FB40, 0xF3F7FB40, 0xF3F8FB40, 0xF3F9FB40, 0xF3FAFB40, 0xF3FBFB40, 0xF3FCFB40, 0xF3FDFB40, 0xF3FEFB40, 0xF3FFFB40, 0xF400FB40, 0xF401FB40, 0xF402FB40, 0xF403FB40, 0xF404FB40, 0xF405FB40, 0xF406FB40, 0xF407FB40, 0xF408FB40, 0xF409FB40, 0xF40AFB40, 0xF40BFB40, 0xF40CFB40, 0xF40DFB40, 0xF40EFB40, 0xF40FFB40, 0xF410FB40, 0xF411FB40, 0xF412FB40, 0xF413FB40, 0xF414FB40, 0xF415FB40, 0xF416FB40, 0xF417FB40, 0xF418FB40, 0xF419FB40, 0xF41AFB40, 0xF41BFB40, 0xF41CFB40, 0xF41DFB40, 0xF41EFB40, 0xF41FFB40, 0xF420FB40, 0xF421FB40, 0xF422FB40, 0xF423FB40, 0xF424FB40, 0xF425FB40, 0xF426FB40, 0xF427FB40, 0xF428FB40, 0xF429FB40, 0xF42AFB40, 0xF42BFB40, 0xF42CFB40, 0xF42DFB40, 0xF42EFB40, 0xF42FFB40, 0xF430FB40, 0xF431FB40, 0xF432FB40, 0xF433FB40, 0xF434FB40, 0xF435FB40, 0xF436FB40, 0xF437FB40, 0xF438FB40, 0xF439FB40, 0xF43AFB40, 0xF43BFB40, 0xF43CFB40, 0xF43DFB40, 0xF43EFB40, 0xF43FFB40, 0xF440FB40, 0xF441FB40, 0xF442FB40, 0xF443FB40, 0xF444FB40, 0xF445FB40, 0xF446FB40, 0xF447FB40, 0xF448FB40, 0xF449FB40, 0xF44AFB40, 0xF44BFB40, 0xF44CFB40, 0xF44DFB40, 0xF44EFB40, 0xF44FFB40, 0xF450FB40, 0xF451FB40, 0xF452FB40, 0xF453FB40, 0xF454FB40, 0xF455FB40, 0xF456FB40, 0xF457FB40, 0xF458FB40, 0xF459FB40, 0xF45AFB40, 0xF45BFB40, 0xF45CFB40, 0xF45DFB40, 0xF45EFB40, 0xF45FFB40, 0xF460FB40, 0xF461FB40, 0xF462FB40, 0xF463FB40, 0xF464FB40, 0xF465FB40, 0xF466FB40, 0xF467FB40, 0xF468FB40, 0xF469FB40, 0xF46AFB40, 0xF46BFB40, 0xF46CFB40, 0xF46DFB40, 0xF46EFB40, 0xF46FFB40, 0xF470FB40, 0xF471FB40, 0xF472FB40, 0xF473FB40, 0xF474FB40, 0xF475FB40, 0xF476FB40, 0xF477FB40, 0xF478FB40, 0xF479FB40, 0xF47AFB40, 0xF47BFB40, 0xF47CFB40, 0xF47DFB40, 0xF47EFB40, 0xF47FFB40, 0xF480FB40, 0xF481FB40, 0xF482FB40, 0xF483FB40, 0xF484FB40, 0xF485FB40, 0xF486FB40, 0xF487FB40, 0xF488FB40, 0xF489FB40, 0xF48AFB40, 0xF48BFB40, 0xF48CFB40, 0xF48DFB40, 0xF48EFB40, 0xF48FFB40, 0xF490FB40, 0xF491FB40, 0xF492FB40, 0xF493FB40, 0xF494FB40, 0xF495FB40, 0xF496FB40, 0xF497FB40, 0xF498FB40, 0xF499FB40, 0xF49AFB40, 0xF49BFB40, 0xF49CFB40, 0xF49DFB40, 0xF49EFB40, 0xF49FFB40, /* 73F6 */
+ 0xF4A0FB40, 0xF4A1FB40, 0xF4A2FB40, 0xF4A3FB40, 0xF4A4FB40, 0xF4A5FB40, 0xF4A6FB40, 0xF4A7FB40, 0xF4A8FB40, 0xF4A9FB40, 0xF4AAFB40, 0xF4ABFB40, 0xF4ACFB40, 0xF4ADFB40, 0xF4AEFB40, 0xF4AFFB40, 0xF4B0FB40, 0xF4B1FB40, 0xF4B2FB40, 0xF4B3FB40, 0xF4B4FB40, 0xF4B5FB40, 0xF4B6FB40, 0xF4B7FB40, 0xF4B8FB40, 0xF4B9FB40, 0xF4BAFB40, 0xF4BBFB40, 0xF4BCFB40, 0xF4BDFB40, 0xF4BEFB40, 0xF4BFFB40, 0xF4C0FB40, 0xF4C1FB40, 0xF4C2FB40, 0xF4C3FB40, 0xF4C4FB40, 0xF4C5FB40, 0xF4C6FB40, 0xF4C7FB40, 0xF4C8FB40, 0xF4C9FB40, 0xF4CAFB40, 0xF4CBFB40, 0xF4CCFB40, 0xF4CDFB40, 0xF4CEFB40, 0xF4CFFB40, 0xF4D0FB40, 0xF4D1FB40, 0xF4D2FB40, 0xF4D3FB40, 0xF4D4FB40, 0xF4D5FB40, 0xF4D6FB40, 0xF4D7FB40, 0xF4D8FB40, 0xF4D9FB40, 0xF4DAFB40, 0xF4DBFB40, 0xF4DCFB40, 0xF4DDFB40, 0xF4DEFB40, 0xF4DFFB40, 0xF4E0FB40, 0xF4E1FB40, 0xF4E2FB40, 0xF4E3FB40, 0xF4E4FB40, 0xF4E5FB40, 0xF4E6FB40, 0xF4E7FB40, 0xF4E8FB40, 0xF4E9FB40, 0xF4EAFB40, 0xF4EBFB40, 0xF4ECFB40, 0xF4EDFB40, 0xF4EEFB40, 0xF4EFFB40, 0xF4F0FB40, 0xF4F1FB40, 0xF4F2FB40, 0xF4F3FB40, 0xF4F4FB40, 0xF4F5FB40, 0xF4F6FB40, 0xF4F7FB40, 0xF4F8FB40, 0xF4F9FB40, 0xF4FAFB40, 0xF4FBFB40, 0xF4FCFB40, 0xF4FDFB40, 0xF4FEFB40, 0xF4FFFB40, 0xF500FB40, 0xF501FB40, 0xF502FB40, 0xF503FB40, 0xF504FB40, 0xF505FB40, 0xF506FB40, 0xF507FB40, 0xF508FB40, 0xF509FB40, 0xF50AFB40, 0xF50BFB40, 0xF50CFB40, 0xF50DFB40, 0xF50EFB40, 0xF50FFB40, 0xF510FB40, 0xF511FB40, 0xF512FB40, 0xF513FB40, 0xF514FB40, 0xF515FB40, 0xF516FB40, 0xF517FB40, 0xF518FB40, 0xF519FB40, 0xF51AFB40, 0xF51BFB40, 0xF51CFB40, 0xF51DFB40, 0xF51EFB40, 0xF51FFB40, 0xF520FB40, 0xF521FB40, 0xF522FB40, 0xF523FB40, 0xF524FB40, 0xF525FB40, 0xF526FB40, 0xF527FB40, 0xF528FB40, 0xF529FB40, 0xF52AFB40, 0xF52BFB40, 0xF52CFB40, 0xF52DFB40, 0xF52EFB40, 0xF52FFB40, 0xF530FB40, 0xF531FB40, 0xF532FB40, 0xF533FB40, 0xF534FB40, 0xF535FB40, 0xF536FB40, 0xF537FB40, 0xF538FB40, 0xF539FB40, 0xF53AFB40, 0xF53BFB40, 0xF53CFB40, 0xF53DFB40, 0xF53EFB40, 0xF53FFB40, 0xF540FB40, 0xF541FB40, 0xF542FB40, 0xF543FB40, 0xF544FB40, 0xF545FB40, 0xF546FB40, 0xF547FB40, 0xF548FB40, 0xF549FB40, /* 74A0 */
+ 0xF54AFB40, 0xF54BFB40, 0xF54CFB40, 0xF54DFB40, 0xF54EFB40, 0xF54FFB40, 0xF550FB40, 0xF551FB40, 0xF552FB40, 0xF553FB40, 0xF554FB40, 0xF555FB40, 0xF556FB40, 0xF557FB40, 0xF558FB40, 0xF559FB40, 0xF55AFB40, 0xF55BFB40, 0xF55CFB40, 0xF55DFB40, 0xF55EFB40, 0xF55FFB40, 0xF560FB40, 0xF561FB40, 0xF562FB40, 0xF563FB40, 0xF564FB40, 0xF565FB40, 0xF566FB40, 0xF567FB40, 0xF568FB40, 0xF569FB40, 0xF56AFB40, 0xF56BFB40, 0xF56CFB40, 0xF56DFB40, 0xF56EFB40, 0xF56FFB40, 0xF570FB40, 0xF571FB40, 0xF572FB40, 0xF573FB40, 0xF574FB40, 0xF575FB40, 0xF576FB40, 0xF577FB40, 0xF578FB40, 0xF579FB40, 0xF57AFB40, 0xF57BFB40, 0xF57CFB40, 0xF57DFB40, 0xF57EFB40, 0xF57FFB40, 0xF580FB40, 0xF581FB40, 0xF582FB40, 0xF583FB40, 0xF584FB40, 0xF585FB40, 0xF586FB40, 0xF587FB40, 0xF588FB40, 0xF589FB40, 0xF58AFB40, 0xF58BFB40, 0xF58CFB40, 0xF58DFB40, 0xF58EFB40, 0xF58FFB40, 0xF590FB40, 0xF591FB40, 0xF592FB40, 0xF593FB40, 0xF594FB40, 0xF595FB40, 0xF596FB40, 0xF597FB40, 0xF598FB40, 0xF599FB40, 0xF59AFB40, 0xF59BFB40, 0xF59CFB40, 0xF59DFB40, 0xF59EFB40, 0xF59FFB40, 0xF5A0FB40, 0xF5A1FB40, 0xF5A2FB40, 0xF5A3FB40, 0xF5A4FB40, 0xF5A5FB40, 0xF5A6FB40, 0xF5A7FB40, 0xF5A8FB40, 0xF5A9FB40, 0xF5AAFB40, 0xF5ABFB40, 0xF5ACFB40, 0xF5ADFB40, 0xF5AEFB40, 0xF5AFFB40, 0xF5B0FB40, 0xF5B1FB40, 0xF5B2FB40, 0xF5B3FB40, 0xF5B4FB40, 0xF5B5FB40, 0xF5B6FB40, 0xF5B7FB40, 0xF5B8FB40, 0xF5B9FB40, 0xF5BAFB40, 0xF5BBFB40, 0xF5BCFB40, 0xF5BDFB40, 0xF5BEFB40, 0xF5BFFB40, 0xF5C0FB40, 0xF5C1FB40, 0xF5C2FB40, 0xF5C3FB40, 0xF5C4FB40, 0xF5C5FB40, 0xF5C6FB40, 0xF5C7FB40, 0xF5C8FB40, 0xF5C9FB40, 0xF5CAFB40, 0xF5CBFB40, 0xF5CCFB40, 0xF5CDFB40, 0xF5CEFB40, 0xF5CFFB40, 0xF5D0FB40, 0xF5D1FB40, 0xF5D2FB40, 0xF5D3FB40, 0xF5D4FB40, 0xF5D5FB40, 0xF5D6FB40, 0xF5D7FB40, 0xF5D8FB40, 0xF5D9FB40, 0xF5DAFB40, 0xF5DBFB40, 0xF5DCFB40, 0xF5DDFB40, 0xF5DEFB40, 0xF5DFFB40, 0xF5E0FB40, 0xF5E1FB40, 0xF5E2FB40, 0xF5E3FB40, 0xF5E4FB40, 0xF5E5FB40, 0xF5E6FB40, 0xF5E7FB40, 0xF5E8FB40, 0xF5E9FB40, 0xF5EAFB40, 0xF5EBFB40, 0xF5ECFB40, 0xF5EDFB40, 0xF5EEFB40, 0xF5EFFB40, 0xF5F0FB40, 0xF5F1FB40, 0xF5F2FB40, 0xF5F3FB40, /* 754A */
+ 0xF5F4FB40, 0xF5F5FB40, 0xF5F6FB40, 0xF5F7FB40, 0xF5F8FB40, 0xF5F9FB40, 0xF5FAFB40, 0xF5FBFB40, 0xF5FCFB40, 0xF5FDFB40, 0xF5FEFB40, 0xF5FFFB40, 0xF600FB40, 0xF601FB40, 0xF602FB40, 0xF603FB40, 0xF604FB40, 0xF605FB40, 0xF606FB40, 0xF607FB40, 0xF608FB40, 0xF609FB40, 0xF60AFB40, 0xF60BFB40, 0xF60CFB40, 0xF60DFB40, 0xF60EFB40, 0xF60FFB40, 0xF610FB40, 0xF611FB40, 0xF612FB40, 0xF613FB40, 0xF614FB40, 0xF615FB40, 0xF616FB40, 0xF617FB40, 0xF618FB40, 0xF619FB40, 0xF61AFB40, 0xF61BFB40, 0xF61CFB40, 0xF61DFB40, 0xF61EFB40, 0xF61FFB40, 0xF620FB40, 0xF621FB40, 0xF622FB40, 0xF623FB40, 0xF624FB40, 0xF625FB40, 0xF626FB40, 0xF627FB40, 0xF628FB40, 0xF629FB40, 0xF62AFB40, 0xF62BFB40, 0xF62CFB40, 0xF62DFB40, 0xF62EFB40, 0xF62FFB40, 0xF630FB40, 0xF631FB40, 0xF632FB40, 0xF633FB40, 0xF634FB40, 0xF635FB40, 0xF636FB40, 0xF637FB40, 0xF638FB40, 0xF639FB40, 0xF63AFB40, 0xF63BFB40, 0xF63CFB40, 0xF63DFB40, 0xF63EFB40, 0xF63FFB40, 0xF640FB40, 0xF641FB40, 0xF642FB40, 0xF643FB40, 0xF644FB40, 0xF645FB40, 0xF646FB40, 0xF647FB40, 0xF648FB40, 0xF649FB40, 0xF64AFB40, 0xF64BFB40, 0xF64CFB40, 0xF64DFB40, 0xF64EFB40, 0xF64FFB40, 0xF650FB40, 0xF651FB40, 0xF652FB40, 0xF653FB40, 0xF654FB40, 0xF655FB40, 0xF656FB40, 0xF657FB40, 0xF658FB40, 0xF659FB40, 0xF65AFB40, 0xF65BFB40, 0xF65CFB40, 0xF65DFB40, 0xF65EFB40, 0xF65FFB40, 0xF660FB40, 0xF661FB40, 0xF662FB40, 0xF663FB40, 0xF664FB40, 0xF665FB40, 0xF666FB40, 0xF667FB40, 0xF668FB40, 0xF669FB40, 0xF66AFB40, 0xF66BFB40, 0xF66CFB40, 0xF66DFB40, 0xF66EFB40, 0xF66FFB40, 0xF670FB40, 0xF671FB40, 0xF672FB40, 0xF673FB40, 0xF674FB40, 0xF675FB40, 0xF676FB40, 0xF677FB40, 0xF678FB40, 0xF679FB40, 0xF67AFB40, 0xF67BFB40, 0xF67CFB40, 0xF67DFB40, 0xF67EFB40, 0xF67FFB40, 0xF680FB40, 0xF681FB40, 0xF682FB40, 0xF683FB40, 0xF684FB40, 0xF685FB40, 0xF686FB40, 0xF687FB40, 0xF688FB40, 0xF689FB40, 0xF68AFB40, 0xF68BFB40, 0xF68CFB40, 0xF68DFB40, 0xF68EFB40, 0xF68FFB40, 0xF690FB40, 0xF691FB40, 0xF692FB40, 0xF693FB40, 0xF694FB40, 0xF695FB40, 0xF696FB40, 0xF697FB40, 0xF698FB40, 0xF699FB40, 0xF69AFB40, 0xF69BFB40, 0xF69CFB40, 0xF69DFB40, /* 75F4 */
+ 0xF69EFB40, 0xF69FFB40, 0xF6A0FB40, 0xF6A1FB40, 0xF6A2FB40, 0xF6A3FB40, 0xF6A4FB40, 0xF6A5FB40, 0xF6A6FB40, 0xF6A7FB40, 0xF6A8FB40, 0xF6A9FB40, 0xF6AAFB40, 0xF6ABFB40, 0xF6ACFB40, 0xF6ADFB40, 0xF6AEFB40, 0xF6AFFB40, 0xF6B0FB40, 0xF6B1FB40, 0xF6B2FB40, 0xF6B3FB40, 0xF6B4FB40, 0xF6B5FB40, 0xF6B6FB40, 0xF6B7FB40, 0xF6B8FB40, 0xF6B9FB40, 0xF6BAFB40, 0xF6BBFB40, 0xF6BCFB40, 0xF6BDFB40, 0xF6BEFB40, 0xF6BFFB40, 0xF6C0FB40, 0xF6C1FB40, 0xF6C2FB40, 0xF6C3FB40, 0xF6C4FB40, 0xF6C5FB40, 0xF6C6FB40, 0xF6C7FB40, 0xF6C8FB40, 0xF6C9FB40, 0xF6CAFB40, 0xF6CBFB40, 0xF6CCFB40, 0xF6CDFB40, 0xF6CEFB40, 0xF6CFFB40, 0xF6D0FB40, 0xF6D1FB40, 0xF6D2FB40, 0xF6D3FB40, 0xF6D4FB40, 0xF6D5FB40, 0xF6D6FB40, 0xF6D7FB40, 0xF6D8FB40, 0xF6D9FB40, 0xF6DAFB40, 0xF6DBFB40, 0xF6DCFB40, 0xF6DDFB40, 0xF6DEFB40, 0xF6DFFB40, 0xF6E0FB40, 0xF6E1FB40, 0xF6E2FB40, 0xF6E3FB40, 0xF6E4FB40, 0xF6E5FB40, 0xF6E6FB40, 0xF6E7FB40, 0xF6E8FB40, 0xF6E9FB40, 0xF6EAFB40, 0xF6EBFB40, 0xF6ECFB40, 0xF6EDFB40, 0xF6EEFB40, 0xF6EFFB40, 0xF6F0FB40, 0xF6F1FB40, 0xF6F2FB40, 0xF6F3FB40, 0xF6F4FB40, 0xF6F5FB40, 0xF6F6FB40, 0xF6F7FB40, 0xF6F8FB40, 0xF6F9FB40, 0xF6FAFB40, 0xF6FBFB40, 0xF6FCFB40, 0xF6FDFB40, 0xF6FEFB40, 0xF6FFFB40, 0xF700FB40, 0xF701FB40, 0xF702FB40, 0xF703FB40, 0xF704FB40, 0xF705FB40, 0xF706FB40, 0xF707FB40, 0xF708FB40, 0xF709FB40, 0xF70AFB40, 0xF70BFB40, 0xF70CFB40, 0xF70DFB40, 0xF70EFB40, 0xF70FFB40, 0xF710FB40, 0xF711FB40, 0xF712FB40, 0xF713FB40, 0xF714FB40, 0xF715FB40, 0xF716FB40, 0xF717FB40, 0xF718FB40, 0xF719FB40, 0xF71AFB40, 0xF71BFB40, 0xF71CFB40, 0xF71DFB40, 0xF71EFB40, 0xF71FFB40, 0xF720FB40, 0xF721FB40, 0xF722FB40, 0xF723FB40, 0xF724FB40, 0xF725FB40, 0xF726FB40, 0xF727FB40, 0xF728FB40, 0xF729FB40, 0xF72AFB40, 0xF72BFB40, 0xF72CFB40, 0xF72DFB40, 0xF72EFB40, 0xF72FFB40, 0xF730FB40, 0xF731FB40, 0xF732FB40, 0xF733FB40, 0xF734FB40, 0xF735FB40, 0xF736FB40, 0xF737FB40, 0xF738FB40, 0xF739FB40, 0xF73AFB40, 0xF73BFB40, 0xF73CFB40, 0xF73DFB40, 0xF73EFB40, 0xF73FFB40, 0xF740FB40, 0xF741FB40, 0xF742FB40, 0xF743FB40, 0xF744FB40, 0xF745FB40, 0xF746FB40, 0xF747FB40, /* 769E */
+ 0xF748FB40, 0xF749FB40, 0xF74AFB40, 0xF74BFB40, 0xF74CFB40, 0xF74DFB40, 0xF74EFB40, 0xF74FFB40, 0xF750FB40, 0xF751FB40, 0xF752FB40, 0xF753FB40, 0xF754FB40, 0xF755FB40, 0xF756FB40, 0xF757FB40, 0xF758FB40, 0xF759FB40, 0xF75AFB40, 0xF75BFB40, 0xF75CFB40, 0xF75DFB40, 0xF75EFB40, 0xF75FFB40, 0xF760FB40, 0xF761FB40, 0xF762FB40, 0xF763FB40, 0xF764FB40, 0xF765FB40, 0xF766FB40, 0xF767FB40, 0xF768FB40, 0xF769FB40, 0xF76AFB40, 0xF76BFB40, 0xF76CFB40, 0xF76DFB40, 0xF76EFB40, 0xF76FFB40, 0xF770FB40, 0xF771FB40, 0xF772FB40, 0xF773FB40, 0xF774FB40, 0xF775FB40, 0xF776FB40, 0xF777FB40, 0xF778FB40, 0xF779FB40, 0xF77AFB40, 0xF77BFB40, 0xF77CFB40, 0xF77DFB40, 0xF77EFB40, 0xF77FFB40, 0xF780FB40, 0xF781FB40, 0xF782FB40, 0xF783FB40, 0xF784FB40, 0xF785FB40, 0xF786FB40, 0xF787FB40, 0xF788FB40, 0xF789FB40, 0xF78AFB40, 0xF78BFB40, 0xF78CFB40, 0xF78DFB40, 0xF78EFB40, 0xF78FFB40, 0xF790FB40, 0xF791FB40, 0xF792FB40, 0xF793FB40, 0xF794FB40, 0xF795FB40, 0xF796FB40, 0xF797FB40, 0xF798FB40, 0xF799FB40, 0xF79AFB40, 0xF79BFB40, 0xF79CFB40, 0xF79DFB40, 0xF79EFB40, 0xF79FFB40, 0xF7A0FB40, 0xF7A1FB40, 0xF7A2FB40, 0xF7A3FB40, 0xF7A4FB40, 0xF7A5FB40, 0xF7A6FB40, 0xF7A7FB40, 0xF7A8FB40, 0xF7A9FB40, 0xF7AAFB40, 0xF7ABFB40, 0xF7ACFB40, 0xF7ADFB40, 0xF7AEFB40, 0xF7AFFB40, 0xF7B0FB40, 0xF7B1FB40, 0xF7B2FB40, 0xF7B3FB40, 0xF7B4FB40, 0xF7B5FB40, 0xF7B6FB40, 0xF7B7FB40, 0xF7B8FB40, 0xF7B9FB40, 0xF7BAFB40, 0xF7BBFB40, 0xF7BCFB40, 0xF7BDFB40, 0xF7BEFB40, 0xF7BFFB40, 0xF7C0FB40, 0xF7C1FB40, 0xF7C2FB40, 0xF7C3FB40, 0xF7C4FB40, 0xF7C5FB40, 0xF7C6FB40, 0xF7C7FB40, 0xF7C8FB40, 0xF7C9FB40, 0xF7CAFB40, 0xF7CBFB40, 0xF7CCFB40, 0xF7CDFB40, 0xF7CEFB40, 0xF7CFFB40, 0xF7D0FB40, 0xF7D1FB40, 0xF7D2FB40, 0xF7D3FB40, 0xF7D4FB40, 0xF7D5FB40, 0xF7D6FB40, 0xF7D7FB40, 0xF7D8FB40, 0xF7D9FB40, 0xF7DAFB40, 0xF7DBFB40, 0xF7DCFB40, 0xF7DDFB40, 0xF7DEFB40, 0xF7DFFB40, 0xF7E0FB40, 0xF7E1FB40, 0xF7E2FB40, 0xF7E3FB40, 0xF7E4FB40, 0xF7E5FB40, 0xF7E6FB40, 0xF7E7FB40, 0xF7E8FB40, 0xF7E9FB40, 0xF7EAFB40, 0xF7EBFB40, 0xF7ECFB40, 0xF7EDFB40, 0xF7EEFB40, 0xF7EFFB40, 0xF7F0FB40, 0xF7F1FB40, /* 7748 */
+ 0xF7F2FB40, 0xF7F3FB40, 0xF7F4FB40, 0xF7F5FB40, 0xF7F6FB40, 0xF7F7FB40, 0xF7F8FB40, 0xF7F9FB40, 0xF7FAFB40, 0xF7FBFB40, 0xF7FCFB40, 0xF7FDFB40, 0xF7FEFB40, 0xF7FFFB40, 0xF800FB40, 0xF801FB40, 0xF802FB40, 0xF803FB40, 0xF804FB40, 0xF805FB40, 0xF806FB40, 0xF807FB40, 0xF808FB40, 0xF809FB40, 0xF80AFB40, 0xF80BFB40, 0xF80CFB40, 0xF80DFB40, 0xF80EFB40, 0xF80FFB40, 0xF810FB40, 0xF811FB40, 0xF812FB40, 0xF813FB40, 0xF814FB40, 0xF815FB40, 0xF816FB40, 0xF817FB40, 0xF818FB40, 0xF819FB40, 0xF81AFB40, 0xF81BFB40, 0xF81CFB40, 0xF81DFB40, 0xF81EFB40, 0xF81FFB40, 0xF820FB40, 0xF821FB40, 0xF822FB40, 0xF823FB40, 0xF824FB40, 0xF825FB40, 0xF826FB40, 0xF827FB40, 0xF828FB40, 0xF829FB40, 0xF82AFB40, 0xF82BFB40, 0xF82CFB40, 0xF82DFB40, 0xF82EFB40, 0xF82FFB40, 0xF830FB40, 0xF831FB40, 0xF832FB40, 0xF833FB40, 0xF834FB40, 0xF835FB40, 0xF836FB40, 0xF837FB40, 0xF838FB40, 0xF839FB40, 0xF83AFB40, 0xF83BFB40, 0xF83CFB40, 0xF83DFB40, 0xF83EFB40, 0xF83FFB40, 0xF840FB40, 0xF841FB40, 0xF842FB40, 0xF843FB40, 0xF844FB40, 0xF845FB40, 0xF846FB40, 0xF847FB40, 0xF848FB40, 0xF849FB40, 0xF84AFB40, 0xF84BFB40, 0xF84CFB40, 0xF84DFB40, 0xF84EFB40, 0xF84FFB40, 0xF850FB40, 0xF851FB40, 0xF852FB40, 0xF853FB40, 0xF854FB40, 0xF855FB40, 0xF856FB40, 0xF857FB40, 0xF858FB40, 0xF859FB40, 0xF85AFB40, 0xF85BFB40, 0xF85CFB40, 0xF85DFB40, 0xF85EFB40, 0xF85FFB40, 0xF860FB40, 0xF861FB40, 0xF862FB40, 0xF863FB40, 0xF864FB40, 0xF865FB40, 0xF866FB40, 0xF867FB40, 0xF868FB40, 0xF869FB40, 0xF86AFB40, 0xF86BFB40, 0xF86CFB40, 0xF86DFB40, 0xF86EFB40, 0xF86FFB40, 0xF870FB40, 0xF871FB40, 0xF872FB40, 0xF873FB40, 0xF874FB40, 0xF875FB40, 0xF876FB40, 0xF877FB40, 0xF878FB40, 0xF879FB40, 0xF87AFB40, 0xF87BFB40, 0xF87CFB40, 0xF87DFB40, 0xF87EFB40, 0xF87FFB40, 0xF880FB40, 0xF881FB40, 0xF882FB40, 0xF883FB40, 0xF884FB40, 0xF885FB40, 0xF886FB40, 0xF887FB40, 0xF888FB40, 0xF889FB40, 0xF88AFB40, 0xF88BFB40, 0xF88CFB40, 0xF88DFB40, 0xF88EFB40, 0xF88FFB40, 0xF890FB40, 0xF891FB40, 0xF892FB40, 0xF893FB40, 0xF894FB40, 0xF895FB40, 0xF896FB40, 0xF897FB40, 0xF898FB40, 0xF899FB40, 0xF89AFB40, 0xF89BFB40, /* 77F2 */
+ 0xF89CFB40, 0xF89DFB40, 0xF89EFB40, 0xF89FFB40, 0xF8A0FB40, 0xF8A1FB40, 0xF8A2FB40, 0xF8A3FB40, 0xF8A4FB40, 0xF8A5FB40, 0xF8A6FB40, 0xF8A7FB40, 0xF8A8FB40, 0xF8A9FB40, 0xF8AAFB40, 0xF8ABFB40, 0xF8ACFB40, 0xF8ADFB40, 0xF8AEFB40, 0xF8AFFB40, 0xF8B0FB40, 0xF8B1FB40, 0xF8B2FB40, 0xF8B3FB40, 0xF8B4FB40, 0xF8B5FB40, 0xF8B6FB40, 0xF8B7FB40, 0xF8B8FB40, 0xF8B9FB40, 0xF8BAFB40, 0xF8BBFB40, 0xF8BCFB40, 0xF8BDFB40, 0xF8BEFB40, 0xF8BFFB40, 0xF8C0FB40, 0xF8C1FB40, 0xF8C2FB40, 0xF8C3FB40, 0xF8C4FB40, 0xF8C5FB40, 0xF8C6FB40, 0xF8C7FB40, 0xF8C8FB40, 0xF8C9FB40, 0xF8CAFB40, 0xF8CBFB40, 0xF8CCFB40, 0xF8CDFB40, 0xF8CEFB40, 0xF8CFFB40, 0xF8D0FB40, 0xF8D1FB40, 0xF8D2FB40, 0xF8D3FB40, 0xF8D4FB40, 0xF8D5FB40, 0xF8D6FB40, 0xF8D7FB40, 0xF8D8FB40, 0xF8D9FB40, 0xF8DAFB40, 0xF8DBFB40, 0xF8DCFB40, 0xF8DDFB40, 0xF8DEFB40, 0xF8DFFB40, 0xF8E0FB40, 0xF8E1FB40, 0xF8E2FB40, 0xF8E3FB40, 0xF8E4FB40, 0xF8E5FB40, 0xF8E6FB40, 0xF8E7FB40, 0xF8E8FB40, 0xF8E9FB40, 0xF8EAFB40, 0xF8EBFB40, 0xF8ECFB40, 0xF8EDFB40, 0xF8EEFB40, 0xF8EFFB40, 0xF8F0FB40, 0xF8F1FB40, 0xF8F2FB40, 0xF8F3FB40, 0xF8F4FB40, 0xF8F5FB40, 0xF8F6FB40, 0xF8F7FB40, 0xF8F8FB40, 0xF8F9FB40, 0xF8FAFB40, 0xF8FBFB40, 0xF8FCFB40, 0xF8FDFB40, 0xF8FEFB40, 0xF8FFFB40, 0xF900FB40, 0xF901FB40, 0xF902FB40, 0xF903FB40, 0xF904FB40, 0xF905FB40, 0xF906FB40, 0xF907FB40, 0xF908FB40, 0xF909FB40, 0xF90AFB40, 0xF90BFB40, 0xF90CFB40, 0xF90DFB40, 0xF90EFB40, 0xF90FFB40, 0xF910FB40, 0xF911FB40, 0xF912FB40, 0xF913FB40, 0xF914FB40, 0xF915FB40, 0xF916FB40, 0xF917FB40, 0xF918FB40, 0xF919FB40, 0xF91AFB40, 0xF91BFB40, 0xF91CFB40, 0xF91DFB40, 0xF91EFB40, 0xF91FFB40, 0xF920FB40, 0xF921FB40, 0xF922FB40, 0xF923FB40, 0xF924FB40, 0xF925FB40, 0xF926FB40, 0xF927FB40, 0xF928FB40, 0xF929FB40, 0xF92AFB40, 0xF92BFB40, 0xF92CFB40, 0xF92DFB40, 0xF92EFB40, 0xF92FFB40, 0xF930FB40, 0xF931FB40, 0xF932FB40, 0xF933FB40, 0xF934FB40, 0xF935FB40, 0xF936FB40, 0xF937FB40, 0xF938FB40, 0xF939FB40, 0xF93AFB40, 0xF93BFB40, 0xF93CFB40, 0xF93DFB40, 0xF93EFB40, 0xF93FFB40, 0xF940FB40, 0xF941FB40, 0xF942FB40, 0xF943FB40, 0xF944FB40, 0xF945FB40, /* 789C */
+ 0xF946FB40, 0xF947FB40, 0xF948FB40, 0xF949FB40, 0xF94AFB40, 0xF94BFB40, 0xF94CFB40, 0xF94DFB40, 0xF94EFB40, 0xF94FFB40, 0xF950FB40, 0xF951FB40, 0xF952FB40, 0xF953FB40, 0xF954FB40, 0xF955FB40, 0xF956FB40, 0xF957FB40, 0xF958FB40, 0xF959FB40, 0xF95AFB40, 0xF95BFB40, 0xF95CFB40, 0xF95DFB40, 0xF95EFB40, 0xF95FFB40, 0xF960FB40, 0xF961FB40, 0xF962FB40, 0xF963FB40, 0xF964FB40, 0xF965FB40, 0xF966FB40, 0xF967FB40, 0xF968FB40, 0xF969FB40, 0xF96AFB40, 0xF96BFB40, 0xF96CFB40, 0xF96DFB40, 0xF96EFB40, 0xF96FFB40, 0xF970FB40, 0xF971FB40, 0xF972FB40, 0xF973FB40, 0xF974FB40, 0xF975FB40, 0xF976FB40, 0xF977FB40, 0xF978FB40, 0xF979FB40, 0xF97AFB40, 0xF97BFB40, 0xF97CFB40, 0xF97DFB40, 0xF97EFB40, 0xF97FFB40, 0xF980FB40, 0xF981FB40, 0xF982FB40, 0xF983FB40, 0xF984FB40, 0xF985FB40, 0xF986FB40, 0xF987FB40, 0xF988FB40, 0xF989FB40, 0xF98AFB40, 0xF98BFB40, 0xF98CFB40, 0xF98DFB40, 0xF98EFB40, 0xF98FFB40, 0xF990FB40, 0xF991FB40, 0xF992FB40, 0xF993FB40, 0xF994FB40, 0xF995FB40, 0xF996FB40, 0xF997FB40, 0xF998FB40, 0xF999FB40, 0xF99AFB40, 0xF99BFB40, 0xF99CFB40, 0xF99DFB40, 0xF99EFB40, 0xF99FFB40, 0xF9A0FB40, 0xF9A1FB40, 0xF9A2FB40, 0xF9A3FB40, 0xF9A4FB40, 0xF9A5FB40, 0xF9A6FB40, 0xF9A7FB40, 0xF9A8FB40, 0xF9A9FB40, 0xF9AAFB40, 0xF9ABFB40, 0xF9ACFB40, 0xF9ADFB40, 0xF9AEFB40, 0xF9AFFB40, 0xF9B0FB40, 0xF9B1FB40, 0xF9B2FB40, 0xF9B3FB40, 0xF9B4FB40, 0xF9B5FB40, 0xF9B6FB40, 0xF9B7FB40, 0xF9B8FB40, 0xF9B9FB40, 0xF9BAFB40, 0xF9BBFB40, 0xF9BCFB40, 0xF9BDFB40, 0xF9BEFB40, 0xF9BFFB40, 0xF9C0FB40, 0xF9C1FB40, 0xF9C2FB40, 0xF9C3FB40, 0xF9C4FB40, 0xF9C5FB40, 0xF9C6FB40, 0xF9C7FB40, 0xF9C8FB40, 0xF9C9FB40, 0xF9CAFB40, 0xF9CBFB40, 0xF9CCFB40, 0xF9CDFB40, 0xF9CEFB40, 0xF9CFFB40, 0xF9D0FB40, 0xF9D1FB40, 0xF9D2FB40, 0xF9D3FB40, 0xF9D4FB40, 0xF9D5FB40, 0xF9D6FB40, 0xF9D7FB40, 0xF9D8FB40, 0xF9D9FB40, 0xF9DAFB40, 0xF9DBFB40, 0xF9DCFB40, 0xF9DDFB40, 0xF9DEFB40, 0xF9DFFB40, 0xF9E0FB40, 0xF9E1FB40, 0xF9E2FB40, 0xF9E3FB40, 0xF9E4FB40, 0xF9E5FB40, 0xF9E6FB40, 0xF9E7FB40, 0xF9E8FB40, 0xF9E9FB40, 0xF9EAFB40, 0xF9EBFB40, 0xF9ECFB40, 0xF9EDFB40, 0xF9EEFB40, 0xF9EFFB40, /* 7946 */
+ 0xF9F0FB40, 0xF9F1FB40, 0xF9F2FB40, 0xF9F3FB40, 0xF9F4FB40, 0xF9F5FB40, 0xF9F6FB40, 0xF9F7FB40, 0xF9F8FB40, 0xF9F9FB40, 0xF9FAFB40, 0xF9FBFB40, 0xF9FCFB40, 0xF9FDFB40, 0xF9FEFB40, 0xF9FFFB40, 0xFA00FB40, 0xFA01FB40, 0xFA02FB40, 0xFA03FB40, 0xFA04FB40, 0xFA05FB40, 0xFA06FB40, 0xFA07FB40, 0xFA08FB40, 0xFA09FB40, 0xFA0AFB40, 0xFA0BFB40, 0xFA0CFB40, 0xFA0DFB40, 0xFA0EFB40, 0xFA0FFB40, 0xFA10FB40, 0xFA11FB40, 0xFA12FB40, 0xFA13FB40, 0xFA14FB40, 0xFA15FB40, 0xFA16FB40, 0xFA17FB40, 0xFA18FB40, 0xFA19FB40, 0xFA1AFB40, 0xFA1BFB40, 0xFA1CFB40, 0xFA1DFB40, 0xFA1EFB40, 0xFA1FFB40, 0xFA20FB40, 0xFA21FB40, 0xFA22FB40, 0xFA23FB40, 0xFA24FB40, 0xFA25FB40, 0xFA26FB40, 0xFA27FB40, 0xFA28FB40, 0xFA29FB40, 0xFA2AFB40, 0xFA2BFB40, 0xFA2CFB40, 0xFA2DFB40, 0xFA2EFB40, 0xFA2FFB40, 0xFA30FB40, 0xFA31FB40, 0xFA32FB40, 0xFA33FB40, 0xFA34FB40, 0xFA35FB40, 0xFA36FB40, 0xFA37FB40, 0xFA38FB40, 0xFA39FB40, 0xFA3AFB40, 0xFA3BFB40, 0xFA3CFB40, 0xFA3DFB40, 0xFA3EFB40, 0xFA3FFB40, 0xFA40FB40, 0xFA41FB40, 0xFA42FB40, 0xFA43FB40, 0xFA44FB40, 0xFA45FB40, 0xFA46FB40, 0xFA47FB40, 0xFA48FB40, 0xFA49FB40, 0xFA4AFB40, 0xFA4BFB40, 0xFA4CFB40, 0xFA4DFB40, 0xFA4EFB40, 0xFA4FFB40, 0xFA50FB40, 0xFA51FB40, 0xFA52FB40, 0xFA53FB40, 0xFA54FB40, 0xFA55FB40, 0xFA56FB40, 0xFA57FB40, 0xFA58FB40, 0xFA59FB40, 0xFA5AFB40, 0xFA5BFB40, 0xFA5CFB40, 0xFA5DFB40, 0xFA5EFB40, 0xFA5FFB40, 0xFA60FB40, 0xFA61FB40, 0xFA62FB40, 0xFA63FB40, 0xFA64FB40, 0xFA65FB40, 0xFA66FB40, 0xFA67FB40, 0xFA68FB40, 0xFA69FB40, 0xFA6AFB40, 0xFA6BFB40, 0xFA6CFB40, 0xFA6DFB40, 0xFA6EFB40, 0xFA6FFB40, 0xFA70FB40, 0xFA71FB40, 0xFA72FB40, 0xFA73FB40, 0xFA74FB40, 0xFA75FB40, 0xFA76FB40, 0xFA77FB40, 0xFA78FB40, 0xFA79FB40, 0xFA7AFB40, 0xFA7BFB40, 0xFA7CFB40, 0xFA7DFB40, 0xFA7EFB40, 0xFA7FFB40, 0xFA80FB40, 0xFA81FB40, 0xFA82FB40, 0xFA83FB40, 0xFA84FB40, 0xFA85FB40, 0xFA86FB40, 0xFA87FB40, 0xFA88FB40, 0xFA89FB40, 0xFA8AFB40, 0xFA8BFB40, 0xFA8CFB40, 0xFA8DFB40, 0xFA8EFB40, 0xFA8FFB40, 0xFA90FB40, 0xFA91FB40, 0xFA92FB40, 0xFA93FB40, 0xFA94FB40, 0xFA95FB40, 0xFA96FB40, 0xFA97FB40, 0xFA98FB40, 0xFA99FB40, /* 79F0 */
+ 0xFA9AFB40, 0xFA9BFB40, 0xFA9CFB40, 0xFA9DFB40, 0xFA9EFB40, 0xFA9FFB40, 0xFAA0FB40, 0xFAA1FB40, 0xFAA2FB40, 0xFAA3FB40, 0xFAA4FB40, 0xFAA5FB40, 0xFAA6FB40, 0xFAA7FB40, 0xFAA8FB40, 0xFAA9FB40, 0xFAAAFB40, 0xFAABFB40, 0xFAACFB40, 0xFAADFB40, 0xFAAEFB40, 0xFAAFFB40, 0xFAB0FB40, 0xFAB1FB40, 0xFAB2FB40, 0xFAB3FB40, 0xFAB4FB40, 0xFAB5FB40, 0xFAB6FB40, 0xFAB7FB40, 0xFAB8FB40, 0xFAB9FB40, 0xFABAFB40, 0xFABBFB40, 0xFABCFB40, 0xFABDFB40, 0xFABEFB40, 0xFABFFB40, 0xFAC0FB40, 0xFAC1FB40, 0xFAC2FB40, 0xFAC3FB40, 0xFAC4FB40, 0xFAC5FB40, 0xFAC6FB40, 0xFAC7FB40, 0xFAC8FB40, 0xFAC9FB40, 0xFACAFB40, 0xFACBFB40, 0xFACCFB40, 0xFACDFB40, 0xFACEFB40, 0xFACFFB40, 0xFAD0FB40, 0xFAD1FB40, 0xFAD2FB40, 0xFAD3FB40, 0xFAD4FB40, 0xFAD5FB40, 0xFAD6FB40, 0xFAD7FB40, 0xFAD8FB40, 0xFAD9FB40, 0xFADAFB40, 0xFADBFB40, 0xFADCFB40, 0xFADDFB40, 0xFADEFB40, 0xFADFFB40, 0xFAE0FB40, 0xFAE1FB40, 0xFAE2FB40, 0xFAE3FB40, 0xFAE4FB40, 0xFAE5FB40, 0xFAE6FB40, 0xFAE7FB40, 0xFAE8FB40, 0xFAE9FB40, 0xFAEAFB40, 0xFAEBFB40, 0xFAECFB40, 0xFAEDFB40, 0xFAEEFB40, 0xFAEFFB40, 0xFAF0FB40, 0xFAF1FB40, 0xFAF2FB40, 0xFAF3FB40, 0xFAF4FB40, 0xFAF5FB40, 0xFAF6FB40, 0xFAF7FB40, 0xFAF8FB40, 0xFAF9FB40, 0xFAFAFB40, 0xFAFBFB40, 0xFAFCFB40, 0xFAFDFB40, 0xFAFEFB40, 0xFAFFFB40, 0xFB00FB40, 0xFB01FB40, 0xFB02FB40, 0xFB03FB40, 0xFB04FB40, 0xFB05FB40, 0xFB06FB40, 0xFB07FB40, 0xFB08FB40, 0xFB09FB40, 0xFB0AFB40, 0xFB0BFB40, 0xFB0CFB40, 0xFB0DFB40, 0xFB0EFB40, 0xFB0FFB40, 0xFB10FB40, 0xFB11FB40, 0xFB12FB40, 0xFB13FB40, 0xFB14FB40, 0xFB15FB40, 0xFB16FB40, 0xFB17FB40, 0xFB18FB40, 0xFB19FB40, 0xFB1AFB40, 0xFB1BFB40, 0xFB1CFB40, 0xFB1DFB40, 0xFB1EFB40, 0xFB1FFB40, 0xFB20FB40, 0xFB21FB40, 0xFB22FB40, 0xFB23FB40, 0xFB24FB40, 0xFB25FB40, 0xFB26FB40, 0xFB27FB40, 0xFB28FB40, 0xFB29FB40, 0xFB2AFB40, 0xFB2BFB40, 0xFB2CFB40, 0xFB2DFB40, 0xFB2EFB40, 0xFB2FFB40, 0xFB30FB40, 0xFB31FB40, 0xFB32FB40, 0xFB33FB40, 0xFB34FB40, 0xFB35FB40, 0xFB36FB40, 0xFB37FB40, 0xFB38FB40, 0xFB39FB40, 0xFB3AFB40, 0xFB3BFB40, 0xFB3CFB40, 0xFB3DFB40, 0xFB3EFB40, 0xFB3FFB40, 0xFB40FB40, 0xFB41FB40, 0xFB42FB40, 0xFB43FB40, /* 7A9A */
+ 0xFB44FB40, 0xFB45FB40, 0xFB46FB40, 0xFB47FB40, 0xFB48FB40, 0xFB49FB40, 0xFB4AFB40, 0xFB4BFB40, 0xFB4CFB40, 0xFB4DFB40, 0xFB4EFB40, 0xFB4FFB40, 0xFB50FB40, 0xFB51FB40, 0xFB52FB40, 0xFB53FB40, 0xFB54FB40, 0xFB55FB40, 0xFB56FB40, 0xFB57FB40, 0xFB58FB40, 0xFB59FB40, 0xFB5AFB40, 0xFB5BFB40, 0xFB5CFB40, 0xFB5DFB40, 0xFB5EFB40, 0xFB5FFB40, 0xFB60FB40, 0xFB61FB40, 0xFB62FB40, 0xFB63FB40, 0xFB64FB40, 0xFB65FB40, 0xFB66FB40, 0xFB67FB40, 0xFB68FB40, 0xFB69FB40, 0xFB6AFB40, 0xFB6BFB40, 0xFB6CFB40, 0xFB6DFB40, 0xFB6EFB40, 0xFB6FFB40, 0xFB70FB40, 0xFB71FB40, 0xFB72FB40, 0xFB73FB40, 0xFB74FB40, 0xFB75FB40, 0xFB76FB40, 0xFB77FB40, 0xFB78FB40, 0xFB79FB40, 0xFB7AFB40, 0xFB7BFB40, 0xFB7CFB40, 0xFB7DFB40, 0xFB7EFB40, 0xFB7FFB40, 0xFB80FB40, 0xFB81FB40, 0xFB82FB40, 0xFB83FB40, 0xFB84FB40, 0xFB85FB40, 0xFB86FB40, 0xFB87FB40, 0xFB88FB40, 0xFB89FB40, 0xFB8AFB40, 0xFB8BFB40, 0xFB8CFB40, 0xFB8DFB40, 0xFB8EFB40, 0xFB8FFB40, 0xFB90FB40, 0xFB91FB40, 0xFB92FB40, 0xFB93FB40, 0xFB94FB40, 0xFB95FB40, 0xFB96FB40, 0xFB97FB40, 0xFB98FB40, 0xFB99FB40, 0xFB9AFB40, 0xFB9BFB40, 0xFB9CFB40, 0xFB9DFB40, 0xFB9EFB40, 0xFB9FFB40, 0xFBA0FB40, 0xFBA1FB40, 0xFBA2FB40, 0xFBA3FB40, 0xFBA4FB40, 0xFBA5FB40, 0xFBA6FB40, 0xFBA7FB40, 0xFBA8FB40, 0xFBA9FB40, 0xFBAAFB40, 0xFBABFB40, 0xFBACFB40, 0xFBADFB40, 0xFBAEFB40, 0xFBAFFB40, 0xFBB0FB40, 0xFBB1FB40, 0xFBB2FB40, 0xFBB3FB40, 0xFBB4FB40, 0xFBB5FB40, 0xFBB6FB40, 0xFBB7FB40, 0xFBB8FB40, 0xFBB9FB40, 0xFBBAFB40, 0xFBBBFB40, 0xFBBCFB40, 0xFBBDFB40, 0xFBBEFB40, 0xFBBFFB40, 0xFBC0FB40, 0xFBC1FB40, 0xFBC2FB40, 0xFBC3FB40, 0xFBC4FB40, 0xFBC5FB40, 0xFBC6FB40, 0xFBC7FB40, 0xFBC8FB40, 0xFBC9FB40, 0xFBCAFB40, 0xFBCBFB40, 0xFBCCFB40, 0xFBCDFB40, 0xFBCEFB40, 0xFBCFFB40, 0xFBD0FB40, 0xFBD1FB40, 0xFBD2FB40, 0xFBD3FB40, 0xFBD4FB40, 0xFBD5FB40, 0xFBD6FB40, 0xFBD7FB40, 0xFBD8FB40, 0xFBD9FB40, 0xFBDAFB40, 0xFBDBFB40, 0xFBDCFB40, 0xFBDDFB40, 0xFBDEFB40, 0xFBDFFB40, 0xFBE0FB40, 0xFBE1FB40, 0xFBE2FB40, 0xFBE3FB40, 0xFBE4FB40, 0xFBE5FB40, 0xFBE6FB40, 0xFBE7FB40, 0xFBE8FB40, 0xFBE9FB40, 0xFBEAFB40, 0xFBEBFB40, 0xFBECFB40, 0xFBEDFB40, /* 7B44 */
+ 0xFBEEFB40, 0xFBEFFB40, 0xFBF0FB40, 0xFBF1FB40, 0xFBF2FB40, 0xFBF3FB40, 0xFBF4FB40, 0xFBF5FB40, 0xFBF6FB40, 0xFBF7FB40, 0xFBF8FB40, 0xFBF9FB40, 0xFBFAFB40, 0xFBFBFB40, 0xFBFCFB40, 0xFBFDFB40, 0xFBFEFB40, 0xFBFFFB40, 0xFC00FB40, 0xFC01FB40, 0xFC02FB40, 0xFC03FB40, 0xFC04FB40, 0xFC05FB40, 0xFC06FB40, 0xFC07FB40, 0xFC08FB40, 0xFC09FB40, 0xFC0AFB40, 0xFC0BFB40, 0xFC0CFB40, 0xFC0DFB40, 0xFC0EFB40, 0xFC0FFB40, 0xFC10FB40, 0xFC11FB40, 0xFC12FB40, 0xFC13FB40, 0xFC14FB40, 0xFC15FB40, 0xFC16FB40, 0xFC17FB40, 0xFC18FB40, 0xFC19FB40, 0xFC1AFB40, 0xFC1BFB40, 0xFC1CFB40, 0xFC1DFB40, 0xFC1EFB40, 0xFC1FFB40, 0xFC20FB40, 0xFC21FB40, 0xFC22FB40, 0xFC23FB40, 0xFC24FB40, 0xFC25FB40, 0xFC26FB40, 0xFC27FB40, 0xFC28FB40, 0xFC29FB40, 0xFC2AFB40, 0xFC2BFB40, 0xFC2CFB40, 0xFC2DFB40, 0xFC2EFB40, 0xFC2FFB40, 0xFC30FB40, 0xFC31FB40, 0xFC32FB40, 0xFC33FB40, 0xFC34FB40, 0xFC35FB40, 0xFC36FB40, 0xFC37FB40, 0xFC38FB40, 0xFC39FB40, 0xFC3AFB40, 0xFC3BFB40, 0xFC3CFB40, 0xFC3DFB40, 0xFC3EFB40, 0xFC3FFB40, 0xFC40FB40, 0xFC41FB40, 0xFC42FB40, 0xFC43FB40, 0xFC44FB40, 0xFC45FB40, 0xFC46FB40, 0xFC47FB40, 0xFC48FB40, 0xFC49FB40, 0xFC4AFB40, 0xFC4BFB40, 0xFC4CFB40, 0xFC4DFB40, 0xFC4EFB40, 0xFC4FFB40, 0xFC50FB40, 0xFC51FB40, 0xFC52FB40, 0xFC53FB40, 0xFC54FB40, 0xFC55FB40, 0xFC56FB40, 0xFC57FB40, 0xFC58FB40, 0xFC59FB40, 0xFC5AFB40, 0xFC5BFB40, 0xFC5CFB40, 0xFC5DFB40, 0xFC5EFB40, 0xFC5FFB40, 0xFC60FB40, 0xFC61FB40, 0xFC62FB40, 0xFC63FB40, 0xFC64FB40, 0xFC65FB40, 0xFC66FB40, 0xFC67FB40, 0xFC68FB40, 0xFC69FB40, 0xFC6AFB40, 0xFC6BFB40, 0xFC6CFB40, 0xFC6DFB40, 0xFC6EFB40, 0xFC6FFB40, 0xFC70FB40, 0xFC71FB40, 0xFC72FB40, 0xFC73FB40, 0xFC74FB40, 0xFC75FB40, 0xFC76FB40, 0xFC77FB40, 0xFC78FB40, 0xFC79FB40, 0xFC7AFB40, 0xFC7BFB40, 0xFC7CFB40, 0xFC7DFB40, 0xFC7EFB40, 0xFC7FFB40, 0xFC80FB40, 0xFC81FB40, 0xFC82FB40, 0xFC83FB40, 0xFC84FB40, 0xFC85FB40, 0xFC86FB40, 0xFC87FB40, 0xFC88FB40, 0xFC89FB40, 0xFC8AFB40, 0xFC8BFB40, 0xFC8CFB40, 0xFC8DFB40, 0xFC8EFB40, 0xFC8FFB40, 0xFC90FB40, 0xFC91FB40, 0xFC92FB40, 0xFC93FB40, 0xFC94FB40, 0xFC95FB40, 0xFC96FB40, 0xFC97FB40, /* 7BEE */
+ 0xFC98FB40, 0xFC99FB40, 0xFC9AFB40, 0xFC9BFB40, 0xFC9CFB40, 0xFC9DFB40, 0xFC9EFB40, 0xFC9FFB40, 0xFCA0FB40, 0xFCA1FB40, 0xFCA2FB40, 0xFCA3FB40, 0xFCA4FB40, 0xFCA5FB40, 0xFCA6FB40, 0xFCA7FB40, 0xFCA8FB40, 0xFCA9FB40, 0xFCAAFB40, 0xFCABFB40, 0xFCACFB40, 0xFCADFB40, 0xFCAEFB40, 0xFCAFFB40, 0xFCB0FB40, 0xFCB1FB40, 0xFCB2FB40, 0xFCB3FB40, 0xFCB4FB40, 0xFCB5FB40, 0xFCB6FB40, 0xFCB7FB40, 0xFCB8FB40, 0xFCB9FB40, 0xFCBAFB40, 0xFCBBFB40, 0xFCBCFB40, 0xFCBDFB40, 0xFCBEFB40, 0xFCBFFB40, 0xFCC0FB40, 0xFCC1FB40, 0xFCC2FB40, 0xFCC3FB40, 0xFCC4FB40, 0xFCC5FB40, 0xFCC6FB40, 0xFCC7FB40, 0xFCC8FB40, 0xFCC9FB40, 0xFCCAFB40, 0xFCCBFB40, 0xFCCCFB40, 0xFCCDFB40, 0xFCCEFB40, 0xFCCFFB40, 0xFCD0FB40, 0xFCD1FB40, 0xFCD2FB40, 0xFCD3FB40, 0xFCD4FB40, 0xFCD5FB40, 0xFCD6FB40, 0xFCD7FB40, 0xFCD8FB40, 0xFCD9FB40, 0xFCDAFB40, 0xFCDBFB40, 0xFCDCFB40, 0xFCDDFB40, 0xFCDEFB40, 0xFCDFFB40, 0xFCE0FB40, 0xFCE1FB40, 0xFCE2FB40, 0xFCE3FB40, 0xFCE4FB40, 0xFCE5FB40, 0xFCE6FB40, 0xFCE7FB40, 0xFCE8FB40, 0xFCE9FB40, 0xFCEAFB40, 0xFCEBFB40, 0xFCECFB40, 0xFCEDFB40, 0xFCEEFB40, 0xFCEFFB40, 0xFCF0FB40, 0xFCF1FB40, 0xFCF2FB40, 0xFCF3FB40, 0xFCF4FB40, 0xFCF5FB40, 0xFCF6FB40, 0xFCF7FB40, 0xFCF8FB40, 0xFCF9FB40, 0xFCFAFB40, 0xFCFBFB40, 0xFCFCFB40, 0xFCFDFB40, 0xFCFEFB40, 0xFCFFFB40, 0xFD00FB40, 0xFD01FB40, 0xFD02FB40, 0xFD03FB40, 0xFD04FB40, 0xFD05FB40, 0xFD06FB40, 0xFD07FB40, 0xFD08FB40, 0xFD09FB40, 0xFD0AFB40, 0xFD0BFB40, 0xFD0CFB40, 0xFD0DFB40, 0xFD0EFB40, 0xFD0FFB40, 0xFD10FB40, 0xFD11FB40, 0xFD12FB40, 0xFD13FB40, 0xFD14FB40, 0xFD15FB40, 0xFD16FB40, 0xFD17FB40, 0xFD18FB40, 0xFD19FB40, 0xFD1AFB40, 0xFD1BFB40, 0xFD1CFB40, 0xFD1DFB40, 0xFD1EFB40, 0xFD1FFB40, 0xFD20FB40, 0xFD21FB40, 0xFD22FB40, 0xFD23FB40, 0xFD24FB40, 0xFD25FB40, 0xFD26FB40, 0xFD27FB40, 0xFD28FB40, 0xFD29FB40, 0xFD2AFB40, 0xFD2BFB40, 0xFD2CFB40, 0xFD2DFB40, 0xFD2EFB40, 0xFD2FFB40, 0xFD30FB40, 0xFD31FB40, 0xFD32FB40, 0xFD33FB40, 0xFD34FB40, 0xFD35FB40, 0xFD36FB40, 0xFD37FB40, 0xFD38FB40, 0xFD39FB40, 0xFD3AFB40, 0xFD3BFB40, 0xFD3CFB40, 0xFD3DFB40, 0xFD3EFB40, 0xFD3FFB40, 0xFD40FB40, 0xFD41FB40, /* 7C98 */
+ 0xFD42FB40, 0xFD43FB40, 0xFD44FB40, 0xFD45FB40, 0xFD46FB40, 0xFD47FB40, 0xFD48FB40, 0xFD49FB40, 0xFD4AFB40, 0xFD4BFB40, 0xFD4CFB40, 0xFD4DFB40, 0xFD4EFB40, 0xFD4FFB40, 0xFD50FB40, 0xFD51FB40, 0xFD52FB40, 0xFD53FB40, 0xFD54FB40, 0xFD55FB40, 0xFD56FB40, 0xFD57FB40, 0xFD58FB40, 0xFD59FB40, 0xFD5AFB40, 0xFD5BFB40, 0xFD5CFB40, 0xFD5DFB40, 0xFD5EFB40, 0xFD5FFB40, 0xFD60FB40, 0xFD61FB40, 0xFD62FB40, 0xFD63FB40, 0xFD64FB40, 0xFD65FB40, 0xFD66FB40, 0xFD67FB40, 0xFD68FB40, 0xFD69FB40, 0xFD6AFB40, 0xFD6BFB40, 0xFD6CFB40, 0xFD6DFB40, 0xFD6EFB40, 0xFD6FFB40, 0xFD70FB40, 0xFD71FB40, 0xFD72FB40, 0xFD73FB40, 0xFD74FB40, 0xFD75FB40, 0xFD76FB40, 0xFD77FB40, 0xFD78FB40, 0xFD79FB40, 0xFD7AFB40, 0xFD7BFB40, 0xFD7CFB40, 0xFD7DFB40, 0xFD7EFB40, 0xFD7FFB40, 0xFD80FB40, 0xFD81FB40, 0xFD82FB40, 0xFD83FB40, 0xFD84FB40, 0xFD85FB40, 0xFD86FB40, 0xFD87FB40, 0xFD88FB40, 0xFD89FB40, 0xFD8AFB40, 0xFD8BFB40, 0xFD8CFB40, 0xFD8DFB40, 0xFD8EFB40, 0xFD8FFB40, 0xFD90FB40, 0xFD91FB40, 0xFD92FB40, 0xFD93FB40, 0xFD94FB40, 0xFD95FB40, 0xFD96FB40, 0xFD97FB40, 0xFD98FB40, 0xFD99FB40, 0xFD9AFB40, 0xFD9BFB40, 0xFD9CFB40, 0xFD9DFB40, 0xFD9EFB40, 0xFD9FFB40, 0xFDA0FB40, 0xFDA1FB40, 0xFDA2FB40, 0xFDA3FB40, 0xFDA4FB40, 0xFDA5FB40, 0xFDA6FB40, 0xFDA7FB40, 0xFDA8FB40, 0xFDA9FB40, 0xFDAAFB40, 0xFDABFB40, 0xFDACFB40, 0xFDADFB40, 0xFDAEFB40, 0xFDAFFB40, 0xFDB0FB40, 0xFDB1FB40, 0xFDB2FB40, 0xFDB3FB40, 0xFDB4FB40, 0xFDB5FB40, 0xFDB6FB40, 0xFDB7FB40, 0xFDB8FB40, 0xFDB9FB40, 0xFDBAFB40, 0xFDBBFB40, 0xFDBCFB40, 0xFDBDFB40, 0xFDBEFB40, 0xFDBFFB40, 0xFDC0FB40, 0xFDC1FB40, 0xFDC2FB40, 0xFDC3FB40, 0xFDC4FB40, 0xFDC5FB40, 0xFDC6FB40, 0xFDC7FB40, 0xFDC8FB40, 0xFDC9FB40, 0xFDCAFB40, 0xFDCBFB40, 0xFDCCFB40, 0xFDCDFB40, 0xFDCEFB40, 0xFDCFFB40, 0xFDD0FB40, 0xFDD1FB40, 0xFDD2FB40, 0xFDD3FB40, 0xFDD4FB40, 0xFDD5FB40, 0xFDD6FB40, 0xFDD7FB40, 0xFDD8FB40, 0xFDD9FB40, 0xFDDAFB40, 0xFDDBFB40, 0xFDDCFB40, 0xFDDDFB40, 0xFDDEFB40, 0xFDDFFB40, 0xFDE0FB40, 0xFDE1FB40, 0xFDE2FB40, 0xFDE3FB40, 0xFDE4FB40, 0xFDE5FB40, 0xFDE6FB40, 0xFDE7FB40, 0xFDE8FB40, 0xFDE9FB40, 0xFDEAFB40, 0xFDEBFB40, /* 7D42 */
+ 0xFDECFB40, 0xFDEDFB40, 0xFDEEFB40, 0xFDEFFB40, 0xFDF0FB40, 0xFDF1FB40, 0xFDF2FB40, 0xFDF3FB40, 0xFDF4FB40, 0xFDF5FB40, 0xFDF6FB40, 0xFDF7FB40, 0xFDF8FB40, 0xFDF9FB40, 0xFDFAFB40, 0xFDFBFB40, 0xFDFCFB40, 0xFDFDFB40, 0xFDFEFB40, 0xFDFFFB40, 0xFE00FB40, 0xFE01FB40, 0xFE02FB40, 0xFE03FB40, 0xFE04FB40, 0xFE05FB40, 0xFE06FB40, 0xFE07FB40, 0xFE08FB40, 0xFE09FB40, 0xFE0AFB40, 0xFE0BFB40, 0xFE0CFB40, 0xFE0DFB40, 0xFE0EFB40, 0xFE0FFB40, 0xFE10FB40, 0xFE11FB40, 0xFE12FB40, 0xFE13FB40, 0xFE14FB40, 0xFE15FB40, 0xFE16FB40, 0xFE17FB40, 0xFE18FB40, 0xFE19FB40, 0xFE1AFB40, 0xFE1BFB40, 0xFE1CFB40, 0xFE1DFB40, 0xFE1EFB40, 0xFE1FFB40, 0xFE20FB40, 0xFE21FB40, 0xFE22FB40, 0xFE23FB40, 0xFE24FB40, 0xFE25FB40, 0xFE26FB40, 0xFE27FB40, 0xFE28FB40, 0xFE29FB40, 0xFE2AFB40, 0xFE2BFB40, 0xFE2CFB40, 0xFE2DFB40, 0xFE2EFB40, 0xFE2FFB40, 0xFE30FB40, 0xFE31FB40, 0xFE32FB40, 0xFE33FB40, 0xFE34FB40, 0xFE35FB40, 0xFE36FB40, 0xFE37FB40, 0xFE38FB40, 0xFE39FB40, 0xFE3AFB40, 0xFE3BFB40, 0xFE3CFB40, 0xFE3DFB40, 0xFE3EFB40, 0xFE3FFB40, 0xFE40FB40, 0xFE41FB40, 0xFE42FB40, 0xFE43FB40, 0xFE44FB40, 0xFE45FB40, 0xFE46FB40, 0xFE47FB40, 0xFE48FB40, 0xFE49FB40, 0xFE4AFB40, 0xFE4BFB40, 0xFE4CFB40, 0xFE4DFB40, 0xFE4EFB40, 0xFE4FFB40, 0xFE50FB40, 0xFE51FB40, 0xFE52FB40, 0xFE53FB40, 0xFE54FB40, 0xFE55FB40, 0xFE56FB40, 0xFE57FB40, 0xFE58FB40, 0xFE59FB40, 0xFE5AFB40, 0xFE5BFB40, 0xFE5CFB40, 0xFE5DFB40, 0xFE5EFB40, 0xFE5FFB40, 0xFE60FB40, 0xFE61FB40, 0xFE62FB40, 0xFE63FB40, 0xFE64FB40, 0xFE65FB40, 0xFE66FB40, 0xFE67FB40, 0xFE68FB40, 0xFE69FB40, 0xFE6AFB40, 0xFE6BFB40, 0xFE6CFB40, 0xFE6DFB40, 0xFE6EFB40, 0xFE6FFB40, 0xFE70FB40, 0xFE71FB40, 0xFE72FB40, 0xFE73FB40, 0xFE74FB40, 0xFE75FB40, 0xFE76FB40, 0xFE77FB40, 0xFE78FB40, 0xFE79FB40, 0xFE7AFB40, 0xFE7BFB40, 0xFE7CFB40, 0xFE7DFB40, 0xFE7EFB40, 0xFE7FFB40, 0xFE80FB40, 0xFE81FB40, 0xFE82FB40, 0xFE83FB40, 0xFE84FB40, 0xFE85FB40, 0xFE86FB40, 0xFE87FB40, 0xFE88FB40, 0xFE89FB40, 0xFE8AFB40, 0xFE8BFB40, 0xFE8CFB40, 0xFE8DFB40, 0xFE8EFB40, 0xFE8FFB40, 0xFE90FB40, 0xFE91FB40, 0xFE92FB40, 0xFE93FB40, 0xFE94FB40, 0xFE95FB40, /* 7DEC */
+ 0xFE96FB40, 0xFE97FB40, 0xFE98FB40, 0xFE99FB40, 0xFE9AFB40, 0xFE9BFB40, 0xFE9CFB40, 0xFE9DFB40, 0xFE9EFB40, 0xFE9FFB40, 0xFEA0FB40, 0xFEA1FB40, 0xFEA2FB40, 0xFEA3FB40, 0xFEA4FB40, 0xFEA5FB40, 0xFEA6FB40, 0xFEA7FB40, 0xFEA8FB40, 0xFEA9FB40, 0xFEAAFB40, 0xFEABFB40, 0xFEACFB40, 0xFEADFB40, 0xFEAEFB40, 0xFEAFFB40, 0xFEB0FB40, 0xFEB1FB40, 0xFEB2FB40, 0xFEB3FB40, 0xFEB4FB40, 0xFEB5FB40, 0xFEB6FB40, 0xFEB7FB40, 0xFEB8FB40, 0xFEB9FB40, 0xFEBAFB40, 0xFEBBFB40, 0xFEBCFB40, 0xFEBDFB40, 0xFEBEFB40, 0xFEBFFB40, 0xFEC0FB40, 0xFEC1FB40, 0xFEC2FB40, 0xFEC3FB40, 0xFEC4FB40, 0xFEC5FB40, 0xFEC6FB40, 0xFEC7FB40, 0xFEC8FB40, 0xFEC9FB40, 0xFECAFB40, 0xFECBFB40, 0xFECCFB40, 0xFECDFB40, 0xFECEFB40, 0xFECFFB40, 0xFED0FB40, 0xFED1FB40, 0xFED2FB40, 0xFED3FB40, 0xFED4FB40, 0xFED5FB40, 0xFED6FB40, 0xFED7FB40, 0xFED8FB40, 0xFED9FB40, 0xFEDAFB40, 0xFEDBFB40, 0xFEDCFB40, 0xFEDDFB40, 0xFEDEFB40, 0xFEDFFB40, 0xFEE0FB40, 0xFEE1FB40, 0xFEE2FB40, 0xFEE3FB40, 0xFEE4FB40, 0xFEE5FB40, 0xFEE6FB40, 0xFEE7FB40, 0xFEE8FB40, 0xFEE9FB40, 0xFEEAFB40, 0xFEEBFB40, 0xFEECFB40, 0xFEEDFB40, 0xFEEEFB40, 0xFEEFFB40, 0xFEF0FB40, 0xFEF1FB40, 0xFEF2FB40, 0xFEF3FB40, 0xFEF4FB40, 0xFEF5FB40, 0xFEF6FB40, 0xFEF7FB40, 0xFEF8FB40, 0xFEF9FB40, 0xFEFAFB40, 0xFEFBFB40, 0xFEFCFB40, 0xFEFDFB40, 0xFEFEFB40, 0xFEFFFB40, 0xFF00FB40, 0xFF01FB40, 0xFF02FB40, 0xFF03FB40, 0xFF04FB40, 0xFF05FB40, 0xFF06FB40, 0xFF07FB40, 0xFF08FB40, 0xFF09FB40, 0xFF0AFB40, 0xFF0BFB40, 0xFF0CFB40, 0xFF0DFB40, 0xFF0EFB40, 0xFF0FFB40, 0xFF10FB40, 0xFF11FB40, 0xFF12FB40, 0xFF13FB40, 0xFF14FB40, 0xFF15FB40, 0xFF16FB40, 0xFF17FB40, 0xFF18FB40, 0xFF19FB40, 0xFF1AFB40, 0xFF1BFB40, 0xFF1CFB40, 0xFF1DFB40, 0xFF1EFB40, 0xFF1FFB40, 0xFF20FB40, 0xFF21FB40, 0xFF22FB40, 0xFF23FB40, 0xFF24FB40, 0xFF25FB40, 0xFF26FB40, 0xFF27FB40, 0xFF28FB40, 0xFF29FB40, 0xFF2AFB40, 0xFF2BFB40, 0xFF2CFB40, 0xFF2DFB40, 0xFF2EFB40, 0xFF2FFB40, 0xFF30FB40, 0xFF31FB40, 0xFF32FB40, 0xFF33FB40, 0xFF34FB40, 0xFF35FB40, 0xFF36FB40, 0xFF37FB40, 0xFF38FB40, 0xFF39FB40, 0xFF3AFB40, 0xFF3BFB40, 0xFF3CFB40, 0xFF3DFB40, 0xFF3EFB40, 0xFF3FFB40, /* 7E96 */
+ 0xFF40FB40, 0xFF41FB40, 0xFF42FB40, 0xFF43FB40, 0xFF44FB40, 0xFF45FB40, 0xFF46FB40, 0xFF47FB40, 0xFF48FB40, 0xFF49FB40, 0xFF4AFB40, 0xFF4BFB40, 0xFF4CFB40, 0xFF4DFB40, 0xFF4EFB40, 0xFF4FFB40, 0xFF50FB40, 0xFF51FB40, 0xFF52FB40, 0xFF53FB40, 0xFF54FB40, 0xFF55FB40, 0xFF56FB40, 0xFF57FB40, 0xFF58FB40, 0xFF59FB40, 0xFF5AFB40, 0xFF5BFB40, 0xFF5CFB40, 0xFF5DFB40, 0xFF5EFB40, 0xFF5FFB40, 0xFF60FB40, 0xFF61FB40, 0xFF62FB40, 0xFF63FB40, 0xFF64FB40, 0xFF65FB40, 0xFF66FB40, 0xFF67FB40, 0xFF68FB40, 0xFF69FB40, 0xFF6AFB40, 0xFF6BFB40, 0xFF6CFB40, 0xFF6DFB40, 0xFF6EFB40, 0xFF6FFB40, 0xFF70FB40, 0xFF71FB40, 0xFF72FB40, 0xFF73FB40, 0xFF74FB40, 0xFF75FB40, 0xFF76FB40, 0xFF77FB40, 0xFF78FB40, 0xFF79FB40, 0xFF7AFB40, 0xFF7BFB40, 0xFF7CFB40, 0xFF7DFB40, 0xFF7EFB40, 0xFF7FFB40, 0xFF80FB40, 0xFF81FB40, 0xFF82FB40, 0xFF83FB40, 0xFF84FB40, 0xFF85FB40, 0xFF86FB40, 0xFF87FB40, 0xFF88FB40, 0xFF89FB40, 0xFF8AFB40, 0xFF8BFB40, 0xFF8CFB40, 0xFF8DFB40, 0xFF8EFB40, 0xFF8FFB40, 0xFF90FB40, 0xFF91FB40, 0xFF92FB40, 0xFF93FB40, 0xFF94FB40, 0xFF95FB40, 0xFF96FB40, 0xFF97FB40, 0xFF98FB40, 0xFF99FB40, 0xFF9AFB40, 0xFF9BFB40, 0xFF9CFB40, 0xFF9DFB40, 0xFF9EFB40, 0xFF9FFB40, 0xFFA0FB40, 0xFFA1FB40, 0xFFA2FB40, 0xFFA3FB40, 0xFFA4FB40, 0xFFA5FB40, 0xFFA6FB40, 0xFFA7FB40, 0xFFA8FB40, 0xFFA9FB40, 0xFFAAFB40, 0xFFABFB40, 0xFFACFB40, 0xFFADFB40, 0xFFAEFB40, 0xFFAFFB40, 0xFFB0FB40, 0xFFB1FB40, 0xFFB2FB40, 0xFFB3FB40, 0xFFB4FB40, 0xFFB5FB40, 0xFFB6FB40, 0xFFB7FB40, 0xFFB8FB40, 0xFFB9FB40, 0xFFBAFB40, 0xFFBBFB40, 0xFFBCFB40, 0xFFBDFB40, 0xFFBEFB40, 0xFFBFFB40, 0xFFC0FB40, 0xFFC1FB40, 0xFFC2FB40, 0xFFC3FB40, 0xFFC4FB40, 0xFFC5FB40, 0xFFC6FB40, 0xFFC7FB40, 0xFFC8FB40, 0xFFC9FB40, 0xFFCAFB40, 0xFFCBFB40, 0xFFCCFB40, 0xFFCDFB40, 0xFFCEFB40, 0xFFCFFB40, 0xFFD0FB40, 0xFFD1FB40, 0xFFD2FB40, 0xFFD3FB40, 0xFFD4FB40, 0xFFD5FB40, 0xFFD6FB40, 0xFFD7FB40, 0xFFD8FB40, 0xFFD9FB40, 0xFFDAFB40, 0xFFDBFB40, 0xFFDCFB40, 0xFFDDFB40, 0xFFDEFB40, 0xFFDFFB40, 0xFFE0FB40, 0xFFE1FB40, 0xFFE2FB40, 0xFFE3FB40, 0xFFE4FB40, 0xFFE5FB40, 0xFFE6FB40, 0xFFE7FB40, 0xFFE8FB40, 0xFFE9FB40, /* 7F40 */
+ 0xFFEAFB40, 0xFFEBFB40, 0xFFECFB40, 0xFFEDFB40, 0xFFEEFB40, 0xFFEFFB40, 0xFFF0FB40, 0xFFF1FB40, 0xFFF2FB40, 0xFFF3FB40, 0xFFF4FB40, 0xFFF5FB40, 0xFFF6FB40, 0xFFF7FB40, 0xFFF8FB40, 0xFFF9FB40, 0xFFFAFB40, 0xFFFBFB40, 0xFFFCFB40, 0xFFFDFB40, 0xFFFEFB40, 0xFFFFFB40, 0x8000FB41, 0x8001FB41, 0x8002FB41, 0x8003FB41, 0x8004FB41, 0x8005FB41, 0x8006FB41, 0x8007FB41, 0x8008FB41, 0x8009FB41, 0x800AFB41, 0x800BFB41, 0x800CFB41, 0x800DFB41, 0x800EFB41, 0x800FFB41, 0x8010FB41, 0x8011FB41, 0x8012FB41, 0x8013FB41, 0x8014FB41, 0x8015FB41, 0x8016FB41, 0x8017FB41, 0x8018FB41, 0x8019FB41, 0x801AFB41, 0x801BFB41, 0x801CFB41, 0x801DFB41, 0x801EFB41, 0x801FFB41, 0x8020FB41, 0x8021FB41, 0x8022FB41, 0x8023FB41, 0x8024FB41, 0x8025FB41, 0x8026FB41, 0x8027FB41, 0x8028FB41, 0x8029FB41, 0x802AFB41, 0x802BFB41, 0x802CFB41, 0x802DFB41, 0x802EFB41, 0x802FFB41, 0x8030FB41, 0x8031FB41, 0x8032FB41, 0x8033FB41, 0x8034FB41, 0x8035FB41, 0x8036FB41, 0x8037FB41, 0x8038FB41, 0x8039FB41, 0x803AFB41, 0x803BFB41, 0x803CFB41, 0x803DFB41, 0x803EFB41, 0x803FFB41, 0x8040FB41, 0x8041FB41, 0x8042FB41, 0x8043FB41, 0x8044FB41, 0x8045FB41, 0x8046FB41, 0x8047FB41, 0x8048FB41, 0x8049FB41, 0x804AFB41, 0x804BFB41, 0x804CFB41, 0x804DFB41, 0x804EFB41, 0x804FFB41, 0x8050FB41, 0x8051FB41, 0x8052FB41, 0x8053FB41, 0x8054FB41, 0x8055FB41, 0x8056FB41, 0x8057FB41, 0x8058FB41, 0x8059FB41, 0x805AFB41, 0x805BFB41, 0x805CFB41, 0x805DFB41, 0x805EFB41, 0x805FFB41, 0x8060FB41, 0x8061FB41, 0x8062FB41, 0x8063FB41, 0x8064FB41, 0x8065FB41, 0x8066FB41, 0x8067FB41, 0x8068FB41, 0x8069FB41, 0x806AFB41, 0x806BFB41, 0x806CFB41, 0x806DFB41, 0x806EFB41, 0x806FFB41, 0x8070FB41, 0x8071FB41, 0x8072FB41, 0x8073FB41, 0x8074FB41, 0x8075FB41, 0x8076FB41, 0x8077FB41, 0x8078FB41, 0x8079FB41, 0x807AFB41, 0x807BFB41, 0x807CFB41, 0x807DFB41, 0x807EFB41, 0x807FFB41, 0x8080FB41, 0x8081FB41, 0x8082FB41, 0x8083FB41, 0x8084FB41, 0x8085FB41, 0x8086FB41, 0x8087FB41, 0x8088FB41, 0x8089FB41, 0x808AFB41, 0x808BFB41, 0x808CFB41, 0x808DFB41, 0x808EFB41, 0x808FFB41, 0x8090FB41, 0x8091FB41, 0x8092FB41, 0x8093FB41, /* 7FEA */
+ 0x8094FB41, 0x8095FB41, 0x8096FB41, 0x8097FB41, 0x8098FB41, 0x8099FB41, 0x809AFB41, 0x809BFB41, 0x809CFB41, 0x809DFB41, 0x809EFB41, 0x809FFB41, 0x80A0FB41, 0x80A1FB41, 0x80A2FB41, 0x80A3FB41, 0x80A4FB41, 0x80A5FB41, 0x80A6FB41, 0x80A7FB41, 0x80A8FB41, 0x80A9FB41, 0x80AAFB41, 0x80ABFB41, 0x80ACFB41, 0x80ADFB41, 0x80AEFB41, 0x80AFFB41, 0x80B0FB41, 0x80B1FB41, 0x80B2FB41, 0x80B3FB41, 0x80B4FB41, 0x80B5FB41, 0x80B6FB41, 0x80B7FB41, 0x80B8FB41, 0x80B9FB41, 0x80BAFB41, 0x80BBFB41, 0x80BCFB41, 0x80BDFB41, 0x80BEFB41, 0x80BFFB41, 0x80C0FB41, 0x80C1FB41, 0x80C2FB41, 0x80C3FB41, 0x80C4FB41, 0x80C5FB41, 0x80C6FB41, 0x80C7FB41, 0x80C8FB41, 0x80C9FB41, 0x80CAFB41, 0x80CBFB41, 0x80CCFB41, 0x80CDFB41, 0x80CEFB41, 0x80CFFB41, 0x80D0FB41, 0x80D1FB41, 0x80D2FB41, 0x80D3FB41, 0x80D4FB41, 0x80D5FB41, 0x80D6FB41, 0x80D7FB41, 0x80D8FB41, 0x80D9FB41, 0x80DAFB41, 0x80DBFB41, 0x80DCFB41, 0x80DDFB41, 0x80DEFB41, 0x80DFFB41, 0x80E0FB41, 0x80E1FB41, 0x80E2FB41, 0x80E3FB41, 0x80E4FB41, 0x80E5FB41, 0x80E6FB41, 0x80E7FB41, 0x80E8FB41, 0x80E9FB41, 0x80EAFB41, 0x80EBFB41, 0x80ECFB41, 0x80EDFB41, 0x80EEFB41, 0x80EFFB41, 0x80F0FB41, 0x80F1FB41, 0x80F2FB41, 0x80F3FB41, 0x80F4FB41, 0x80F5FB41, 0x80F6FB41, 0x80F7FB41, 0x80F8FB41, 0x80F9FB41, 0x80FAFB41, 0x80FBFB41, 0x80FCFB41, 0x80FDFB41, 0x80FEFB41, 0x80FFFB41, 0x8100FB41, 0x8101FB41, 0x8102FB41, 0x8103FB41, 0x8104FB41, 0x8105FB41, 0x8106FB41, 0x8107FB41, 0x8108FB41, 0x8109FB41, 0x810AFB41, 0x810BFB41, 0x810CFB41, 0x810DFB41, 0x810EFB41, 0x810FFB41, 0x8110FB41, 0x8111FB41, 0x8112FB41, 0x8113FB41, 0x8114FB41, 0x8115FB41, 0x8116FB41, 0x8117FB41, 0x8118FB41, 0x8119FB41, 0x811AFB41, 0x811BFB41, 0x811CFB41, 0x811DFB41, 0x811EFB41, 0x811FFB41, 0x8120FB41, 0x8121FB41, 0x8122FB41, 0x8123FB41, 0x8124FB41, 0x8125FB41, 0x8126FB41, 0x8127FB41, 0x8128FB41, 0x8129FB41, 0x812AFB41, 0x812BFB41, 0x812CFB41, 0x812DFB41, 0x812EFB41, 0x812FFB41, 0x8130FB41, 0x8131FB41, 0x8132FB41, 0x8133FB41, 0x8134FB41, 0x8135FB41, 0x8136FB41, 0x8137FB41, 0x8138FB41, 0x8139FB41, 0x813AFB41, 0x813BFB41, 0x813CFB41, 0x813DFB41, /* 8094 */
+ 0x813EFB41, 0x813FFB41, 0x8140FB41, 0x8141FB41, 0x8142FB41, 0x8143FB41, 0x8144FB41, 0x8145FB41, 0x8146FB41, 0x8147FB41, 0x8148FB41, 0x8149FB41, 0x814AFB41, 0x814BFB41, 0x814CFB41, 0x814DFB41, 0x814EFB41, 0x814FFB41, 0x8150FB41, 0x8151FB41, 0x8152FB41, 0x8153FB41, 0x8154FB41, 0x8155FB41, 0x8156FB41, 0x8157FB41, 0x8158FB41, 0x8159FB41, 0x815AFB41, 0x815BFB41, 0x815CFB41, 0x815DFB41, 0x815EFB41, 0x815FFB41, 0x8160FB41, 0x8161FB41, 0x8162FB41, 0x8163FB41, 0x8164FB41, 0x8165FB41, 0x8166FB41, 0x8167FB41, 0x8168FB41, 0x8169FB41, 0x816AFB41, 0x816BFB41, 0x816CFB41, 0x816DFB41, 0x816EFB41, 0x816FFB41, 0x8170FB41, 0x8171FB41, 0x8172FB41, 0x8173FB41, 0x8174FB41, 0x8175FB41, 0x8176FB41, 0x8177FB41, 0x8178FB41, 0x8179FB41, 0x817AFB41, 0x817BFB41, 0x817CFB41, 0x817DFB41, 0x817EFB41, 0x817FFB41, 0x8180FB41, 0x8181FB41, 0x8182FB41, 0x8183FB41, 0x8184FB41, 0x8185FB41, 0x8186FB41, 0x8187FB41, 0x8188FB41, 0x8189FB41, 0x818AFB41, 0x818BFB41, 0x818CFB41, 0x818DFB41, 0x818EFB41, 0x818FFB41, 0x8190FB41, 0x8191FB41, 0x8192FB41, 0x8193FB41, 0x8194FB41, 0x8195FB41, 0x8196FB41, 0x8197FB41, 0x8198FB41, 0x8199FB41, 0x819AFB41, 0x819BFB41, 0x819CFB41, 0x819DFB41, 0x819EFB41, 0x819FFB41, 0x81A0FB41, 0x81A1FB41, 0x81A2FB41, 0x81A3FB41, 0x81A4FB41, 0x81A5FB41, 0x81A6FB41, 0x81A7FB41, 0x81A8FB41, 0x81A9FB41, 0x81AAFB41, 0x81ABFB41, 0x81ACFB41, 0x81ADFB41, 0x81AEFB41, 0x81AFFB41, 0x81B0FB41, 0x81B1FB41, 0x81B2FB41, 0x81B3FB41, 0x81B4FB41, 0x81B5FB41, 0x81B6FB41, 0x81B7FB41, 0x81B8FB41, 0x81B9FB41, 0x81BAFB41, 0x81BBFB41, 0x81BCFB41, 0x81BDFB41, 0x81BEFB41, 0x81BFFB41, 0x81C0FB41, 0x81C1FB41, 0x81C2FB41, 0x81C3FB41, 0x81C4FB41, 0x81C5FB41, 0x81C6FB41, 0x81C7FB41, 0x81C8FB41, 0x81C9FB41, 0x81CAFB41, 0x81CBFB41, 0x81CCFB41, 0x81CDFB41, 0x81CEFB41, 0x81CFFB41, 0x81D0FB41, 0x81D1FB41, 0x81D2FB41, 0x81D3FB41, 0x81D4FB41, 0x81D5FB41, 0x81D6FB41, 0x81D7FB41, 0x81D8FB41, 0x81D9FB41, 0x81DAFB41, 0x81DBFB41, 0x81DCFB41, 0x81DDFB41, 0x81DEFB41, 0x81DFFB41, 0x81E0FB41, 0x81E1FB41, 0x81E2FB41, 0x81E3FB41, 0x81E4FB41, 0x81E5FB41, 0x81E6FB41, 0x81E7FB41, /* 813E */
+ 0x81E8FB41, 0x81E9FB41, 0x81EAFB41, 0x81EBFB41, 0x81ECFB41, 0x81EDFB41, 0x81EEFB41, 0x81EFFB41, 0x81F0FB41, 0x81F1FB41, 0x81F2FB41, 0x81F3FB41, 0x81F4FB41, 0x81F5FB41, 0x81F6FB41, 0x81F7FB41, 0x81F8FB41, 0x81F9FB41, 0x81FAFB41, 0x81FBFB41, 0x81FCFB41, 0x81FDFB41, 0x81FEFB41, 0x81FFFB41, 0x8200FB41, 0x8201FB41, 0x8202FB41, 0x8203FB41, 0x8204FB41, 0x8205FB41, 0x8206FB41, 0x8207FB41, 0x8208FB41, 0x8209FB41, 0x820AFB41, 0x820BFB41, 0x820CFB41, 0x820DFB41, 0x820EFB41, 0x820FFB41, 0x8210FB41, 0x8211FB41, 0x8212FB41, 0x8213FB41, 0x8214FB41, 0x8215FB41, 0x8216FB41, 0x8217FB41, 0x8218FB41, 0x8219FB41, 0x821AFB41, 0x821BFB41, 0x821CFB41, 0x821DFB41, 0x821EFB41, 0x821FFB41, 0x8220FB41, 0x8221FB41, 0x8222FB41, 0x8223FB41, 0x8224FB41, 0x8225FB41, 0x8226FB41, 0x8227FB41, 0x8228FB41, 0x8229FB41, 0x822AFB41, 0x822BFB41, 0x822CFB41, 0x822DFB41, 0x822EFB41, 0x822FFB41, 0x8230FB41, 0x8231FB41, 0x8232FB41, 0x8233FB41, 0x8234FB41, 0x8235FB41, 0x8236FB41, 0x8237FB41, 0x8238FB41, 0x8239FB41, 0x823AFB41, 0x823BFB41, 0x823CFB41, 0x823DFB41, 0x823EFB41, 0x823FFB41, 0x8240FB41, 0x8241FB41, 0x8242FB41, 0x8243FB41, 0x8244FB41, 0x8245FB41, 0x8246FB41, 0x8247FB41, 0x8248FB41, 0x8249FB41, 0x824AFB41, 0x824BFB41, 0x824CFB41, 0x824DFB41, 0x824EFB41, 0x824FFB41, 0x8250FB41, 0x8251FB41, 0x8252FB41, 0x8253FB41, 0x8254FB41, 0x8255FB41, 0x8256FB41, 0x8257FB41, 0x8258FB41, 0x8259FB41, 0x825AFB41, 0x825BFB41, 0x825CFB41, 0x825DFB41, 0x825EFB41, 0x825FFB41, 0x8260FB41, 0x8261FB41, 0x8262FB41, 0x8263FB41, 0x8264FB41, 0x8265FB41, 0x8266FB41, 0x8267FB41, 0x8268FB41, 0x8269FB41, 0x826AFB41, 0x826BFB41, 0x826CFB41, 0x826DFB41, 0x826EFB41, 0x826FFB41, 0x8270FB41, 0x8271FB41, 0x8272FB41, 0x8273FB41, 0x8274FB41, 0x8275FB41, 0x8276FB41, 0x8277FB41, 0x8278FB41, 0x8279FB41, 0x827AFB41, 0x827BFB41, 0x827CFB41, 0x827DFB41, 0x827EFB41, 0x827FFB41, 0x8280FB41, 0x8281FB41, 0x8282FB41, 0x8283FB41, 0x8284FB41, 0x8285FB41, 0x8286FB41, 0x8287FB41, 0x8288FB41, 0x8289FB41, 0x828AFB41, 0x828BFB41, 0x828CFB41, 0x828DFB41, 0x828EFB41, 0x828FFB41, 0x8290FB41, 0x8291FB41, /* 81E8 */
+ 0x8292FB41, 0x8293FB41, 0x8294FB41, 0x8295FB41, 0x8296FB41, 0x8297FB41, 0x8298FB41, 0x8299FB41, 0x829AFB41, 0x829BFB41, 0x829CFB41, 0x829DFB41, 0x829EFB41, 0x829FFB41, 0x82A0FB41, 0x82A1FB41, 0x82A2FB41, 0x82A3FB41, 0x82A4FB41, 0x82A5FB41, 0x82A6FB41, 0x82A7FB41, 0x82A8FB41, 0x82A9FB41, 0x82AAFB41, 0x82ABFB41, 0x82ACFB41, 0x82ADFB41, 0x82AEFB41, 0x82AFFB41, 0x82B0FB41, 0x82B1FB41, 0x82B2FB41, 0x82B3FB41, 0x82B4FB41, 0x82B5FB41, 0x82B6FB41, 0x82B7FB41, 0x82B8FB41, 0x82B9FB41, 0x82BAFB41, 0x82BBFB41, 0x82BCFB41, 0x82BDFB41, 0x82BEFB41, 0x82BFFB41, 0x82C0FB41, 0x82C1FB41, 0x82C2FB41, 0x82C3FB41, 0x82C4FB41, 0x82C5FB41, 0x82C6FB41, 0x82C7FB41, 0x82C8FB41, 0x82C9FB41, 0x82CAFB41, 0x82CBFB41, 0x82CCFB41, 0x82CDFB41, 0x82CEFB41, 0x82CFFB41, 0x82D0FB41, 0x82D1FB41, 0x82D2FB41, 0x82D3FB41, 0x82D4FB41, 0x82D5FB41, 0x82D6FB41, 0x82D7FB41, 0x82D8FB41, 0x82D9FB41, 0x82DAFB41, 0x82DBFB41, 0x82DCFB41, 0x82DDFB41, 0x82DEFB41, 0x82DFFB41, 0x82E0FB41, 0x82E1FB41, 0x82E2FB41, 0x82E3FB41, 0x82E4FB41, 0x82E5FB41, 0x82E6FB41, 0x82E7FB41, 0x82E8FB41, 0x82E9FB41, 0x82EAFB41, 0x82EBFB41, 0x82ECFB41, 0x82EDFB41, 0x82EEFB41, 0x82EFFB41, 0x82F0FB41, 0x82F1FB41, 0x82F2FB41, 0x82F3FB41, 0x82F4FB41, 0x82F5FB41, 0x82F6FB41, 0x82F7FB41, 0x82F8FB41, 0x82F9FB41, 0x82FAFB41, 0x82FBFB41, 0x82FCFB41, 0x82FDFB41, 0x82FEFB41, 0x82FFFB41, 0x8300FB41, 0x8301FB41, 0x8302FB41, 0x8303FB41, 0x8304FB41, 0x8305FB41, 0x8306FB41, 0x8307FB41, 0x8308FB41, 0x8309FB41, 0x830AFB41, 0x830BFB41, 0x830CFB41, 0x830DFB41, 0x830EFB41, 0x830FFB41, 0x8310FB41, 0x8311FB41, 0x8312FB41, 0x8313FB41, 0x8314FB41, 0x8315FB41, 0x8316FB41, 0x8317FB41, 0x8318FB41, 0x8319FB41, 0x831AFB41, 0x831BFB41, 0x831CFB41, 0x831DFB41, 0x831EFB41, 0x831FFB41, 0x8320FB41, 0x8321FB41, 0x8322FB41, 0x8323FB41, 0x8324FB41, 0x8325FB41, 0x8326FB41, 0x8327FB41, 0x8328FB41, 0x8329FB41, 0x832AFB41, 0x832BFB41, 0x832CFB41, 0x832DFB41, 0x832EFB41, 0x832FFB41, 0x8330FB41, 0x8331FB41, 0x8332FB41, 0x8333FB41, 0x8334FB41, 0x8335FB41, 0x8336FB41, 0x8337FB41, 0x8338FB41, 0x8339FB41, 0x833AFB41, 0x833BFB41, /* 8292 */
+ 0x833CFB41, 0x833DFB41, 0x833EFB41, 0x833FFB41, 0x8340FB41, 0x8341FB41, 0x8342FB41, 0x8343FB41, 0x8344FB41, 0x8345FB41, 0x8346FB41, 0x8347FB41, 0x8348FB41, 0x8349FB41, 0x834AFB41, 0x834BFB41, 0x834CFB41, 0x834DFB41, 0x834EFB41, 0x834FFB41, 0x8350FB41, 0x8351FB41, 0x8352FB41, 0x8353FB41, 0x8354FB41, 0x8355FB41, 0x8356FB41, 0x8357FB41, 0x8358FB41, 0x8359FB41, 0x835AFB41, 0x835BFB41, 0x835CFB41, 0x835DFB41, 0x835EFB41, 0x835FFB41, 0x8360FB41, 0x8361FB41, 0x8362FB41, 0x8363FB41, 0x8364FB41, 0x8365FB41, 0x8366FB41, 0x8367FB41, 0x8368FB41, 0x8369FB41, 0x836AFB41, 0x836BFB41, 0x836CFB41, 0x836DFB41, 0x836EFB41, 0x836FFB41, 0x8370FB41, 0x8371FB41, 0x8372FB41, 0x8373FB41, 0x8374FB41, 0x8375FB41, 0x8376FB41, 0x8377FB41, 0x8378FB41, 0x8379FB41, 0x837AFB41, 0x837BFB41, 0x837CFB41, 0x837DFB41, 0x837EFB41, 0x837FFB41, 0x8380FB41, 0x8381FB41, 0x8382FB41, 0x8383FB41, 0x8384FB41, 0x8385FB41, 0x8386FB41, 0x8387FB41, 0x8388FB41, 0x8389FB41, 0x838AFB41, 0x838BFB41, 0x838CFB41, 0x838DFB41, 0x838EFB41, 0x838FFB41, 0x8390FB41, 0x8391FB41, 0x8392FB41, 0x8393FB41, 0x8394FB41, 0x8395FB41, 0x8396FB41, 0x8397FB41, 0x8398FB41, 0x8399FB41, 0x839AFB41, 0x839BFB41, 0x839CFB41, 0x839DFB41, 0x839EFB41, 0x839FFB41, 0x83A0FB41, 0x83A1FB41, 0x83A2FB41, 0x83A3FB41, 0x83A4FB41, 0x83A5FB41, 0x83A6FB41, 0x83A7FB41, 0x83A8FB41, 0x83A9FB41, 0x83AAFB41, 0x83ABFB41, 0x83ACFB41, 0x83ADFB41, 0x83AEFB41, 0x83AFFB41, 0x83B0FB41, 0x83B1FB41, 0x83B2FB41, 0x83B3FB41, 0x83B4FB41, 0x83B5FB41, 0x83B6FB41, 0x83B7FB41, 0x83B8FB41, 0x83B9FB41, 0x83BAFB41, 0x83BBFB41, 0x83BCFB41, 0x83BDFB41, 0x83BEFB41, 0x83BFFB41, 0x83C0FB41, 0x83C1FB41, 0x83C2FB41, 0x83C3FB41, 0x83C4FB41, 0x83C5FB41, 0x83C6FB41, 0x83C7FB41, 0x83C8FB41, 0x83C9FB41, 0x83CAFB41, 0x83CBFB41, 0x83CCFB41, 0x83CDFB41, 0x83CEFB41, 0x83CFFB41, 0x83D0FB41, 0x83D1FB41, 0x83D2FB41, 0x83D3FB41, 0x83D4FB41, 0x83D5FB41, 0x83D6FB41, 0x83D7FB41, 0x83D8FB41, 0x83D9FB41, 0x83DAFB41, 0x83DBFB41, 0x83DCFB41, 0x83DDFB41, 0x83DEFB41, 0x83DFFB41, 0x83E0FB41, 0x83E1FB41, 0x83E2FB41, 0x83E3FB41, 0x83E4FB41, 0x83E5FB41, /* 833C */
+ 0x83E6FB41, 0x83E7FB41, 0x83E8FB41, 0x83E9FB41, 0x83EAFB41, 0x83EBFB41, 0x83ECFB41, 0x83EDFB41, 0x83EEFB41, 0x83EFFB41, 0x83F0FB41, 0x83F1FB41, 0x83F2FB41, 0x83F3FB41, 0x83F4FB41, 0x83F5FB41, 0x83F6FB41, 0x83F7FB41, 0x83F8FB41, 0x83F9FB41, 0x83FAFB41, 0x83FBFB41, 0x83FCFB41, 0x83FDFB41, 0x83FEFB41, 0x83FFFB41, 0x8400FB41, 0x8401FB41, 0x8402FB41, 0x8403FB41, 0x8404FB41, 0x8405FB41, 0x8406FB41, 0x8407FB41, 0x8408FB41, 0x8409FB41, 0x840AFB41, 0x840BFB41, 0x840CFB41, 0x840DFB41, 0x840EFB41, 0x840FFB41, 0x8410FB41, 0x8411FB41, 0x8412FB41, 0x8413FB41, 0x8414FB41, 0x8415FB41, 0x8416FB41, 0x8417FB41, 0x8418FB41, 0x8419FB41, 0x841AFB41, 0x841BFB41, 0x841CFB41, 0x841DFB41, 0x841EFB41, 0x841FFB41, 0x8420FB41, 0x8421FB41, 0x8422FB41, 0x8423FB41, 0x8424FB41, 0x8425FB41, 0x8426FB41, 0x8427FB41, 0x8428FB41, 0x8429FB41, 0x842AFB41, 0x842BFB41, 0x842CFB41, 0x842DFB41, 0x842EFB41, 0x842FFB41, 0x8430FB41, 0x8431FB41, 0x8432FB41, 0x8433FB41, 0x8434FB41, 0x8435FB41, 0x8436FB41, 0x8437FB41, 0x8438FB41, 0x8439FB41, 0x843AFB41, 0x843BFB41, 0x843CFB41, 0x843DFB41, 0x843EFB41, 0x843FFB41, 0x8440FB41, 0x8441FB41, 0x8442FB41, 0x8443FB41, 0x8444FB41, 0x8445FB41, 0x8446FB41, 0x8447FB41, 0x8448FB41, 0x8449FB41, 0x844AFB41, 0x844BFB41, 0x844CFB41, 0x844DFB41, 0x844EFB41, 0x844FFB41, 0x8450FB41, 0x8451FB41, 0x8452FB41, 0x8453FB41, 0x8454FB41, 0x8455FB41, 0x8456FB41, 0x8457FB41, 0x8458FB41, 0x8459FB41, 0x845AFB41, 0x845BFB41, 0x845CFB41, 0x845DFB41, 0x845EFB41, 0x845FFB41, 0x8460FB41, 0x8461FB41, 0x8462FB41, 0x8463FB41, 0x8464FB41, 0x8465FB41, 0x8466FB41, 0x8467FB41, 0x8468FB41, 0x8469FB41, 0x846AFB41, 0x846BFB41, 0x846CFB41, 0x846DFB41, 0x846EFB41, 0x846FFB41, 0x8470FB41, 0x8471FB41, 0x8472FB41, 0x8473FB41, 0x8474FB41, 0x8475FB41, 0x8476FB41, 0x8477FB41, 0x8478FB41, 0x8479FB41, 0x847AFB41, 0x847BFB41, 0x847CFB41, 0x847DFB41, 0x847EFB41, 0x847FFB41, 0x8480FB41, 0x8481FB41, 0x8482FB41, 0x8483FB41, 0x8484FB41, 0x8485FB41, 0x8486FB41, 0x8487FB41, 0x8488FB41, 0x8489FB41, 0x848AFB41, 0x848BFB41, 0x848CFB41, 0x848DFB41, 0x848EFB41, 0x848FFB41, /* 83E6 */
+ 0x8490FB41, 0x8491FB41, 0x8492FB41, 0x8493FB41, 0x8494FB41, 0x8495FB41, 0x8496FB41, 0x8497FB41, 0x8498FB41, 0x8499FB41, 0x849AFB41, 0x849BFB41, 0x849CFB41, 0x849DFB41, 0x849EFB41, 0x849FFB41, 0x84A0FB41, 0x84A1FB41, 0x84A2FB41, 0x84A3FB41, 0x84A4FB41, 0x84A5FB41, 0x84A6FB41, 0x84A7FB41, 0x84A8FB41, 0x84A9FB41, 0x84AAFB41, 0x84ABFB41, 0x84ACFB41, 0x84ADFB41, 0x84AEFB41, 0x84AFFB41, 0x84B0FB41, 0x84B1FB41, 0x84B2FB41, 0x84B3FB41, 0x84B4FB41, 0x84B5FB41, 0x84B6FB41, 0x84B7FB41, 0x84B8FB41, 0x84B9FB41, 0x84BAFB41, 0x84BBFB41, 0x84BCFB41, 0x84BDFB41, 0x84BEFB41, 0x84BFFB41, 0x84C0FB41, 0x84C1FB41, 0x84C2FB41, 0x84C3FB41, 0x84C4FB41, 0x84C5FB41, 0x84C6FB41, 0x84C7FB41, 0x84C8FB41, 0x84C9FB41, 0x84CAFB41, 0x84CBFB41, 0x84CCFB41, 0x84CDFB41, 0x84CEFB41, 0x84CFFB41, 0x84D0FB41, 0x84D1FB41, 0x84D2FB41, 0x84D3FB41, 0x84D4FB41, 0x84D5FB41, 0x84D6FB41, 0x84D7FB41, 0x84D8FB41, 0x84D9FB41, 0x84DAFB41, 0x84DBFB41, 0x84DCFB41, 0x84DDFB41, 0x84DEFB41, 0x84DFFB41, 0x84E0FB41, 0x84E1FB41, 0x84E2FB41, 0x84E3FB41, 0x84E4FB41, 0x84E5FB41, 0x84E6FB41, 0x84E7FB41, 0x84E8FB41, 0x84E9FB41, 0x84EAFB41, 0x84EBFB41, 0x84ECFB41, 0x84EDFB41, 0x84EEFB41, 0x84EFFB41, 0x84F0FB41, 0x84F1FB41, 0x84F2FB41, 0x84F3FB41, 0x84F4FB41, 0x84F5FB41, 0x84F6FB41, 0x84F7FB41, 0x84F8FB41, 0x84F9FB41, 0x84FAFB41, 0x84FBFB41, 0x84FCFB41, 0x84FDFB41, 0x84FEFB41, 0x84FFFB41, 0x8500FB41, 0x8501FB41, 0x8502FB41, 0x8503FB41, 0x8504FB41, 0x8505FB41, 0x8506FB41, 0x8507FB41, 0x8508FB41, 0x8509FB41, 0x850AFB41, 0x850BFB41, 0x850CFB41, 0x850DFB41, 0x850EFB41, 0x850FFB41, 0x8510FB41, 0x8511FB41, 0x8512FB41, 0x8513FB41, 0x8514FB41, 0x8515FB41, 0x8516FB41, 0x8517FB41, 0x8518FB41, 0x8519FB41, 0x851AFB41, 0x851BFB41, 0x851CFB41, 0x851DFB41, 0x851EFB41, 0x851FFB41, 0x8520FB41, 0x8521FB41, 0x8522FB41, 0x8523FB41, 0x8524FB41, 0x8525FB41, 0x8526FB41, 0x8527FB41, 0x8528FB41, 0x8529FB41, 0x852AFB41, 0x852BFB41, 0x852CFB41, 0x852DFB41, 0x852EFB41, 0x852FFB41, 0x8530FB41, 0x8531FB41, 0x8532FB41, 0x8533FB41, 0x8534FB41, 0x8535FB41, 0x8536FB41, 0x8537FB41, 0x8538FB41, 0x8539FB41, /* 8490 */
+ 0x853AFB41, 0x853BFB41, 0x853CFB41, 0x853DFB41, 0x853EFB41, 0x853FFB41, 0x8540FB41, 0x8541FB41, 0x8542FB41, 0x8543FB41, 0x8544FB41, 0x8545FB41, 0x8546FB41, 0x8547FB41, 0x8548FB41, 0x8549FB41, 0x854AFB41, 0x854BFB41, 0x854CFB41, 0x854DFB41, 0x854EFB41, 0x854FFB41, 0x8550FB41, 0x8551FB41, 0x8552FB41, 0x8553FB41, 0x8554FB41, 0x8555FB41, 0x8556FB41, 0x8557FB41, 0x8558FB41, 0x8559FB41, 0x855AFB41, 0x855BFB41, 0x855CFB41, 0x855DFB41, 0x855EFB41, 0x855FFB41, 0x8560FB41, 0x8561FB41, 0x8562FB41, 0x8563FB41, 0x8564FB41, 0x8565FB41, 0x8566FB41, 0x8567FB41, 0x8568FB41, 0x8569FB41, 0x856AFB41, 0x856BFB41, 0x856CFB41, 0x856DFB41, 0x856EFB41, 0x856FFB41, 0x8570FB41, 0x8571FB41, 0x8572FB41, 0x8573FB41, 0x8574FB41, 0x8575FB41, 0x8576FB41, 0x8577FB41, 0x8578FB41, 0x8579FB41, 0x857AFB41, 0x857BFB41, 0x857CFB41, 0x857DFB41, 0x857EFB41, 0x857FFB41, 0x8580FB41, 0x8581FB41, 0x8582FB41, 0x8583FB41, 0x8584FB41, 0x8585FB41, 0x8586FB41, 0x8587FB41, 0x8588FB41, 0x8589FB41, 0x858AFB41, 0x858BFB41, 0x858CFB41, 0x858DFB41, 0x858EFB41, 0x858FFB41, 0x8590FB41, 0x8591FB41, 0x8592FB41, 0x8593FB41, 0x8594FB41, 0x8595FB41, 0x8596FB41, 0x8597FB41, 0x8598FB41, 0x8599FB41, 0x859AFB41, 0x859BFB41, 0x859CFB41, 0x859DFB41, 0x859EFB41, 0x859FFB41, 0x85A0FB41, 0x85A1FB41, 0x85A2FB41, 0x85A3FB41, 0x85A4FB41, 0x85A5FB41, 0x85A6FB41, 0x85A7FB41, 0x85A8FB41, 0x85A9FB41, 0x85AAFB41, 0x85ABFB41, 0x85ACFB41, 0x85ADFB41, 0x85AEFB41, 0x85AFFB41, 0x85B0FB41, 0x85B1FB41, 0x85B2FB41, 0x85B3FB41, 0x85B4FB41, 0x85B5FB41, 0x85B6FB41, 0x85B7FB41, 0x85B8FB41, 0x85B9FB41, 0x85BAFB41, 0x85BBFB41, 0x85BCFB41, 0x85BDFB41, 0x85BEFB41, 0x85BFFB41, 0x85C0FB41, 0x85C1FB41, 0x85C2FB41, 0x85C3FB41, 0x85C4FB41, 0x85C5FB41, 0x85C6FB41, 0x85C7FB41, 0x85C8FB41, 0x85C9FB41, 0x85CAFB41, 0x85CBFB41, 0x85CCFB41, 0x85CDFB41, 0x85CEFB41, 0x85CFFB41, 0x85D0FB41, 0x85D1FB41, 0x85D2FB41, 0x85D3FB41, 0x85D4FB41, 0x85D5FB41, 0x85D6FB41, 0x85D7FB41, 0x85D8FB41, 0x85D9FB41, 0x85DAFB41, 0x85DBFB41, 0x85DCFB41, 0x85DDFB41, 0x85DEFB41, 0x85DFFB41, 0x85E0FB41, 0x85E1FB41, 0x85E2FB41, 0x85E3FB41, /* 853A */
+ 0x85E4FB41, 0x85E5FB41, 0x85E6FB41, 0x85E7FB41, 0x85E8FB41, 0x85E9FB41, 0x85EAFB41, 0x85EBFB41, 0x85ECFB41, 0x85EDFB41, 0x85EEFB41, 0x85EFFB41, 0x85F0FB41, 0x85F1FB41, 0x85F2FB41, 0x85F3FB41, 0x85F4FB41, 0x85F5FB41, 0x85F6FB41, 0x85F7FB41, 0x85F8FB41, 0x85F9FB41, 0x85FAFB41, 0x85FBFB41, 0x85FCFB41, 0x85FDFB41, 0x85FEFB41, 0x85FFFB41, 0x8600FB41, 0x8601FB41, 0x8602FB41, 0x8603FB41, 0x8604FB41, 0x8605FB41, 0x8606FB41, 0x8607FB41, 0x8608FB41, 0x8609FB41, 0x860AFB41, 0x860BFB41, 0x860CFB41, 0x860DFB41, 0x860EFB41, 0x860FFB41, 0x8610FB41, 0x8611FB41, 0x8612FB41, 0x8613FB41, 0x8614FB41, 0x8615FB41, 0x8616FB41, 0x8617FB41, 0x8618FB41, 0x8619FB41, 0x861AFB41, 0x861BFB41, 0x861CFB41, 0x861DFB41, 0x861EFB41, 0x861FFB41, 0x8620FB41, 0x8621FB41, 0x8622FB41, 0x8623FB41, 0x8624FB41, 0x8625FB41, 0x8626FB41, 0x8627FB41, 0x8628FB41, 0x8629FB41, 0x862AFB41, 0x862BFB41, 0x862CFB41, 0x862DFB41, 0x862EFB41, 0x862FFB41, 0x8630FB41, 0x8631FB41, 0x8632FB41, 0x8633FB41, 0x8634FB41, 0x8635FB41, 0x8636FB41, 0x8637FB41, 0x8638FB41, 0x8639FB41, 0x863AFB41, 0x863BFB41, 0x863CFB41, 0x863DFB41, 0x863EFB41, 0x863FFB41, 0x8640FB41, 0x8641FB41, 0x8642FB41, 0x8643FB41, 0x8644FB41, 0x8645FB41, 0x8646FB41, 0x8647FB41, 0x8648FB41, 0x8649FB41, 0x864AFB41, 0x864BFB41, 0x864CFB41, 0x864DFB41, 0x864EFB41, 0x864FFB41, 0x8650FB41, 0x8651FB41, 0x8652FB41, 0x8653FB41, 0x8654FB41, 0x8655FB41, 0x8656FB41, 0x8657FB41, 0x8658FB41, 0x8659FB41, 0x865AFB41, 0x865BFB41, 0x865CFB41, 0x865DFB41, 0x865EFB41, 0x865FFB41, 0x8660FB41, 0x8661FB41, 0x8662FB41, 0x8663FB41, 0x8664FB41, 0x8665FB41, 0x8666FB41, 0x8667FB41, 0x8668FB41, 0x8669FB41, 0x866AFB41, 0x866BFB41, 0x866CFB41, 0x866DFB41, 0x866EFB41, 0x866FFB41, 0x8670FB41, 0x8671FB41, 0x8672FB41, 0x8673FB41, 0x8674FB41, 0x8675FB41, 0x8676FB41, 0x8677FB41, 0x8678FB41, 0x8679FB41, 0x867AFB41, 0x867BFB41, 0x867CFB41, 0x867DFB41, 0x867EFB41, 0x867FFB41, 0x8680FB41, 0x8681FB41, 0x8682FB41, 0x8683FB41, 0x8684FB41, 0x8685FB41, 0x8686FB41, 0x8687FB41, 0x8688FB41, 0x8689FB41, 0x868AFB41, 0x868BFB41, 0x868CFB41, 0x868DFB41, /* 85E4 */
+ 0x868EFB41, 0x868FFB41, 0x8690FB41, 0x8691FB41, 0x8692FB41, 0x8693FB41, 0x8694FB41, 0x8695FB41, 0x8696FB41, 0x8697FB41, 0x8698FB41, 0x8699FB41, 0x869AFB41, 0x869BFB41, 0x869CFB41, 0x869DFB41, 0x869EFB41, 0x869FFB41, 0x86A0FB41, 0x86A1FB41, 0x86A2FB41, 0x86A3FB41, 0x86A4FB41, 0x86A5FB41, 0x86A6FB41, 0x86A7FB41, 0x86A8FB41, 0x86A9FB41, 0x86AAFB41, 0x86ABFB41, 0x86ACFB41, 0x86ADFB41, 0x86AEFB41, 0x86AFFB41, 0x86B0FB41, 0x86B1FB41, 0x86B2FB41, 0x86B3FB41, 0x86B4FB41, 0x86B5FB41, 0x86B6FB41, 0x86B7FB41, 0x86B8FB41, 0x86B9FB41, 0x86BAFB41, 0x86BBFB41, 0x86BCFB41, 0x86BDFB41, 0x86BEFB41, 0x86BFFB41, 0x86C0FB41, 0x86C1FB41, 0x86C2FB41, 0x86C3FB41, 0x86C4FB41, 0x86C5FB41, 0x86C6FB41, 0x86C7FB41, 0x86C8FB41, 0x86C9FB41, 0x86CAFB41, 0x86CBFB41, 0x86CCFB41, 0x86CDFB41, 0x86CEFB41, 0x86CFFB41, 0x86D0FB41, 0x86D1FB41, 0x86D2FB41, 0x86D3FB41, 0x86D4FB41, 0x86D5FB41, 0x86D6FB41, 0x86D7FB41, 0x86D8FB41, 0x86D9FB41, 0x86DAFB41, 0x86DBFB41, 0x86DCFB41, 0x86DDFB41, 0x86DEFB41, 0x86DFFB41, 0x86E0FB41, 0x86E1FB41, 0x86E2FB41, 0x86E3FB41, 0x86E4FB41, 0x86E5FB41, 0x86E6FB41, 0x86E7FB41, 0x86E8FB41, 0x86E9FB41, 0x86EAFB41, 0x86EBFB41, 0x86ECFB41, 0x86EDFB41, 0x86EEFB41, 0x86EFFB41, 0x86F0FB41, 0x86F1FB41, 0x86F2FB41, 0x86F3FB41, 0x86F4FB41, 0x86F5FB41, 0x86F6FB41, 0x86F7FB41, 0x86F8FB41, 0x86F9FB41, 0x86FAFB41, 0x86FBFB41, 0x86FCFB41, 0x86FDFB41, 0x86FEFB41, 0x86FFFB41, 0x8700FB41, 0x8701FB41, 0x8702FB41, 0x8703FB41, 0x8704FB41, 0x8705FB41, 0x8706FB41, 0x8707FB41, 0x8708FB41, 0x8709FB41, 0x870AFB41, 0x870BFB41, 0x870CFB41, 0x870DFB41, 0x870EFB41, 0x870FFB41, 0x8710FB41, 0x8711FB41, 0x8712FB41, 0x8713FB41, 0x8714FB41, 0x8715FB41, 0x8716FB41, 0x8717FB41, 0x8718FB41, 0x8719FB41, 0x871AFB41, 0x871BFB41, 0x871CFB41, 0x871DFB41, 0x871EFB41, 0x871FFB41, 0x8720FB41, 0x8721FB41, 0x8722FB41, 0x8723FB41, 0x8724FB41, 0x8725FB41, 0x8726FB41, 0x8727FB41, 0x8728FB41, 0x8729FB41, 0x872AFB41, 0x872BFB41, 0x872CFB41, 0x872DFB41, 0x872EFB41, 0x872FFB41, 0x8730FB41, 0x8731FB41, 0x8732FB41, 0x8733FB41, 0x8734FB41, 0x8735FB41, 0x8736FB41, 0x8737FB41, /* 868E */
+ 0x8738FB41, 0x8739FB41, 0x873AFB41, 0x873BFB41, 0x873CFB41, 0x873DFB41, 0x873EFB41, 0x873FFB41, 0x8740FB41, 0x8741FB41, 0x8742FB41, 0x8743FB41, 0x8744FB41, 0x8745FB41, 0x8746FB41, 0x8747FB41, 0x8748FB41, 0x8749FB41, 0x874AFB41, 0x874BFB41, 0x874CFB41, 0x874DFB41, 0x874EFB41, 0x874FFB41, 0x8750FB41, 0x8751FB41, 0x8752FB41, 0x8753FB41, 0x8754FB41, 0x8755FB41, 0x8756FB41, 0x8757FB41, 0x8758FB41, 0x8759FB41, 0x875AFB41, 0x875BFB41, 0x875CFB41, 0x875DFB41, 0x875EFB41, 0x875FFB41, 0x8760FB41, 0x8761FB41, 0x8762FB41, 0x8763FB41, 0x8764FB41, 0x8765FB41, 0x8766FB41, 0x8767FB41, 0x8768FB41, 0x8769FB41, 0x876AFB41, 0x876BFB41, 0x876CFB41, 0x876DFB41, 0x876EFB41, 0x876FFB41, 0x8770FB41, 0x8771FB41, 0x8772FB41, 0x8773FB41, 0x8774FB41, 0x8775FB41, 0x8776FB41, 0x8777FB41, 0x8778FB41, 0x8779FB41, 0x877AFB41, 0x877BFB41, 0x877CFB41, 0x877DFB41, 0x877EFB41, 0x877FFB41, 0x8780FB41, 0x8781FB41, 0x8782FB41, 0x8783FB41, 0x8784FB41, 0x8785FB41, 0x8786FB41, 0x8787FB41, 0x8788FB41, 0x8789FB41, 0x878AFB41, 0x878BFB41, 0x878CFB41, 0x878DFB41, 0x878EFB41, 0x878FFB41, 0x8790FB41, 0x8791FB41, 0x8792FB41, 0x8793FB41, 0x8794FB41, 0x8795FB41, 0x8796FB41, 0x8797FB41, 0x8798FB41, 0x8799FB41, 0x879AFB41, 0x879BFB41, 0x879CFB41, 0x879DFB41, 0x879EFB41, 0x879FFB41, 0x87A0FB41, 0x87A1FB41, 0x87A2FB41, 0x87A3FB41, 0x87A4FB41, 0x87A5FB41, 0x87A6FB41, 0x87A7FB41, 0x87A8FB41, 0x87A9FB41, 0x87AAFB41, 0x87ABFB41, 0x87ACFB41, 0x87ADFB41, 0x87AEFB41, 0x87AFFB41, 0x87B0FB41, 0x87B1FB41, 0x87B2FB41, 0x87B3FB41, 0x87B4FB41, 0x87B5FB41, 0x87B6FB41, 0x87B7FB41, 0x87B8FB41, 0x87B9FB41, 0x87BAFB41, 0x87BBFB41, 0x87BCFB41, 0x87BDFB41, 0x87BEFB41, 0x87BFFB41, 0x87C0FB41, 0x87C1FB41, 0x87C2FB41, 0x87C3FB41, 0x87C4FB41, 0x87C5FB41, 0x87C6FB41, 0x87C7FB41, 0x87C8FB41, 0x87C9FB41, 0x87CAFB41, 0x87CBFB41, 0x87CCFB41, 0x87CDFB41, 0x87CEFB41, 0x87CFFB41, 0x87D0FB41, 0x87D1FB41, 0x87D2FB41, 0x87D3FB41, 0x87D4FB41, 0x87D5FB41, 0x87D6FB41, 0x87D7FB41, 0x87D8FB41, 0x87D9FB41, 0x87DAFB41, 0x87DBFB41, 0x87DCFB41, 0x87DDFB41, 0x87DEFB41, 0x87DFFB41, 0x87E0FB41, 0x87E1FB41, /* 8738 */
+ 0x87E2FB41, 0x87E3FB41, 0x87E4FB41, 0x87E5FB41, 0x87E6FB41, 0x87E7FB41, 0x87E8FB41, 0x87E9FB41, 0x87EAFB41, 0x87EBFB41, 0x87ECFB41, 0x87EDFB41, 0x87EEFB41, 0x87EFFB41, 0x87F0FB41, 0x87F1FB41, 0x87F2FB41, 0x87F3FB41, 0x87F4FB41, 0x87F5FB41, 0x87F6FB41, 0x87F7FB41, 0x87F8FB41, 0x87F9FB41, 0x87FAFB41, 0x87FBFB41, 0x87FCFB41, 0x87FDFB41, 0x87FEFB41, 0x87FFFB41, 0x8800FB41, 0x8801FB41, 0x8802FB41, 0x8803FB41, 0x8804FB41, 0x8805FB41, 0x8806FB41, 0x8807FB41, 0x8808FB41, 0x8809FB41, 0x880AFB41, 0x880BFB41, 0x880CFB41, 0x880DFB41, 0x880EFB41, 0x880FFB41, 0x8810FB41, 0x8811FB41, 0x8812FB41, 0x8813FB41, 0x8814FB41, 0x8815FB41, 0x8816FB41, 0x8817FB41, 0x8818FB41, 0x8819FB41, 0x881AFB41, 0x881BFB41, 0x881CFB41, 0x881DFB41, 0x881EFB41, 0x881FFB41, 0x8820FB41, 0x8821FB41, 0x8822FB41, 0x8823FB41, 0x8824FB41, 0x8825FB41, 0x8826FB41, 0x8827FB41, 0x8828FB41, 0x8829FB41, 0x882AFB41, 0x882BFB41, 0x882CFB41, 0x882DFB41, 0x882EFB41, 0x882FFB41, 0x8830FB41, 0x8831FB41, 0x8832FB41, 0x8833FB41, 0x8834FB41, 0x8835FB41, 0x8836FB41, 0x8837FB41, 0x8838FB41, 0x8839FB41, 0x883AFB41, 0x883BFB41, 0x883CFB41, 0x883DFB41, 0x883EFB41, 0x883FFB41, 0x8840FB41, 0x8841FB41, 0x8842FB41, 0x8843FB41, 0x8844FB41, 0x8845FB41, 0x8846FB41, 0x8847FB41, 0x8848FB41, 0x8849FB41, 0x884AFB41, 0x884BFB41, 0x884CFB41, 0x884DFB41, 0x884EFB41, 0x884FFB41, 0x8850FB41, 0x8851FB41, 0x8852FB41, 0x8853FB41, 0x8854FB41, 0x8855FB41, 0x8856FB41, 0x8857FB41, 0x8858FB41, 0x8859FB41, 0x885AFB41, 0x885BFB41, 0x885CFB41, 0x885DFB41, 0x885EFB41, 0x885FFB41, 0x8860FB41, 0x8861FB41, 0x8862FB41, 0x8863FB41, 0x8864FB41, 0x8865FB41, 0x8866FB41, 0x8867FB41, 0x8868FB41, 0x8869FB41, 0x886AFB41, 0x886BFB41, 0x886CFB41, 0x886DFB41, 0x886EFB41, 0x886FFB41, 0x8870FB41, 0x8871FB41, 0x8872FB41, 0x8873FB41, 0x8874FB41, 0x8875FB41, 0x8876FB41, 0x8877FB41, 0x8878FB41, 0x8879FB41, 0x887AFB41, 0x887BFB41, 0x887CFB41, 0x887DFB41, 0x887EFB41, 0x887FFB41, 0x8880FB41, 0x8881FB41, 0x8882FB41, 0x8883FB41, 0x8884FB41, 0x8885FB41, 0x8886FB41, 0x8887FB41, 0x8888FB41, 0x8889FB41, 0x888AFB41, 0x888BFB41, /* 87E2 */
+ 0x888CFB41, 0x888DFB41, 0x888EFB41, 0x888FFB41, 0x8890FB41, 0x8891FB41, 0x8892FB41, 0x8893FB41, 0x8894FB41, 0x8895FB41, 0x8896FB41, 0x8897FB41, 0x8898FB41, 0x8899FB41, 0x889AFB41, 0x889BFB41, 0x889CFB41, 0x889DFB41, 0x889EFB41, 0x889FFB41, 0x88A0FB41, 0x88A1FB41, 0x88A2FB41, 0x88A3FB41, 0x88A4FB41, 0x88A5FB41, 0x88A6FB41, 0x88A7FB41, 0x88A8FB41, 0x88A9FB41, 0x88AAFB41, 0x88ABFB41, 0x88ACFB41, 0x88ADFB41, 0x88AEFB41, 0x88AFFB41, 0x88B0FB41, 0x88B1FB41, 0x88B2FB41, 0x88B3FB41, 0x88B4FB41, 0x88B5FB41, 0x88B6FB41, 0x88B7FB41, 0x88B8FB41, 0x88B9FB41, 0x88BAFB41, 0x88BBFB41, 0x88BCFB41, 0x88BDFB41, 0x88BEFB41, 0x88BFFB41, 0x88C0FB41, 0x88C1FB41, 0x88C2FB41, 0x88C3FB41, 0x88C4FB41, 0x88C5FB41, 0x88C6FB41, 0x88C7FB41, 0x88C8FB41, 0x88C9FB41, 0x88CAFB41, 0x88CBFB41, 0x88CCFB41, 0x88CDFB41, 0x88CEFB41, 0x88CFFB41, 0x88D0FB41, 0x88D1FB41, 0x88D2FB41, 0x88D3FB41, 0x88D4FB41, 0x88D5FB41, 0x88D6FB41, 0x88D7FB41, 0x88D8FB41, 0x88D9FB41, 0x88DAFB41, 0x88DBFB41, 0x88DCFB41, 0x88DDFB41, 0x88DEFB41, 0x88DFFB41, 0x88E0FB41, 0x88E1FB41, 0x88E2FB41, 0x88E3FB41, 0x88E4FB41, 0x88E5FB41, 0x88E6FB41, 0x88E7FB41, 0x88E8FB41, 0x88E9FB41, 0x88EAFB41, 0x88EBFB41, 0x88ECFB41, 0x88EDFB41, 0x88EEFB41, 0x88EFFB41, 0x88F0FB41, 0x88F1FB41, 0x88F2FB41, 0x88F3FB41, 0x88F4FB41, 0x88F5FB41, 0x88F6FB41, 0x88F7FB41, 0x88F8FB41, 0x88F9FB41, 0x88FAFB41, 0x88FBFB41, 0x88FCFB41, 0x88FDFB41, 0x88FEFB41, 0x88FFFB41, 0x8900FB41, 0x8901FB41, 0x8902FB41, 0x8903FB41, 0x8904FB41, 0x8905FB41, 0x8906FB41, 0x8907FB41, 0x8908FB41, 0x8909FB41, 0x890AFB41, 0x890BFB41, 0x890CFB41, 0x890DFB41, 0x890EFB41, 0x890FFB41, 0x8910FB41, 0x8911FB41, 0x8912FB41, 0x8913FB41, 0x8914FB41, 0x8915FB41, 0x8916FB41, 0x8917FB41, 0x8918FB41, 0x8919FB41, 0x891AFB41, 0x891BFB41, 0x891CFB41, 0x891DFB41, 0x891EFB41, 0x891FFB41, 0x8920FB41, 0x8921FB41, 0x8922FB41, 0x8923FB41, 0x8924FB41, 0x8925FB41, 0x8926FB41, 0x8927FB41, 0x8928FB41, 0x8929FB41, 0x892AFB41, 0x892BFB41, 0x892CFB41, 0x892DFB41, 0x892EFB41, 0x892FFB41, 0x8930FB41, 0x8931FB41, 0x8932FB41, 0x8933FB41, 0x8934FB41, 0x8935FB41, /* 888C */
+ 0x8936FB41, 0x8937FB41, 0x8938FB41, 0x8939FB41, 0x893AFB41, 0x893BFB41, 0x893CFB41, 0x893DFB41, 0x893EFB41, 0x893FFB41, 0x8940FB41, 0x8941FB41, 0x8942FB41, 0x8943FB41, 0x8944FB41, 0x8945FB41, 0x8946FB41, 0x8947FB41, 0x8948FB41, 0x8949FB41, 0x894AFB41, 0x894BFB41, 0x894CFB41, 0x894DFB41, 0x894EFB41, 0x894FFB41, 0x8950FB41, 0x8951FB41, 0x8952FB41, 0x8953FB41, 0x8954FB41, 0x8955FB41, 0x8956FB41, 0x8957FB41, 0x8958FB41, 0x8959FB41, 0x895AFB41, 0x895BFB41, 0x895CFB41, 0x895DFB41, 0x895EFB41, 0x895FFB41, 0x8960FB41, 0x8961FB41, 0x8962FB41, 0x8963FB41, 0x8964FB41, 0x8965FB41, 0x8966FB41, 0x8967FB41, 0x8968FB41, 0x8969FB41, 0x896AFB41, 0x896BFB41, 0x896CFB41, 0x896DFB41, 0x896EFB41, 0x896FFB41, 0x8970FB41, 0x8971FB41, 0x8972FB41, 0x8973FB41, 0x8974FB41, 0x8975FB41, 0x8976FB41, 0x8977FB41, 0x8978FB41, 0x8979FB41, 0x897AFB41, 0x897BFB41, 0x897CFB41, 0x897DFB41, 0x897EFB41, 0x897FFB41, 0x8980FB41, 0x8981FB41, 0x8982FB41, 0x8983FB41, 0x8984FB41, 0x8985FB41, 0x8986FB41, 0x8987FB41, 0x8988FB41, 0x8989FB41, 0x898AFB41, 0x898BFB41, 0x898CFB41, 0x898DFB41, 0x898EFB41, 0x898FFB41, 0x8990FB41, 0x8991FB41, 0x8992FB41, 0x8993FB41, 0x8994FB41, 0x8995FB41, 0x8996FB41, 0x8997FB41, 0x8998FB41, 0x8999FB41, 0x899AFB41, 0x899BFB41, 0x899CFB41, 0x899DFB41, 0x899EFB41, 0x899FFB41, 0x89A0FB41, 0x89A1FB41, 0x89A2FB41, 0x89A3FB41, 0x89A4FB41, 0x89A5FB41, 0x89A6FB41, 0x89A7FB41, 0x89A8FB41, 0x89A9FB41, 0x89AAFB41, 0x89ABFB41, 0x89ACFB41, 0x89ADFB41, 0x89AEFB41, 0x89AFFB41, 0x89B0FB41, 0x89B1FB41, 0x89B2FB41, 0x89B3FB41, 0x89B4FB41, 0x89B5FB41, 0x89B6FB41, 0x89B7FB41, 0x89B8FB41, 0x89B9FB41, 0x89BAFB41, 0x89BBFB41, 0x89BCFB41, 0x89BDFB41, 0x89BEFB41, 0x89BFFB41, 0x89C0FB41, 0x89C1FB41, 0x89C2FB41, 0x89C3FB41, 0x89C4FB41, 0x89C5FB41, 0x89C6FB41, 0x89C7FB41, 0x89C8FB41, 0x89C9FB41, 0x89CAFB41, 0x89CBFB41, 0x89CCFB41, 0x89CDFB41, 0x89CEFB41, 0x89CFFB41, 0x89D0FB41, 0x89D1FB41, 0x89D2FB41, 0x89D3FB41, 0x89D4FB41, 0x89D5FB41, 0x89D6FB41, 0x89D7FB41, 0x89D8FB41, 0x89D9FB41, 0x89DAFB41, 0x89DBFB41, 0x89DCFB41, 0x89DDFB41, 0x89DEFB41, 0x89DFFB41, /* 8936 */
+ 0x89E0FB41, 0x89E1FB41, 0x89E2FB41, 0x89E3FB41, 0x89E4FB41, 0x89E5FB41, 0x89E6FB41, 0x89E7FB41, 0x89E8FB41, 0x89E9FB41, 0x89EAFB41, 0x89EBFB41, 0x89ECFB41, 0x89EDFB41, 0x89EEFB41, 0x89EFFB41, 0x89F0FB41, 0x89F1FB41, 0x89F2FB41, 0x89F3FB41, 0x89F4FB41, 0x89F5FB41, 0x89F6FB41, 0x89F7FB41, 0x89F8FB41, 0x89F9FB41, 0x89FAFB41, 0x89FBFB41, 0x89FCFB41, 0x89FDFB41, 0x89FEFB41, 0x89FFFB41, 0x8A00FB41, 0x8A01FB41, 0x8A02FB41, 0x8A03FB41, 0x8A04FB41, 0x8A05FB41, 0x8A06FB41, 0x8A07FB41, 0x8A08FB41, 0x8A09FB41, 0x8A0AFB41, 0x8A0BFB41, 0x8A0CFB41, 0x8A0DFB41, 0x8A0EFB41, 0x8A0FFB41, 0x8A10FB41, 0x8A11FB41, 0x8A12FB41, 0x8A13FB41, 0x8A14FB41, 0x8A15FB41, 0x8A16FB41, 0x8A17FB41, 0x8A18FB41, 0x8A19FB41, 0x8A1AFB41, 0x8A1BFB41, 0x8A1CFB41, 0x8A1DFB41, 0x8A1EFB41, 0x8A1FFB41, 0x8A20FB41, 0x8A21FB41, 0x8A22FB41, 0x8A23FB41, 0x8A24FB41, 0x8A25FB41, 0x8A26FB41, 0x8A27FB41, 0x8A28FB41, 0x8A29FB41, 0x8A2AFB41, 0x8A2BFB41, 0x8A2CFB41, 0x8A2DFB41, 0x8A2EFB41, 0x8A2FFB41, 0x8A30FB41, 0x8A31FB41, 0x8A32FB41, 0x8A33FB41, 0x8A34FB41, 0x8A35FB41, 0x8A36FB41, 0x8A37FB41, 0x8A38FB41, 0x8A39FB41, 0x8A3AFB41, 0x8A3BFB41, 0x8A3CFB41, 0x8A3DFB41, 0x8A3EFB41, 0x8A3FFB41, 0x8A40FB41, 0x8A41FB41, 0x8A42FB41, 0x8A43FB41, 0x8A44FB41, 0x8A45FB41, 0x8A46FB41, 0x8A47FB41, 0x8A48FB41, 0x8A49FB41, 0x8A4AFB41, 0x8A4BFB41, 0x8A4CFB41, 0x8A4DFB41, 0x8A4EFB41, 0x8A4FFB41, 0x8A50FB41, 0x8A51FB41, 0x8A52FB41, 0x8A53FB41, 0x8A54FB41, 0x8A55FB41, 0x8A56FB41, 0x8A57FB41, 0x8A58FB41, 0x8A59FB41, 0x8A5AFB41, 0x8A5BFB41, 0x8A5CFB41, 0x8A5DFB41, 0x8A5EFB41, 0x8A5FFB41, 0x8A60FB41, 0x8A61FB41, 0x8A62FB41, 0x8A63FB41, 0x8A64FB41, 0x8A65FB41, 0x8A66FB41, 0x8A67FB41, 0x8A68FB41, 0x8A69FB41, 0x8A6AFB41, 0x8A6BFB41, 0x8A6CFB41, 0x8A6DFB41, 0x8A6EFB41, 0x8A6FFB41, 0x8A70FB41, 0x8A71FB41, 0x8A72FB41, 0x8A73FB41, 0x8A74FB41, 0x8A75FB41, 0x8A76FB41, 0x8A77FB41, 0x8A78FB41, 0x8A79FB41, 0x8A7AFB41, 0x8A7BFB41, 0x8A7CFB41, 0x8A7DFB41, 0x8A7EFB41, 0x8A7FFB41, 0x8A80FB41, 0x8A81FB41, 0x8A82FB41, 0x8A83FB41, 0x8A84FB41, 0x8A85FB41, 0x8A86FB41, 0x8A87FB41, 0x8A88FB41, 0x8A89FB41, /* 89E0 */
+ 0x8A8AFB41, 0x8A8BFB41, 0x8A8CFB41, 0x8A8DFB41, 0x8A8EFB41, 0x8A8FFB41, 0x8A90FB41, 0x8A91FB41, 0x8A92FB41, 0x8A93FB41, 0x8A94FB41, 0x8A95FB41, 0x8A96FB41, 0x8A97FB41, 0x8A98FB41, 0x8A99FB41, 0x8A9AFB41, 0x8A9BFB41, 0x8A9CFB41, 0x8A9DFB41, 0x8A9EFB41, 0x8A9FFB41, 0x8AA0FB41, 0x8AA1FB41, 0x8AA2FB41, 0x8AA3FB41, 0x8AA4FB41, 0x8AA5FB41, 0x8AA6FB41, 0x8AA7FB41, 0x8AA8FB41, 0x8AA9FB41, 0x8AAAFB41, 0x8AABFB41, 0x8AACFB41, 0x8AADFB41, 0x8AAEFB41, 0x8AAFFB41, 0x8AB0FB41, 0x8AB1FB41, 0x8AB2FB41, 0x8AB3FB41, 0x8AB4FB41, 0x8AB5FB41, 0x8AB6FB41, 0x8AB7FB41, 0x8AB8FB41, 0x8AB9FB41, 0x8ABAFB41, 0x8ABBFB41, 0x8ABCFB41, 0x8ABDFB41, 0x8ABEFB41, 0x8ABFFB41, 0x8AC0FB41, 0x8AC1FB41, 0x8AC2FB41, 0x8AC3FB41, 0x8AC4FB41, 0x8AC5FB41, 0x8AC6FB41, 0x8AC7FB41, 0x8AC8FB41, 0x8AC9FB41, 0x8ACAFB41, 0x8ACBFB41, 0x8ACCFB41, 0x8ACDFB41, 0x8ACEFB41, 0x8ACFFB41, 0x8AD0FB41, 0x8AD1FB41, 0x8AD2FB41, 0x8AD3FB41, 0x8AD4FB41, 0x8AD5FB41, 0x8AD6FB41, 0x8AD7FB41, 0x8AD8FB41, 0x8AD9FB41, 0x8ADAFB41, 0x8ADBFB41, 0x8ADCFB41, 0x8ADDFB41, 0x8ADEFB41, 0x8ADFFB41, 0x8AE0FB41, 0x8AE1FB41, 0x8AE2FB41, 0x8AE3FB41, 0x8AE4FB41, 0x8AE5FB41, 0x8AE6FB41, 0x8AE7FB41, 0x8AE8FB41, 0x8AE9FB41, 0x8AEAFB41, 0x8AEBFB41, 0x8AECFB41, 0x8AEDFB41, 0x8AEEFB41, 0x8AEFFB41, 0x8AF0FB41, 0x8AF1FB41, 0x8AF2FB41, 0x8AF3FB41, 0x8AF4FB41, 0x8AF5FB41, 0x8AF6FB41, 0x8AF7FB41, 0x8AF8FB41, 0x8AF9FB41, 0x8AFAFB41, 0x8AFBFB41, 0x8AFCFB41, 0x8AFDFB41, 0x8AFEFB41, 0x8AFFFB41, 0x8B00FB41, 0x8B01FB41, 0x8B02FB41, 0x8B03FB41, 0x8B04FB41, 0x8B05FB41, 0x8B06FB41, 0x8B07FB41, 0x8B08FB41, 0x8B09FB41, 0x8B0AFB41, 0x8B0BFB41, 0x8B0CFB41, 0x8B0DFB41, 0x8B0EFB41, 0x8B0FFB41, 0x8B10FB41, 0x8B11FB41, 0x8B12FB41, 0x8B13FB41, 0x8B14FB41, 0x8B15FB41, 0x8B16FB41, 0x8B17FB41, 0x8B18FB41, 0x8B19FB41, 0x8B1AFB41, 0x8B1BFB41, 0x8B1CFB41, 0x8B1DFB41, 0x8B1EFB41, 0x8B1FFB41, 0x8B20FB41, 0x8B21FB41, 0x8B22FB41, 0x8B23FB41, 0x8B24FB41, 0x8B25FB41, 0x8B26FB41, 0x8B27FB41, 0x8B28FB41, 0x8B29FB41, 0x8B2AFB41, 0x8B2BFB41, 0x8B2CFB41, 0x8B2DFB41, 0x8B2EFB41, 0x8B2FFB41, 0x8B30FB41, 0x8B31FB41, 0x8B32FB41, 0x8B33FB41, /* 8A8A */
+ 0x8B34FB41, 0x8B35FB41, 0x8B36FB41, 0x8B37FB41, 0x8B38FB41, 0x8B39FB41, 0x8B3AFB41, 0x8B3BFB41, 0x8B3CFB41, 0x8B3DFB41, 0x8B3EFB41, 0x8B3FFB41, 0x8B40FB41, 0x8B41FB41, 0x8B42FB41, 0x8B43FB41, 0x8B44FB41, 0x8B45FB41, 0x8B46FB41, 0x8B47FB41, 0x8B48FB41, 0x8B49FB41, 0x8B4AFB41, 0x8B4BFB41, 0x8B4CFB41, 0x8B4DFB41, 0x8B4EFB41, 0x8B4FFB41, 0x8B50FB41, 0x8B51FB41, 0x8B52FB41, 0x8B53FB41, 0x8B54FB41, 0x8B55FB41, 0x8B56FB41, 0x8B57FB41, 0x8B58FB41, 0x8B59FB41, 0x8B5AFB41, 0x8B5BFB41, 0x8B5CFB41, 0x8B5DFB41, 0x8B5EFB41, 0x8B5FFB41, 0x8B60FB41, 0x8B61FB41, 0x8B62FB41, 0x8B63FB41, 0x8B64FB41, 0x8B65FB41, 0x8B66FB41, 0x8B67FB41, 0x8B68FB41, 0x8B69FB41, 0x8B6AFB41, 0x8B6BFB41, 0x8B6CFB41, 0x8B6DFB41, 0x8B6EFB41, 0x8B6FFB41, 0x8B70FB41, 0x8B71FB41, 0x8B72FB41, 0x8B73FB41, 0x8B74FB41, 0x8B75FB41, 0x8B76FB41, 0x8B77FB41, 0x8B78FB41, 0x8B79FB41, 0x8B7AFB41, 0x8B7BFB41, 0x8B7CFB41, 0x8B7DFB41, 0x8B7EFB41, 0x8B7FFB41, 0x8B80FB41, 0x8B81FB41, 0x8B82FB41, 0x8B83FB41, 0x8B84FB41, 0x8B85FB41, 0x8B86FB41, 0x8B87FB41, 0x8B88FB41, 0x8B89FB41, 0x8B8AFB41, 0x8B8BFB41, 0x8B8CFB41, 0x8B8DFB41, 0x8B8EFB41, 0x8B8FFB41, 0x8B90FB41, 0x8B91FB41, 0x8B92FB41, 0x8B93FB41, 0x8B94FB41, 0x8B95FB41, 0x8B96FB41, 0x8B97FB41, 0x8B98FB41, 0x8B99FB41, 0x8B9AFB41, 0x8B9BFB41, 0x8B9CFB41, 0x8B9DFB41, 0x8B9EFB41, 0x8B9FFB41, 0x8BA0FB41, 0x8BA1FB41, 0x8BA2FB41, 0x8BA3FB41, 0x8BA4FB41, 0x8BA5FB41, 0x8BA6FB41, 0x8BA7FB41, 0x8BA8FB41, 0x8BA9FB41, 0x8BAAFB41, 0x8BABFB41, 0x8BACFB41, 0x8BADFB41, 0x8BAEFB41, 0x8BAFFB41, 0x8BB0FB41, 0x8BB1FB41, 0x8BB2FB41, 0x8BB3FB41, 0x8BB4FB41, 0x8BB5FB41, 0x8BB6FB41, 0x8BB7FB41, 0x8BB8FB41, 0x8BB9FB41, 0x8BBAFB41, 0x8BBBFB41, 0x8BBCFB41, 0x8BBDFB41, 0x8BBEFB41, 0x8BBFFB41, 0x8BC0FB41, 0x8BC1FB41, 0x8BC2FB41, 0x8BC3FB41, 0x8BC4FB41, 0x8BC5FB41, 0x8BC6FB41, 0x8BC7FB41, 0x8BC8FB41, 0x8BC9FB41, 0x8BCAFB41, 0x8BCBFB41, 0x8BCCFB41, 0x8BCDFB41, 0x8BCEFB41, 0x8BCFFB41, 0x8BD0FB41, 0x8BD1FB41, 0x8BD2FB41, 0x8BD3FB41, 0x8BD4FB41, 0x8BD5FB41, 0x8BD6FB41, 0x8BD7FB41, 0x8BD8FB41, 0x8BD9FB41, 0x8BDAFB41, 0x8BDBFB41, 0x8BDCFB41, 0x8BDDFB41, /* 8B34 */
+ 0x8BDEFB41, 0x8BDFFB41, 0x8BE0FB41, 0x8BE1FB41, 0x8BE2FB41, 0x8BE3FB41, 0x8BE4FB41, 0x8BE5FB41, 0x8BE6FB41, 0x8BE7FB41, 0x8BE8FB41, 0x8BE9FB41, 0x8BEAFB41, 0x8BEBFB41, 0x8BECFB41, 0x8BEDFB41, 0x8BEEFB41, 0x8BEFFB41, 0x8BF0FB41, 0x8BF1FB41, 0x8BF2FB41, 0x8BF3FB41, 0x8BF4FB41, 0x8BF5FB41, 0x8BF6FB41, 0x8BF7FB41, 0x8BF8FB41, 0x8BF9FB41, 0x8BFAFB41, 0x8BFBFB41, 0x8BFCFB41, 0x8BFDFB41, 0x8BFEFB41, 0x8BFFFB41, 0x8C00FB41, 0x8C01FB41, 0x8C02FB41, 0x8C03FB41, 0x8C04FB41, 0x8C05FB41, 0x8C06FB41, 0x8C07FB41, 0x8C08FB41, 0x8C09FB41, 0x8C0AFB41, 0x8C0BFB41, 0x8C0CFB41, 0x8C0DFB41, 0x8C0EFB41, 0x8C0FFB41, 0x8C10FB41, 0x8C11FB41, 0x8C12FB41, 0x8C13FB41, 0x8C14FB41, 0x8C15FB41, 0x8C16FB41, 0x8C17FB41, 0x8C18FB41, 0x8C19FB41, 0x8C1AFB41, 0x8C1BFB41, 0x8C1CFB41, 0x8C1DFB41, 0x8C1EFB41, 0x8C1FFB41, 0x8C20FB41, 0x8C21FB41, 0x8C22FB41, 0x8C23FB41, 0x8C24FB41, 0x8C25FB41, 0x8C26FB41, 0x8C27FB41, 0x8C28FB41, 0x8C29FB41, 0x8C2AFB41, 0x8C2BFB41, 0x8C2CFB41, 0x8C2DFB41, 0x8C2EFB41, 0x8C2FFB41, 0x8C30FB41, 0x8C31FB41, 0x8C32FB41, 0x8C33FB41, 0x8C34FB41, 0x8C35FB41, 0x8C36FB41, 0x8C37FB41, 0x8C38FB41, 0x8C39FB41, 0x8C3AFB41, 0x8C3BFB41, 0x8C3CFB41, 0x8C3DFB41, 0x8C3EFB41, 0x8C3FFB41, 0x8C40FB41, 0x8C41FB41, 0x8C42FB41, 0x8C43FB41, 0x8C44FB41, 0x8C45FB41, 0x8C46FB41, 0x8C47FB41, 0x8C48FB41, 0x8C49FB41, 0x8C4AFB41, 0x8C4BFB41, 0x8C4CFB41, 0x8C4DFB41, 0x8C4EFB41, 0x8C4FFB41, 0x8C50FB41, 0x8C51FB41, 0x8C52FB41, 0x8C53FB41, 0x8C54FB41, 0x8C55FB41, 0x8C56FB41, 0x8C57FB41, 0x8C58FB41, 0x8C59FB41, 0x8C5AFB41, 0x8C5BFB41, 0x8C5CFB41, 0x8C5DFB41, 0x8C5EFB41, 0x8C5FFB41, 0x8C60FB41, 0x8C61FB41, 0x8C62FB41, 0x8C63FB41, 0x8C64FB41, 0x8C65FB41, 0x8C66FB41, 0x8C67FB41, 0x8C68FB41, 0x8C69FB41, 0x8C6AFB41, 0x8C6BFB41, 0x8C6CFB41, 0x8C6DFB41, 0x8C6EFB41, 0x8C6FFB41, 0x8C70FB41, 0x8C71FB41, 0x8C72FB41, 0x8C73FB41, 0x8C74FB41, 0x8C75FB41, 0x8C76FB41, 0x8C77FB41, 0x8C78FB41, 0x8C79FB41, 0x8C7AFB41, 0x8C7BFB41, 0x8C7CFB41, 0x8C7DFB41, 0x8C7EFB41, 0x8C7FFB41, 0x8C80FB41, 0x8C81FB41, 0x8C82FB41, 0x8C83FB41, 0x8C84FB41, 0x8C85FB41, 0x8C86FB41, 0x8C87FB41, /* 8BDE */
+ 0x8C88FB41, 0x8C89FB41, 0x8C8AFB41, 0x8C8BFB41, 0x8C8CFB41, 0x8C8DFB41, 0x8C8EFB41, 0x8C8FFB41, 0x8C90FB41, 0x8C91FB41, 0x8C92FB41, 0x8C93FB41, 0x8C94FB41, 0x8C95FB41, 0x8C96FB41, 0x8C97FB41, 0x8C98FB41, 0x8C99FB41, 0x8C9AFB41, 0x8C9BFB41, 0x8C9CFB41, 0x8C9DFB41, 0x8C9EFB41, 0x8C9FFB41, 0x8CA0FB41, 0x8CA1FB41, 0x8CA2FB41, 0x8CA3FB41, 0x8CA4FB41, 0x8CA5FB41, 0x8CA6FB41, 0x8CA7FB41, 0x8CA8FB41, 0x8CA9FB41, 0x8CAAFB41, 0x8CABFB41, 0x8CACFB41, 0x8CADFB41, 0x8CAEFB41, 0x8CAFFB41, 0x8CB0FB41, 0x8CB1FB41, 0x8CB2FB41, 0x8CB3FB41, 0x8CB4FB41, 0x8CB5FB41, 0x8CB6FB41, 0x8CB7FB41, 0x8CB8FB41, 0x8CB9FB41, 0x8CBAFB41, 0x8CBBFB41, 0x8CBCFB41, 0x8CBDFB41, 0x8CBEFB41, 0x8CBFFB41, 0x8CC0FB41, 0x8CC1FB41, 0x8CC2FB41, 0x8CC3FB41, 0x8CC4FB41, 0x8CC5FB41, 0x8CC6FB41, 0x8CC7FB41, 0x8CC8FB41, 0x8CC9FB41, 0x8CCAFB41, 0x8CCBFB41, 0x8CCCFB41, 0x8CCDFB41, 0x8CCEFB41, 0x8CCFFB41, 0x8CD0FB41, 0x8CD1FB41, 0x8CD2FB41, 0x8CD3FB41, 0x8CD4FB41, 0x8CD5FB41, 0x8CD6FB41, 0x8CD7FB41, 0x8CD8FB41, 0x8CD9FB41, 0x8CDAFB41, 0x8CDBFB41, 0x8CDCFB41, 0x8CDDFB41, 0x8CDEFB41, 0x8CDFFB41, 0x8CE0FB41, 0x8CE1FB41, 0x8CE2FB41, 0x8CE3FB41, 0x8CE4FB41, 0x8CE5FB41, 0x8CE6FB41, 0x8CE7FB41, 0x8CE8FB41, 0x8CE9FB41, 0x8CEAFB41, 0x8CEBFB41, 0x8CECFB41, 0x8CEDFB41, 0x8CEEFB41, 0x8CEFFB41, 0x8CF0FB41, 0x8CF1FB41, 0x8CF2FB41, 0x8CF3FB41, 0x8CF4FB41, 0x8CF5FB41, 0x8CF6FB41, 0x8CF7FB41, 0x8CF8FB41, 0x8CF9FB41, 0x8CFAFB41, 0x8CFBFB41, 0x8CFCFB41, 0x8CFDFB41, 0x8CFEFB41, 0x8CFFFB41, 0x8D00FB41, 0x8D01FB41, 0x8D02FB41, 0x8D03FB41, 0x8D04FB41, 0x8D05FB41, 0x8D06FB41, 0x8D07FB41, 0x8D08FB41, 0x8D09FB41, 0x8D0AFB41, 0x8D0BFB41, 0x8D0CFB41, 0x8D0DFB41, 0x8D0EFB41, 0x8D0FFB41, 0x8D10FB41, 0x8D11FB41, 0x8D12FB41, 0x8D13FB41, 0x8D14FB41, 0x8D15FB41, 0x8D16FB41, 0x8D17FB41, 0x8D18FB41, 0x8D19FB41, 0x8D1AFB41, 0x8D1BFB41, 0x8D1CFB41, 0x8D1DFB41, 0x8D1EFB41, 0x8D1FFB41, 0x8D20FB41, 0x8D21FB41, 0x8D22FB41, 0x8D23FB41, 0x8D24FB41, 0x8D25FB41, 0x8D26FB41, 0x8D27FB41, 0x8D28FB41, 0x8D29FB41, 0x8D2AFB41, 0x8D2BFB41, 0x8D2CFB41, 0x8D2DFB41, 0x8D2EFB41, 0x8D2FFB41, 0x8D30FB41, 0x8D31FB41, /* 8C88 */
+ 0x8D32FB41, 0x8D33FB41, 0x8D34FB41, 0x8D35FB41, 0x8D36FB41, 0x8D37FB41, 0x8D38FB41, 0x8D39FB41, 0x8D3AFB41, 0x8D3BFB41, 0x8D3CFB41, 0x8D3DFB41, 0x8D3EFB41, 0x8D3FFB41, 0x8D40FB41, 0x8D41FB41, 0x8D42FB41, 0x8D43FB41, 0x8D44FB41, 0x8D45FB41, 0x8D46FB41, 0x8D47FB41, 0x8D48FB41, 0x8D49FB41, 0x8D4AFB41, 0x8D4BFB41, 0x8D4CFB41, 0x8D4DFB41, 0x8D4EFB41, 0x8D4FFB41, 0x8D50FB41, 0x8D51FB41, 0x8D52FB41, 0x8D53FB41, 0x8D54FB41, 0x8D55FB41, 0x8D56FB41, 0x8D57FB41, 0x8D58FB41, 0x8D59FB41, 0x8D5AFB41, 0x8D5BFB41, 0x8D5CFB41, 0x8D5DFB41, 0x8D5EFB41, 0x8D5FFB41, 0x8D60FB41, 0x8D61FB41, 0x8D62FB41, 0x8D63FB41, 0x8D64FB41, 0x8D65FB41, 0x8D66FB41, 0x8D67FB41, 0x8D68FB41, 0x8D69FB41, 0x8D6AFB41, 0x8D6BFB41, 0x8D6CFB41, 0x8D6DFB41, 0x8D6EFB41, 0x8D6FFB41, 0x8D70FB41, 0x8D71FB41, 0x8D72FB41, 0x8D73FB41, 0x8D74FB41, 0x8D75FB41, 0x8D76FB41, 0x8D77FB41, 0x8D78FB41, 0x8D79FB41, 0x8D7AFB41, 0x8D7BFB41, 0x8D7CFB41, 0x8D7DFB41, 0x8D7EFB41, 0x8D7FFB41, 0x8D80FB41, 0x8D81FB41, 0x8D82FB41, 0x8D83FB41, 0x8D84FB41, 0x8D85FB41, 0x8D86FB41, 0x8D87FB41, 0x8D88FB41, 0x8D89FB41, 0x8D8AFB41, 0x8D8BFB41, 0x8D8CFB41, 0x8D8DFB41, 0x8D8EFB41, 0x8D8FFB41, 0x8D90FB41, 0x8D91FB41, 0x8D92FB41, 0x8D93FB41, 0x8D94FB41, 0x8D95FB41, 0x8D96FB41, 0x8D97FB41, 0x8D98FB41, 0x8D99FB41, 0x8D9AFB41, 0x8D9BFB41, 0x8D9CFB41, 0x8D9DFB41, 0x8D9EFB41, 0x8D9FFB41, 0x8DA0FB41, 0x8DA1FB41, 0x8DA2FB41, 0x8DA3FB41, 0x8DA4FB41, 0x8DA5FB41, 0x8DA6FB41, 0x8DA7FB41, 0x8DA8FB41, 0x8DA9FB41, 0x8DAAFB41, 0x8DABFB41, 0x8DACFB41, 0x8DADFB41, 0x8DAEFB41, 0x8DAFFB41, 0x8DB0FB41, 0x8DB1FB41, 0x8DB2FB41, 0x8DB3FB41, 0x8DB4FB41, 0x8DB5FB41, 0x8DB6FB41, 0x8DB7FB41, 0x8DB8FB41, 0x8DB9FB41, 0x8DBAFB41, 0x8DBBFB41, 0x8DBCFB41, 0x8DBDFB41, 0x8DBEFB41, 0x8DBFFB41, 0x8DC0FB41, 0x8DC1FB41, 0x8DC2FB41, 0x8DC3FB41, 0x8DC4FB41, 0x8DC5FB41, 0x8DC6FB41, 0x8DC7FB41, 0x8DC8FB41, 0x8DC9FB41, 0x8DCAFB41, 0x8DCBFB41, 0x8DCCFB41, 0x8DCDFB41, 0x8DCEFB41, 0x8DCFFB41, 0x8DD0FB41, 0x8DD1FB41, 0x8DD2FB41, 0x8DD3FB41, 0x8DD4FB41, 0x8DD5FB41, 0x8DD6FB41, 0x8DD7FB41, 0x8DD8FB41, 0x8DD9FB41, 0x8DDAFB41, 0x8DDBFB41, /* 8D32 */
+ 0x8DDCFB41, 0x8DDDFB41, 0x8DDEFB41, 0x8DDFFB41, 0x8DE0FB41, 0x8DE1FB41, 0x8DE2FB41, 0x8DE3FB41, 0x8DE4FB41, 0x8DE5FB41, 0x8DE6FB41, 0x8DE7FB41, 0x8DE8FB41, 0x8DE9FB41, 0x8DEAFB41, 0x8DEBFB41, 0x8DECFB41, 0x8DEDFB41, 0x8DEEFB41, 0x8DEFFB41, 0x8DF0FB41, 0x8DF1FB41, 0x8DF2FB41, 0x8DF3FB41, 0x8DF4FB41, 0x8DF5FB41, 0x8DF6FB41, 0x8DF7FB41, 0x8DF8FB41, 0x8DF9FB41, 0x8DFAFB41, 0x8DFBFB41, 0x8DFCFB41, 0x8DFDFB41, 0x8DFEFB41, 0x8DFFFB41, 0x8E00FB41, 0x8E01FB41, 0x8E02FB41, 0x8E03FB41, 0x8E04FB41, 0x8E05FB41, 0x8E06FB41, 0x8E07FB41, 0x8E08FB41, 0x8E09FB41, 0x8E0AFB41, 0x8E0BFB41, 0x8E0CFB41, 0x8E0DFB41, 0x8E0EFB41, 0x8E0FFB41, 0x8E10FB41, 0x8E11FB41, 0x8E12FB41, 0x8E13FB41, 0x8E14FB41, 0x8E15FB41, 0x8E16FB41, 0x8E17FB41, 0x8E18FB41, 0x8E19FB41, 0x8E1AFB41, 0x8E1BFB41, 0x8E1CFB41, 0x8E1DFB41, 0x8E1EFB41, 0x8E1FFB41, 0x8E20FB41, 0x8E21FB41, 0x8E22FB41, 0x8E23FB41, 0x8E24FB41, 0x8E25FB41, 0x8E26FB41, 0x8E27FB41, 0x8E28FB41, 0x8E29FB41, 0x8E2AFB41, 0x8E2BFB41, 0x8E2CFB41, 0x8E2DFB41, 0x8E2EFB41, 0x8E2FFB41, 0x8E30FB41, 0x8E31FB41, 0x8E32FB41, 0x8E33FB41, 0x8E34FB41, 0x8E35FB41, 0x8E36FB41, 0x8E37FB41, 0x8E38FB41, 0x8E39FB41, 0x8E3AFB41, 0x8E3BFB41, 0x8E3CFB41, 0x8E3DFB41, 0x8E3EFB41, 0x8E3FFB41, 0x8E40FB41, 0x8E41FB41, 0x8E42FB41, 0x8E43FB41, 0x8E44FB41, 0x8E45FB41, 0x8E46FB41, 0x8E47FB41, 0x8E48FB41, 0x8E49FB41, 0x8E4AFB41, 0x8E4BFB41, 0x8E4CFB41, 0x8E4DFB41, 0x8E4EFB41, 0x8E4FFB41, 0x8E50FB41, 0x8E51FB41, 0x8E52FB41, 0x8E53FB41, 0x8E54FB41, 0x8E55FB41, 0x8E56FB41, 0x8E57FB41, 0x8E58FB41, 0x8E59FB41, 0x8E5AFB41, 0x8E5BFB41, 0x8E5CFB41, 0x8E5DFB41, 0x8E5EFB41, 0x8E5FFB41, 0x8E60FB41, 0x8E61FB41, 0x8E62FB41, 0x8E63FB41, 0x8E64FB41, 0x8E65FB41, 0x8E66FB41, 0x8E67FB41, 0x8E68FB41, 0x8E69FB41, 0x8E6AFB41, 0x8E6BFB41, 0x8E6CFB41, 0x8E6DFB41, 0x8E6EFB41, 0x8E6FFB41, 0x8E70FB41, 0x8E71FB41, 0x8E72FB41, 0x8E73FB41, 0x8E74FB41, 0x8E75FB41, 0x8E76FB41, 0x8E77FB41, 0x8E78FB41, 0x8E79FB41, 0x8E7AFB41, 0x8E7BFB41, 0x8E7CFB41, 0x8E7DFB41, 0x8E7EFB41, 0x8E7FFB41, 0x8E80FB41, 0x8E81FB41, 0x8E82FB41, 0x8E83FB41, 0x8E84FB41, 0x8E85FB41, /* 8DDC */
+ 0x8E86FB41, 0x8E87FB41, 0x8E88FB41, 0x8E89FB41, 0x8E8AFB41, 0x8E8BFB41, 0x8E8CFB41, 0x8E8DFB41, 0x8E8EFB41, 0x8E8FFB41, 0x8E90FB41, 0x8E91FB41, 0x8E92FB41, 0x8E93FB41, 0x8E94FB41, 0x8E95FB41, 0x8E96FB41, 0x8E97FB41, 0x8E98FB41, 0x8E99FB41, 0x8E9AFB41, 0x8E9BFB41, 0x8E9CFB41, 0x8E9DFB41, 0x8E9EFB41, 0x8E9FFB41, 0x8EA0FB41, 0x8EA1FB41, 0x8EA2FB41, 0x8EA3FB41, 0x8EA4FB41, 0x8EA5FB41, 0x8EA6FB41, 0x8EA7FB41, 0x8EA8FB41, 0x8EA9FB41, 0x8EAAFB41, 0x8EABFB41, 0x8EACFB41, 0x8EADFB41, 0x8EAEFB41, 0x8EAFFB41, 0x8EB0FB41, 0x8EB1FB41, 0x8EB2FB41, 0x8EB3FB41, 0x8EB4FB41, 0x8EB5FB41, 0x8EB6FB41, 0x8EB7FB41, 0x8EB8FB41, 0x8EB9FB41, 0x8EBAFB41, 0x8EBBFB41, 0x8EBCFB41, 0x8EBDFB41, 0x8EBEFB41, 0x8EBFFB41, 0x8EC0FB41, 0x8EC1FB41, 0x8EC2FB41, 0x8EC3FB41, 0x8EC4FB41, 0x8EC5FB41, 0x8EC6FB41, 0x8EC7FB41, 0x8EC8FB41, 0x8EC9FB41, 0x8ECAFB41, 0x8ECBFB41, 0x8ECCFB41, 0x8ECDFB41, 0x8ECEFB41, 0x8ECFFB41, 0x8ED0FB41, 0x8ED1FB41, 0x8ED2FB41, 0x8ED3FB41, 0x8ED4FB41, 0x8ED5FB41, 0x8ED6FB41, 0x8ED7FB41, 0x8ED8FB41, 0x8ED9FB41, 0x8EDAFB41, 0x8EDBFB41, 0x8EDCFB41, 0x8EDDFB41, 0x8EDEFB41, 0x8EDFFB41, 0x8EE0FB41, 0x8EE1FB41, 0x8EE2FB41, 0x8EE3FB41, 0x8EE4FB41, 0x8EE5FB41, 0x8EE6FB41, 0x8EE7FB41, 0x8EE8FB41, 0x8EE9FB41, 0x8EEAFB41, 0x8EEBFB41, 0x8EECFB41, 0x8EEDFB41, 0x8EEEFB41, 0x8EEFFB41, 0x8EF0FB41, 0x8EF1FB41, 0x8EF2FB41, 0x8EF3FB41, 0x8EF4FB41, 0x8EF5FB41, 0x8EF6FB41, 0x8EF7FB41, 0x8EF8FB41, 0x8EF9FB41, 0x8EFAFB41, 0x8EFBFB41, 0x8EFCFB41, 0x8EFDFB41, 0x8EFEFB41, 0x8EFFFB41, 0x8F00FB41, 0x8F01FB41, 0x8F02FB41, 0x8F03FB41, 0x8F04FB41, 0x8F05FB41, 0x8F06FB41, 0x8F07FB41, 0x8F08FB41, 0x8F09FB41, 0x8F0AFB41, 0x8F0BFB41, 0x8F0CFB41, 0x8F0DFB41, 0x8F0EFB41, 0x8F0FFB41, 0x8F10FB41, 0x8F11FB41, 0x8F12FB41, 0x8F13FB41, 0x8F14FB41, 0x8F15FB41, 0x8F16FB41, 0x8F17FB41, 0x8F18FB41, 0x8F19FB41, 0x8F1AFB41, 0x8F1BFB41, 0x8F1CFB41, 0x8F1DFB41, 0x8F1EFB41, 0x8F1FFB41, 0x8F20FB41, 0x8F21FB41, 0x8F22FB41, 0x8F23FB41, 0x8F24FB41, 0x8F25FB41, 0x8F26FB41, 0x8F27FB41, 0x8F28FB41, 0x8F29FB41, 0x8F2AFB41, 0x8F2BFB41, 0x8F2CFB41, 0x8F2DFB41, 0x8F2EFB41, 0x8F2FFB41, /* 8E86 */
+ 0x8F30FB41, 0x8F31FB41, 0x8F32FB41, 0x8F33FB41, 0x8F34FB41, 0x8F35FB41, 0x8F36FB41, 0x8F37FB41, 0x8F38FB41, 0x8F39FB41, 0x8F3AFB41, 0x8F3BFB41, 0x8F3CFB41, 0x8F3DFB41, 0x8F3EFB41, 0x8F3FFB41, 0x8F40FB41, 0x8F41FB41, 0x8F42FB41, 0x8F43FB41, 0x8F44FB41, 0x8F45FB41, 0x8F46FB41, 0x8F47FB41, 0x8F48FB41, 0x8F49FB41, 0x8F4AFB41, 0x8F4BFB41, 0x8F4CFB41, 0x8F4DFB41, 0x8F4EFB41, 0x8F4FFB41, 0x8F50FB41, 0x8F51FB41, 0x8F52FB41, 0x8F53FB41, 0x8F54FB41, 0x8F55FB41, 0x8F56FB41, 0x8F57FB41, 0x8F58FB41, 0x8F59FB41, 0x8F5AFB41, 0x8F5BFB41, 0x8F5CFB41, 0x8F5DFB41, 0x8F5EFB41, 0x8F5FFB41, 0x8F60FB41, 0x8F61FB41, 0x8F62FB41, 0x8F63FB41, 0x8F64FB41, 0x8F65FB41, 0x8F66FB41, 0x8F67FB41, 0x8F68FB41, 0x8F69FB41, 0x8F6AFB41, 0x8F6BFB41, 0x8F6CFB41, 0x8F6DFB41, 0x8F6EFB41, 0x8F6FFB41, 0x8F70FB41, 0x8F71FB41, 0x8F72FB41, 0x8F73FB41, 0x8F74FB41, 0x8F75FB41, 0x8F76FB41, 0x8F77FB41, 0x8F78FB41, 0x8F79FB41, 0x8F7AFB41, 0x8F7BFB41, 0x8F7CFB41, 0x8F7DFB41, 0x8F7EFB41, 0x8F7FFB41, 0x8F80FB41, 0x8F81FB41, 0x8F82FB41, 0x8F83FB41, 0x8F84FB41, 0x8F85FB41, 0x8F86FB41, 0x8F87FB41, 0x8F88FB41, 0x8F89FB41, 0x8F8AFB41, 0x8F8BFB41, 0x8F8CFB41, 0x8F8DFB41, 0x8F8EFB41, 0x8F8FFB41, 0x8F90FB41, 0x8F91FB41, 0x8F92FB41, 0x8F93FB41, 0x8F94FB41, 0x8F95FB41, 0x8F96FB41, 0x8F97FB41, 0x8F98FB41, 0x8F99FB41, 0x8F9AFB41, 0x8F9BFB41, 0x8F9CFB41, 0x8F9DFB41, 0x8F9EFB41, 0x8F9FFB41, 0x8FA0FB41, 0x8FA1FB41, 0x8FA2FB41, 0x8FA3FB41, 0x8FA4FB41, 0x8FA5FB41, 0x8FA6FB41, 0x8FA7FB41, 0x8FA8FB41, 0x8FA9FB41, 0x8FAAFB41, 0x8FABFB41, 0x8FACFB41, 0x8FADFB41, 0x8FAEFB41, 0x8FAFFB41, 0x8FB0FB41, 0x8FB1FB41, 0x8FB2FB41, 0x8FB3FB41, 0x8FB4FB41, 0x8FB5FB41, 0x8FB6FB41, 0x8FB7FB41, 0x8FB8FB41, 0x8FB9FB41, 0x8FBAFB41, 0x8FBBFB41, 0x8FBCFB41, 0x8FBDFB41, 0x8FBEFB41, 0x8FBFFB41, 0x8FC0FB41, 0x8FC1FB41, 0x8FC2FB41, 0x8FC3FB41, 0x8FC4FB41, 0x8FC5FB41, 0x8FC6FB41, 0x8FC7FB41, 0x8FC8FB41, 0x8FC9FB41, 0x8FCAFB41, 0x8FCBFB41, 0x8FCCFB41, 0x8FCDFB41, 0x8FCEFB41, 0x8FCFFB41, 0x8FD0FB41, 0x8FD1FB41, 0x8FD2FB41, 0x8FD3FB41, 0x8FD4FB41, 0x8FD5FB41, 0x8FD6FB41, 0x8FD7FB41, 0x8FD8FB41, 0x8FD9FB41, /* 8F30 */
+ 0x8FDAFB41, 0x8FDBFB41, 0x8FDCFB41, 0x8FDDFB41, 0x8FDEFB41, 0x8FDFFB41, 0x8FE0FB41, 0x8FE1FB41, 0x8FE2FB41, 0x8FE3FB41, 0x8FE4FB41, 0x8FE5FB41, 0x8FE6FB41, 0x8FE7FB41, 0x8FE8FB41, 0x8FE9FB41, 0x8FEAFB41, 0x8FEBFB41, 0x8FECFB41, 0x8FEDFB41, 0x8FEEFB41, 0x8FEFFB41, 0x8FF0FB41, 0x8FF1FB41, 0x8FF2FB41, 0x8FF3FB41, 0x8FF4FB41, 0x8FF5FB41, 0x8FF6FB41, 0x8FF7FB41, 0x8FF8FB41, 0x8FF9FB41, 0x8FFAFB41, 0x8FFBFB41, 0x8FFCFB41, 0x8FFDFB41, 0x8FFEFB41, 0x8FFFFB41, 0x9000FB41, 0x9001FB41, 0x9002FB41, 0x9003FB41, 0x9004FB41, 0x9005FB41, 0x9006FB41, 0x9007FB41, 0x9008FB41, 0x9009FB41, 0x900AFB41, 0x900BFB41, 0x900CFB41, 0x900DFB41, 0x900EFB41, 0x900FFB41, 0x9010FB41, 0x9011FB41, 0x9012FB41, 0x9013FB41, 0x9014FB41, 0x9015FB41, 0x9016FB41, 0x9017FB41, 0x9018FB41, 0x9019FB41, 0x901AFB41, 0x901BFB41, 0x901CFB41, 0x901DFB41, 0x901EFB41, 0x901FFB41, 0x9020FB41, 0x9021FB41, 0x9022FB41, 0x9023FB41, 0x9024FB41, 0x9025FB41, 0x9026FB41, 0x9027FB41, 0x9028FB41, 0x9029FB41, 0x902AFB41, 0x902BFB41, 0x902CFB41, 0x902DFB41, 0x902EFB41, 0x902FFB41, 0x9030FB41, 0x9031FB41, 0x9032FB41, 0x9033FB41, 0x9034FB41, 0x9035FB41, 0x9036FB41, 0x9037FB41, 0x9038FB41, 0x9039FB41, 0x903AFB41, 0x903BFB41, 0x903CFB41, 0x903DFB41, 0x903EFB41, 0x903FFB41, 0x9040FB41, 0x9041FB41, 0x9042FB41, 0x9043FB41, 0x9044FB41, 0x9045FB41, 0x9046FB41, 0x9047FB41, 0x9048FB41, 0x9049FB41, 0x904AFB41, 0x904BFB41, 0x904CFB41, 0x904DFB41, 0x904EFB41, 0x904FFB41, 0x9050FB41, 0x9051FB41, 0x9052FB41, 0x9053FB41, 0x9054FB41, 0x9055FB41, 0x9056FB41, 0x9057FB41, 0x9058FB41, 0x9059FB41, 0x905AFB41, 0x905BFB41, 0x905CFB41, 0x905DFB41, 0x905EFB41, 0x905FFB41, 0x9060FB41, 0x9061FB41, 0x9062FB41, 0x9063FB41, 0x9064FB41, 0x9065FB41, 0x9066FB41, 0x9067FB41, 0x9068FB41, 0x9069FB41, 0x906AFB41, 0x906BFB41, 0x906CFB41, 0x906DFB41, 0x906EFB41, 0x906FFB41, 0x9070FB41, 0x9071FB41, 0x9072FB41, 0x9073FB41, 0x9074FB41, 0x9075FB41, 0x9076FB41, 0x9077FB41, 0x9078FB41, 0x9079FB41, 0x907AFB41, 0x907BFB41, 0x907CFB41, 0x907DFB41, 0x907EFB41, 0x907FFB41, 0x9080FB41, 0x9081FB41, 0x9082FB41, 0x9083FB41, /* 8FDA */
+ 0x9084FB41, 0x9085FB41, 0x9086FB41, 0x9087FB41, 0x9088FB41, 0x9089FB41, 0x908AFB41, 0x908BFB41, 0x908CFB41, 0x908DFB41, 0x908EFB41, 0x908FFB41, 0x9090FB41, 0x9091FB41, 0x9092FB41, 0x9093FB41, 0x9094FB41, 0x9095FB41, 0x9096FB41, 0x9097FB41, 0x9098FB41, 0x9099FB41, 0x909AFB41, 0x909BFB41, 0x909CFB41, 0x909DFB41, 0x909EFB41, 0x909FFB41, 0x90A0FB41, 0x90A1FB41, 0x90A2FB41, 0x90A3FB41, 0x90A4FB41, 0x90A5FB41, 0x90A6FB41, 0x90A7FB41, 0x90A8FB41, 0x90A9FB41, 0x90AAFB41, 0x90ABFB41, 0x90ACFB41, 0x90ADFB41, 0x90AEFB41, 0x90AFFB41, 0x90B0FB41, 0x90B1FB41, 0x90B2FB41, 0x90B3FB41, 0x90B4FB41, 0x90B5FB41, 0x90B6FB41, 0x90B7FB41, 0x90B8FB41, 0x90B9FB41, 0x90BAFB41, 0x90BBFB41, 0x90BCFB41, 0x90BDFB41, 0x90BEFB41, 0x90BFFB41, 0x90C0FB41, 0x90C1FB41, 0x90C2FB41, 0x90C3FB41, 0x90C4FB41, 0x90C5FB41, 0x90C6FB41, 0x90C7FB41, 0x90C8FB41, 0x90C9FB41, 0x90CAFB41, 0x90CBFB41, 0x90CCFB41, 0x90CDFB41, 0x90CEFB41, 0x90CFFB41, 0x90D0FB41, 0x90D1FB41, 0x90D2FB41, 0x90D3FB41, 0x90D4FB41, 0x90D5FB41, 0x90D6FB41, 0x90D7FB41, 0x90D8FB41, 0x90D9FB41, 0x90DAFB41, 0x90DBFB41, 0x90DCFB41, 0x90DDFB41, 0x90DEFB41, 0x90DFFB41, 0x90E0FB41, 0x90E1FB41, 0x90E2FB41, 0x90E3FB41, 0x90E4FB41, 0x90E5FB41, 0x90E6FB41, 0x90E7FB41, 0x90E8FB41, 0x90E9FB41, 0x90EAFB41, 0x90EBFB41, 0x90ECFB41, 0x90EDFB41, 0x90EEFB41, 0x90EFFB41, 0x90F0FB41, 0x90F1FB41, 0x90F2FB41, 0x90F3FB41, 0x90F4FB41, 0x90F5FB41, 0x90F6FB41, 0x90F7FB41, 0x90F8FB41, 0x90F9FB41, 0x90FAFB41, 0x90FBFB41, 0x90FCFB41, 0x90FDFB41, 0x90FEFB41, 0x90FFFB41, 0x9100FB41, 0x9101FB41, 0x9102FB41, 0x9103FB41, 0x9104FB41, 0x9105FB41, 0x9106FB41, 0x9107FB41, 0x9108FB41, 0x9109FB41, 0x910AFB41, 0x910BFB41, 0x910CFB41, 0x910DFB41, 0x910EFB41, 0x910FFB41, 0x9110FB41, 0x9111FB41, 0x9112FB41, 0x9113FB41, 0x9114FB41, 0x9115FB41, 0x9116FB41, 0x9117FB41, 0x9118FB41, 0x9119FB41, 0x911AFB41, 0x911BFB41, 0x911CFB41, 0x911DFB41, 0x911EFB41, 0x911FFB41, 0x9120FB41, 0x9121FB41, 0x9122FB41, 0x9123FB41, 0x9124FB41, 0x9125FB41, 0x9126FB41, 0x9127FB41, 0x9128FB41, 0x9129FB41, 0x912AFB41, 0x912BFB41, 0x912CFB41, 0x912DFB41, /* 9084 */
+ 0x912EFB41, 0x912FFB41, 0x9130FB41, 0x9131FB41, 0x9132FB41, 0x9133FB41, 0x9134FB41, 0x9135FB41, 0x9136FB41, 0x9137FB41, 0x9138FB41, 0x9139FB41, 0x913AFB41, 0x913BFB41, 0x913CFB41, 0x913DFB41, 0x913EFB41, 0x913FFB41, 0x9140FB41, 0x9141FB41, 0x9142FB41, 0x9143FB41, 0x9144FB41, 0x9145FB41, 0x9146FB41, 0x9147FB41, 0x9148FB41, 0x9149FB41, 0x914AFB41, 0x914BFB41, 0x914CFB41, 0x914DFB41, 0x914EFB41, 0x914FFB41, 0x9150FB41, 0x9151FB41, 0x9152FB41, 0x9153FB41, 0x9154FB41, 0x9155FB41, 0x9156FB41, 0x9157FB41, 0x9158FB41, 0x9159FB41, 0x915AFB41, 0x915BFB41, 0x915CFB41, 0x915DFB41, 0x915EFB41, 0x915FFB41, 0x9160FB41, 0x9161FB41, 0x9162FB41, 0x9163FB41, 0x9164FB41, 0x9165FB41, 0x9166FB41, 0x9167FB41, 0x9168FB41, 0x9169FB41, 0x916AFB41, 0x916BFB41, 0x916CFB41, 0x916DFB41, 0x916EFB41, 0x916FFB41, 0x9170FB41, 0x9171FB41, 0x9172FB41, 0x9173FB41, 0x9174FB41, 0x9175FB41, 0x9176FB41, 0x9177FB41, 0x9178FB41, 0x9179FB41, 0x917AFB41, 0x917BFB41, 0x917CFB41, 0x917DFB41, 0x917EFB41, 0x917FFB41, 0x9180FB41, 0x9181FB41, 0x9182FB41, 0x9183FB41, 0x9184FB41, 0x9185FB41, 0x9186FB41, 0x9187FB41, 0x9188FB41, 0x9189FB41, 0x918AFB41, 0x918BFB41, 0x918CFB41, 0x918DFB41, 0x918EFB41, 0x918FFB41, 0x9190FB41, 0x9191FB41, 0x9192FB41, 0x9193FB41, 0x9194FB41, 0x9195FB41, 0x9196FB41, 0x9197FB41, 0x9198FB41, 0x9199FB41, 0x919AFB41, 0x919BFB41, 0x919CFB41, 0x919DFB41, 0x919EFB41, 0x919FFB41, 0x91A0FB41, 0x91A1FB41, 0x91A2FB41, 0x91A3FB41, 0x91A4FB41, 0x91A5FB41, 0x91A6FB41, 0x91A7FB41, 0x91A8FB41, 0x91A9FB41, 0x91AAFB41, 0x91ABFB41, 0x91ACFB41, 0x91ADFB41, 0x91AEFB41, 0x91AFFB41, 0x91B0FB41, 0x91B1FB41, 0x91B2FB41, 0x91B3FB41, 0x91B4FB41, 0x91B5FB41, 0x91B6FB41, 0x91B7FB41, 0x91B8FB41, 0x91B9FB41, 0x91BAFB41, 0x91BBFB41, 0x91BCFB41, 0x91BDFB41, 0x91BEFB41, 0x91BFFB41, 0x91C0FB41, 0x91C1FB41, 0x91C2FB41, 0x91C3FB41, 0x91C4FB41, 0x91C5FB41, 0x91C6FB41, 0x91C7FB41, 0x91C8FB41, 0x91C9FB41, 0x91CAFB41, 0x91CBFB41, 0x91CCFB41, 0x91CDFB41, 0x91CEFB41, 0x91CFFB41, 0x91D0FB41, 0x91D1FB41, 0x91D2FB41, 0x91D3FB41, 0x91D4FB41, 0x91D5FB41, 0x91D6FB41, 0x91D7FB41, /* 912E */
+ 0x91D8FB41, 0x91D9FB41, 0x91DAFB41, 0x91DBFB41, 0x91DCFB41, 0x91DDFB41, 0x91DEFB41, 0x91DFFB41, 0x91E0FB41, 0x91E1FB41, 0x91E2FB41, 0x91E3FB41, 0x91E4FB41, 0x91E5FB41, 0x91E6FB41, 0x91E7FB41, 0x91E8FB41, 0x91E9FB41, 0x91EAFB41, 0x91EBFB41, 0x91ECFB41, 0x91EDFB41, 0x91EEFB41, 0x91EFFB41, 0x91F0FB41, 0x91F1FB41, 0x91F2FB41, 0x91F3FB41, 0x91F4FB41, 0x91F5FB41, 0x91F6FB41, 0x91F7FB41, 0x91F8FB41, 0x91F9FB41, 0x91FAFB41, 0x91FBFB41, 0x91FCFB41, 0x91FDFB41, 0x91FEFB41, 0x91FFFB41, 0x9200FB41, 0x9201FB41, 0x9202FB41, 0x9203FB41, 0x9204FB41, 0x9205FB41, 0x9206FB41, 0x9207FB41, 0x9208FB41, 0x9209FB41, 0x920AFB41, 0x920BFB41, 0x920CFB41, 0x920DFB41, 0x920EFB41, 0x920FFB41, 0x9210FB41, 0x9211FB41, 0x9212FB41, 0x9213FB41, 0x9214FB41, 0x9215FB41, 0x9216FB41, 0x9217FB41, 0x9218FB41, 0x9219FB41, 0x921AFB41, 0x921BFB41, 0x921CFB41, 0x921DFB41, 0x921EFB41, 0x921FFB41, 0x9220FB41, 0x9221FB41, 0x9222FB41, 0x9223FB41, 0x9224FB41, 0x9225FB41, 0x9226FB41, 0x9227FB41, 0x9228FB41, 0x9229FB41, 0x922AFB41, 0x922BFB41, 0x922CFB41, 0x922DFB41, 0x922EFB41, 0x922FFB41, 0x9230FB41, 0x9231FB41, 0x9232FB41, 0x9233FB41, 0x9234FB41, 0x9235FB41, 0x9236FB41, 0x9237FB41, 0x9238FB41, 0x9239FB41, 0x923AFB41, 0x923BFB41, 0x923CFB41, 0x923DFB41, 0x923EFB41, 0x923FFB41, 0x9240FB41, 0x9241FB41, 0x9242FB41, 0x9243FB41, 0x9244FB41, 0x9245FB41, 0x9246FB41, 0x9247FB41, 0x9248FB41, 0x9249FB41, 0x924AFB41, 0x924BFB41, 0x924CFB41, 0x924DFB41, 0x924EFB41, 0x924FFB41, 0x9250FB41, 0x9251FB41, 0x9252FB41, 0x9253FB41, 0x9254FB41, 0x9255FB41, 0x9256FB41, 0x9257FB41, 0x9258FB41, 0x9259FB41, 0x925AFB41, 0x925BFB41, 0x925CFB41, 0x925DFB41, 0x925EFB41, 0x925FFB41, 0x9260FB41, 0x9261FB41, 0x9262FB41, 0x9263FB41, 0x9264FB41, 0x9265FB41, 0x9266FB41, 0x9267FB41, 0x9268FB41, 0x9269FB41, 0x926AFB41, 0x926BFB41, 0x926CFB41, 0x926DFB41, 0x926EFB41, 0x926FFB41, 0x9270FB41, 0x9271FB41, 0x9272FB41, 0x9273FB41, 0x9274FB41, 0x9275FB41, 0x9276FB41, 0x9277FB41, 0x9278FB41, 0x9279FB41, 0x927AFB41, 0x927BFB41, 0x927CFB41, 0x927DFB41, 0x927EFB41, 0x927FFB41, 0x9280FB41, 0x9281FB41, /* 91D8 */
+ 0x9282FB41, 0x9283FB41, 0x9284FB41, 0x9285FB41, 0x9286FB41, 0x9287FB41, 0x9288FB41, 0x9289FB41, 0x928AFB41, 0x928BFB41, 0x928CFB41, 0x928DFB41, 0x928EFB41, 0x928FFB41, 0x9290FB41, 0x9291FB41, 0x9292FB41, 0x9293FB41, 0x9294FB41, 0x9295FB41, 0x9296FB41, 0x9297FB41, 0x9298FB41, 0x9299FB41, 0x929AFB41, 0x929BFB41, 0x929CFB41, 0x929DFB41, 0x929EFB41, 0x929FFB41, 0x92A0FB41, 0x92A1FB41, 0x92A2FB41, 0x92A3FB41, 0x92A4FB41, 0x92A5FB41, 0x92A6FB41, 0x92A7FB41, 0x92A8FB41, 0x92A9FB41, 0x92AAFB41, 0x92ABFB41, 0x92ACFB41, 0x92ADFB41, 0x92AEFB41, 0x92AFFB41, 0x92B0FB41, 0x92B1FB41, 0x92B2FB41, 0x92B3FB41, 0x92B4FB41, 0x92B5FB41, 0x92B6FB41, 0x92B7FB41, 0x92B8FB41, 0x92B9FB41, 0x92BAFB41, 0x92BBFB41, 0x92BCFB41, 0x92BDFB41, 0x92BEFB41, 0x92BFFB41, 0x92C0FB41, 0x92C1FB41, 0x92C2FB41, 0x92C3FB41, 0x92C4FB41, 0x92C5FB41, 0x92C6FB41, 0x92C7FB41, 0x92C8FB41, 0x92C9FB41, 0x92CAFB41, 0x92CBFB41, 0x92CCFB41, 0x92CDFB41, 0x92CEFB41, 0x92CFFB41, 0x92D0FB41, 0x92D1FB41, 0x92D2FB41, 0x92D3FB41, 0x92D4FB41, 0x92D5FB41, 0x92D6FB41, 0x92D7FB41, 0x92D8FB41, 0x92D9FB41, 0x92DAFB41, 0x92DBFB41, 0x92DCFB41, 0x92DDFB41, 0x92DEFB41, 0x92DFFB41, 0x92E0FB41, 0x92E1FB41, 0x92E2FB41, 0x92E3FB41, 0x92E4FB41, 0x92E5FB41, 0x92E6FB41, 0x92E7FB41, 0x92E8FB41, 0x92E9FB41, 0x92EAFB41, 0x92EBFB41, 0x92ECFB41, 0x92EDFB41, 0x92EEFB41, 0x92EFFB41, 0x92F0FB41, 0x92F1FB41, 0x92F2FB41, 0x92F3FB41, 0x92F4FB41, 0x92F5FB41, 0x92F6FB41, 0x92F7FB41, 0x92F8FB41, 0x92F9FB41, 0x92FAFB41, 0x92FBFB41, 0x92FCFB41, 0x92FDFB41, 0x92FEFB41, 0x92FFFB41, 0x9300FB41, 0x9301FB41, 0x9302FB41, 0x9303FB41, 0x9304FB41, 0x9305FB41, 0x9306FB41, 0x9307FB41, 0x9308FB41, 0x9309FB41, 0x930AFB41, 0x930BFB41, 0x930CFB41, 0x930DFB41, 0x930EFB41, 0x930FFB41, 0x9310FB41, 0x9311FB41, 0x9312FB41, 0x9313FB41, 0x9314FB41, 0x9315FB41, 0x9316FB41, 0x9317FB41, 0x9318FB41, 0x9319FB41, 0x931AFB41, 0x931BFB41, 0x931CFB41, 0x931DFB41, 0x931EFB41, 0x931FFB41, 0x9320FB41, 0x9321FB41, 0x9322FB41, 0x9323FB41, 0x9324FB41, 0x9325FB41, 0x9326FB41, 0x9327FB41, 0x9328FB41, 0x9329FB41, 0x932AFB41, 0x932BFB41, /* 9282 */
+ 0x932CFB41, 0x932DFB41, 0x932EFB41, 0x932FFB41, 0x9330FB41, 0x9331FB41, 0x9332FB41, 0x9333FB41, 0x9334FB41, 0x9335FB41, 0x9336FB41, 0x9337FB41, 0x9338FB41, 0x9339FB41, 0x933AFB41, 0x933BFB41, 0x933CFB41, 0x933DFB41, 0x933EFB41, 0x933FFB41, 0x9340FB41, 0x9341FB41, 0x9342FB41, 0x9343FB41, 0x9344FB41, 0x9345FB41, 0x9346FB41, 0x9347FB41, 0x9348FB41, 0x9349FB41, 0x934AFB41, 0x934BFB41, 0x934CFB41, 0x934DFB41, 0x934EFB41, 0x934FFB41, 0x9350FB41, 0x9351FB41, 0x9352FB41, 0x9353FB41, 0x9354FB41, 0x9355FB41, 0x9356FB41, 0x9357FB41, 0x9358FB41, 0x9359FB41, 0x935AFB41, 0x935BFB41, 0x935CFB41, 0x935DFB41, 0x935EFB41, 0x935FFB41, 0x9360FB41, 0x9361FB41, 0x9362FB41, 0x9363FB41, 0x9364FB41, 0x9365FB41, 0x9366FB41, 0x9367FB41, 0x9368FB41, 0x9369FB41, 0x936AFB41, 0x936BFB41, 0x936CFB41, 0x936DFB41, 0x936EFB41, 0x936FFB41, 0x9370FB41, 0x9371FB41, 0x9372FB41, 0x9373FB41, 0x9374FB41, 0x9375FB41, 0x9376FB41, 0x9377FB41, 0x9378FB41, 0x9379FB41, 0x937AFB41, 0x937BFB41, 0x937CFB41, 0x937DFB41, 0x937EFB41, 0x937FFB41, 0x9380FB41, 0x9381FB41, 0x9382FB41, 0x9383FB41, 0x9384FB41, 0x9385FB41, 0x9386FB41, 0x9387FB41, 0x9388FB41, 0x9389FB41, 0x938AFB41, 0x938BFB41, 0x938CFB41, 0x938DFB41, 0x938EFB41, 0x938FFB41, 0x9390FB41, 0x9391FB41, 0x9392FB41, 0x9393FB41, 0x9394FB41, 0x9395FB41, 0x9396FB41, 0x9397FB41, 0x9398FB41, 0x9399FB41, 0x939AFB41, 0x939BFB41, 0x939CFB41, 0x939DFB41, 0x939EFB41, 0x939FFB41, 0x93A0FB41, 0x93A1FB41, 0x93A2FB41, 0x93A3FB41, 0x93A4FB41, 0x93A5FB41, 0x93A6FB41, 0x93A7FB41, 0x93A8FB41, 0x93A9FB41, 0x93AAFB41, 0x93ABFB41, 0x93ACFB41, 0x93ADFB41, 0x93AEFB41, 0x93AFFB41, 0x93B0FB41, 0x93B1FB41, 0x93B2FB41, 0x93B3FB41, 0x93B4FB41, 0x93B5FB41, 0x93B6FB41, 0x93B7FB41, 0x93B8FB41, 0x93B9FB41, 0x93BAFB41, 0x93BBFB41, 0x93BCFB41, 0x93BDFB41, 0x93BEFB41, 0x93BFFB41, 0x93C0FB41, 0x93C1FB41, 0x93C2FB41, 0x93C3FB41, 0x93C4FB41, 0x93C5FB41, 0x93C6FB41, 0x93C7FB41, 0x93C8FB41, 0x93C9FB41, 0x93CAFB41, 0x93CBFB41, 0x93CCFB41, 0x93CDFB41, 0x93CEFB41, 0x93CFFB41, 0x93D0FB41, 0x93D1FB41, 0x93D2FB41, 0x93D3FB41, 0x93D4FB41, 0x93D5FB41, /* 932C */
+ 0x93D6FB41, 0x93D7FB41, 0x93D8FB41, 0x93D9FB41, 0x93DAFB41, 0x93DBFB41, 0x93DCFB41, 0x93DDFB41, 0x93DEFB41, 0x93DFFB41, 0x93E0FB41, 0x93E1FB41, 0x93E2FB41, 0x93E3FB41, 0x93E4FB41, 0x93E5FB41, 0x93E6FB41, 0x93E7FB41, 0x93E8FB41, 0x93E9FB41, 0x93EAFB41, 0x93EBFB41, 0x93ECFB41, 0x93EDFB41, 0x93EEFB41, 0x93EFFB41, 0x93F0FB41, 0x93F1FB41, 0x93F2FB41, 0x93F3FB41, 0x93F4FB41, 0x93F5FB41, 0x93F6FB41, 0x93F7FB41, 0x93F8FB41, 0x93F9FB41, 0x93FAFB41, 0x93FBFB41, 0x93FCFB41, 0x93FDFB41, 0x93FEFB41, 0x93FFFB41, 0x9400FB41, 0x9401FB41, 0x9402FB41, 0x9403FB41, 0x9404FB41, 0x9405FB41, 0x9406FB41, 0x9407FB41, 0x9408FB41, 0x9409FB41, 0x940AFB41, 0x940BFB41, 0x940CFB41, 0x940DFB41, 0x940EFB41, 0x940FFB41, 0x9410FB41, 0x9411FB41, 0x9412FB41, 0x9413FB41, 0x9414FB41, 0x9415FB41, 0x9416FB41, 0x9417FB41, 0x9418FB41, 0x9419FB41, 0x941AFB41, 0x941BFB41, 0x941CFB41, 0x941DFB41, 0x941EFB41, 0x941FFB41, 0x9420FB41, 0x9421FB41, 0x9422FB41, 0x9423FB41, 0x9424FB41, 0x9425FB41, 0x9426FB41, 0x9427FB41, 0x9428FB41, 0x9429FB41, 0x942AFB41, 0x942BFB41, 0x942CFB41, 0x942DFB41, 0x942EFB41, 0x942FFB41, 0x9430FB41, 0x9431FB41, 0x9432FB41, 0x9433FB41, 0x9434FB41, 0x9435FB41, 0x9436FB41, 0x9437FB41, 0x9438FB41, 0x9439FB41, 0x943AFB41, 0x943BFB41, 0x943CFB41, 0x943DFB41, 0x943EFB41, 0x943FFB41, 0x9440FB41, 0x9441FB41, 0x9442FB41, 0x9443FB41, 0x9444FB41, 0x9445FB41, 0x9446FB41, 0x9447FB41, 0x9448FB41, 0x9449FB41, 0x944AFB41, 0x944BFB41, 0x944CFB41, 0x944DFB41, 0x944EFB41, 0x944FFB41, 0x9450FB41, 0x9451FB41, 0x9452FB41, 0x9453FB41, 0x9454FB41, 0x9455FB41, 0x9456FB41, 0x9457FB41, 0x9458FB41, 0x9459FB41, 0x945AFB41, 0x945BFB41, 0x945CFB41, 0x945DFB41, 0x945EFB41, 0x945FFB41, 0x9460FB41, 0x9461FB41, 0x9462FB41, 0x9463FB41, 0x9464FB41, 0x9465FB41, 0x9466FB41, 0x9467FB41, 0x9468FB41, 0x9469FB41, 0x946AFB41, 0x946BFB41, 0x946CFB41, 0x946DFB41, 0x946EFB41, 0x946FFB41, 0x9470FB41, 0x9471FB41, 0x9472FB41, 0x9473FB41, 0x9474FB41, 0x9475FB41, 0x9476FB41, 0x9477FB41, 0x9478FB41, 0x9479FB41, 0x947AFB41, 0x947BFB41, 0x947CFB41, 0x947DFB41, 0x947EFB41, 0x947FFB41, /* 93D6 */
+ 0x9480FB41, 0x9481FB41, 0x9482FB41, 0x9483FB41, 0x9484FB41, 0x9485FB41, 0x9486FB41, 0x9487FB41, 0x9488FB41, 0x9489FB41, 0x948AFB41, 0x948BFB41, 0x948CFB41, 0x948DFB41, 0x948EFB41, 0x948FFB41, 0x9490FB41, 0x9491FB41, 0x9492FB41, 0x9493FB41, 0x9494FB41, 0x9495FB41, 0x9496FB41, 0x9497FB41, 0x9498FB41, 0x9499FB41, 0x949AFB41, 0x949BFB41, 0x949CFB41, 0x949DFB41, 0x949EFB41, 0x949FFB41, 0x94A0FB41, 0x94A1FB41, 0x94A2FB41, 0x94A3FB41, 0x94A4FB41, 0x94A5FB41, 0x94A6FB41, 0x94A7FB41, 0x94A8FB41, 0x94A9FB41, 0x94AAFB41, 0x94ABFB41, 0x94ACFB41, 0x94ADFB41, 0x94AEFB41, 0x94AFFB41, 0x94B0FB41, 0x94B1FB41, 0x94B2FB41, 0x94B3FB41, 0x94B4FB41, 0x94B5FB41, 0x94B6FB41, 0x94B7FB41, 0x94B8FB41, 0x94B9FB41, 0x94BAFB41, 0x94BBFB41, 0x94BCFB41, 0x94BDFB41, 0x94BEFB41, 0x94BFFB41, 0x94C0FB41, 0x94C1FB41, 0x94C2FB41, 0x94C3FB41, 0x94C4FB41, 0x94C5FB41, 0x94C6FB41, 0x94C7FB41, 0x94C8FB41, 0x94C9FB41, 0x94CAFB41, 0x94CBFB41, 0x94CCFB41, 0x94CDFB41, 0x94CEFB41, 0x94CFFB41, 0x94D0FB41, 0x94D1FB41, 0x94D2FB41, 0x94D3FB41, 0x94D4FB41, 0x94D5FB41, 0x94D6FB41, 0x94D7FB41, 0x94D8FB41, 0x94D9FB41, 0x94DAFB41, 0x94DBFB41, 0x94DCFB41, 0x94DDFB41, 0x94DEFB41, 0x94DFFB41, 0x94E0FB41, 0x94E1FB41, 0x94E2FB41, 0x94E3FB41, 0x94E4FB41, 0x94E5FB41, 0x94E6FB41, 0x94E7FB41, 0x94E8FB41, 0x94E9FB41, 0x94EAFB41, 0x94EBFB41, 0x94ECFB41, 0x94EDFB41, 0x94EEFB41, 0x94EFFB41, 0x94F0FB41, 0x94F1FB41, 0x94F2FB41, 0x94F3FB41, 0x94F4FB41, 0x94F5FB41, 0x94F6FB41, 0x94F7FB41, 0x94F8FB41, 0x94F9FB41, 0x94FAFB41, 0x94FBFB41, 0x94FCFB41, 0x94FDFB41, 0x94FEFB41, 0x94FFFB41, 0x9500FB41, 0x9501FB41, 0x9502FB41, 0x9503FB41, 0x9504FB41, 0x9505FB41, 0x9506FB41, 0x9507FB41, 0x9508FB41, 0x9509FB41, 0x950AFB41, 0x950BFB41, 0x950CFB41, 0x950DFB41, 0x950EFB41, 0x950FFB41, 0x9510FB41, 0x9511FB41, 0x9512FB41, 0x9513FB41, 0x9514FB41, 0x9515FB41, 0x9516FB41, 0x9517FB41, 0x9518FB41, 0x9519FB41, 0x951AFB41, 0x951BFB41, 0x951CFB41, 0x951DFB41, 0x951EFB41, 0x951FFB41, 0x9520FB41, 0x9521FB41, 0x9522FB41, 0x9523FB41, 0x9524FB41, 0x9525FB41, 0x9526FB41, 0x9527FB41, 0x9528FB41, 0x9529FB41, /* 9480 */
+ 0x952AFB41, 0x952BFB41, 0x952CFB41, 0x952DFB41, 0x952EFB41, 0x952FFB41, 0x9530FB41, 0x9531FB41, 0x9532FB41, 0x9533FB41, 0x9534FB41, 0x9535FB41, 0x9536FB41, 0x9537FB41, 0x9538FB41, 0x9539FB41, 0x953AFB41, 0x953BFB41, 0x953CFB41, 0x953DFB41, 0x953EFB41, 0x953FFB41, 0x9540FB41, 0x9541FB41, 0x9542FB41, 0x9543FB41, 0x9544FB41, 0x9545FB41, 0x9546FB41, 0x9547FB41, 0x9548FB41, 0x9549FB41, 0x954AFB41, 0x954BFB41, 0x954CFB41, 0x954DFB41, 0x954EFB41, 0x954FFB41, 0x9550FB41, 0x9551FB41, 0x9552FB41, 0x9553FB41, 0x9554FB41, 0x9555FB41, 0x9556FB41, 0x9557FB41, 0x9558FB41, 0x9559FB41, 0x955AFB41, 0x955BFB41, 0x955CFB41, 0x955DFB41, 0x955EFB41, 0x955FFB41, 0x9560FB41, 0x9561FB41, 0x9562FB41, 0x9563FB41, 0x9564FB41, 0x9565FB41, 0x9566FB41, 0x9567FB41, 0x9568FB41, 0x9569FB41, 0x956AFB41, 0x956BFB41, 0x956CFB41, 0x956DFB41, 0x956EFB41, 0x956FFB41, 0x9570FB41, 0x9571FB41, 0x9572FB41, 0x9573FB41, 0x9574FB41, 0x9575FB41, 0x9576FB41, 0x9577FB41, 0x9578FB41, 0x9579FB41, 0x957AFB41, 0x957BFB41, 0x957CFB41, 0x957DFB41, 0x957EFB41, 0x957FFB41, 0x9580FB41, 0x9581FB41, 0x9582FB41, 0x9583FB41, 0x9584FB41, 0x9585FB41, 0x9586FB41, 0x9587FB41, 0x9588FB41, 0x9589FB41, 0x958AFB41, 0x958BFB41, 0x958CFB41, 0x958DFB41, 0x958EFB41, 0x958FFB41, 0x9590FB41, 0x9591FB41, 0x9592FB41, 0x9593FB41, 0x9594FB41, 0x9595FB41, 0x9596FB41, 0x9597FB41, 0x9598FB41, 0x9599FB41, 0x959AFB41, 0x959BFB41, 0x959CFB41, 0x959DFB41, 0x959EFB41, 0x959FFB41, 0x95A0FB41, 0x95A1FB41, 0x95A2FB41, 0x95A3FB41, 0x95A4FB41, 0x95A5FB41, 0x95A6FB41, 0x95A7FB41, 0x95A8FB41, 0x95A9FB41, 0x95AAFB41, 0x95ABFB41, 0x95ACFB41, 0x95ADFB41, 0x95AEFB41, 0x95AFFB41, 0x95B0FB41, 0x95B1FB41, 0x95B2FB41, 0x95B3FB41, 0x95B4FB41, 0x95B5FB41, 0x95B6FB41, 0x95B7FB41, 0x95B8FB41, 0x95B9FB41, 0x95BAFB41, 0x95BBFB41, 0x95BCFB41, 0x95BDFB41, 0x95BEFB41, 0x95BFFB41, 0x95C0FB41, 0x95C1FB41, 0x95C2FB41, 0x95C3FB41, 0x95C4FB41, 0x95C5FB41, 0x95C6FB41, 0x95C7FB41, 0x95C8FB41, 0x95C9FB41, 0x95CAFB41, 0x95CBFB41, 0x95CCFB41, 0x95CDFB41, 0x95CEFB41, 0x95CFFB41, 0x95D0FB41, 0x95D1FB41, 0x95D2FB41, 0x95D3FB41, /* 952A */
+ 0x95D4FB41, 0x95D5FB41, 0x95D6FB41, 0x95D7FB41, 0x95D8FB41, 0x95D9FB41, 0x95DAFB41, 0x95DBFB41, 0x95DCFB41, 0x95DDFB41, 0x95DEFB41, 0x95DFFB41, 0x95E0FB41, 0x95E1FB41, 0x95E2FB41, 0x95E3FB41, 0x95E4FB41, 0x95E5FB41, 0x95E6FB41, 0x95E7FB41, 0x95E8FB41, 0x95E9FB41, 0x95EAFB41, 0x95EBFB41, 0x95ECFB41, 0x95EDFB41, 0x95EEFB41, 0x95EFFB41, 0x95F0FB41, 0x95F1FB41, 0x95F2FB41, 0x95F3FB41, 0x95F4FB41, 0x95F5FB41, 0x95F6FB41, 0x95F7FB41, 0x95F8FB41, 0x95F9FB41, 0x95FAFB41, 0x95FBFB41, 0x95FCFB41, 0x95FDFB41, 0x95FEFB41, 0x95FFFB41, 0x9600FB41, 0x9601FB41, 0x9602FB41, 0x9603FB41, 0x9604FB41, 0x9605FB41, 0x9606FB41, 0x9607FB41, 0x9608FB41, 0x9609FB41, 0x960AFB41, 0x960BFB41, 0x960CFB41, 0x960DFB41, 0x960EFB41, 0x960FFB41, 0x9610FB41, 0x9611FB41, 0x9612FB41, 0x9613FB41, 0x9614FB41, 0x9615FB41, 0x9616FB41, 0x9617FB41, 0x9618FB41, 0x9619FB41, 0x961AFB41, 0x961BFB41, 0x961CFB41, 0x961DFB41, 0x961EFB41, 0x961FFB41, 0x9620FB41, 0x9621FB41, 0x9622FB41, 0x9623FB41, 0x9624FB41, 0x9625FB41, 0x9626FB41, 0x9627FB41, 0x9628FB41, 0x9629FB41, 0x962AFB41, 0x962BFB41, 0x962CFB41, 0x962DFB41, 0x962EFB41, 0x962FFB41, 0x9630FB41, 0x9631FB41, 0x9632FB41, 0x9633FB41, 0x9634FB41, 0x9635FB41, 0x9636FB41, 0x9637FB41, 0x9638FB41, 0x9639FB41, 0x963AFB41, 0x963BFB41, 0x963CFB41, 0x963DFB41, 0x963EFB41, 0x963FFB41, 0x9640FB41, 0x9641FB41, 0x9642FB41, 0x9643FB41, 0x9644FB41, 0x9645FB41, 0x9646FB41, 0x9647FB41, 0x9648FB41, 0x9649FB41, 0x964AFB41, 0x964BFB41, 0x964CFB41, 0x964DFB41, 0x964EFB41, 0x964FFB41, 0x9650FB41, 0x9651FB41, 0x9652FB41, 0x9653FB41, 0x9654FB41, 0x9655FB41, 0x9656FB41, 0x9657FB41, 0x9658FB41, 0x9659FB41, 0x965AFB41, 0x965BFB41, 0x965CFB41, 0x965DFB41, 0x965EFB41, 0x965FFB41, 0x9660FB41, 0x9661FB41, 0x9662FB41, 0x9663FB41, 0x9664FB41, 0x9665FB41, 0x9666FB41, 0x9667FB41, 0x9668FB41, 0x9669FB41, 0x966AFB41, 0x966BFB41, 0x966CFB41, 0x966DFB41, 0x966EFB41, 0x966FFB41, 0x9670FB41, 0x9671FB41, 0x9672FB41, 0x9673FB41, 0x9674FB41, 0x9675FB41, 0x9676FB41, 0x9677FB41, 0x9678FB41, 0x9679FB41, 0x967AFB41, 0x967BFB41, 0x967CFB41, 0x967DFB41, /* 95D4 */
+ 0x967EFB41, 0x967FFB41, 0x9680FB41, 0x9681FB41, 0x9682FB41, 0x9683FB41, 0x9684FB41, 0x9685FB41, 0x9686FB41, 0x9687FB41, 0x9688FB41, 0x9689FB41, 0x968AFB41, 0x968BFB41, 0x968CFB41, 0x968DFB41, 0x968EFB41, 0x968FFB41, 0x9690FB41, 0x9691FB41, 0x9692FB41, 0x9693FB41, 0x9694FB41, 0x9695FB41, 0x9696FB41, 0x9697FB41, 0x9698FB41, 0x9699FB41, 0x969AFB41, 0x969BFB41, 0x969CFB41, 0x969DFB41, 0x969EFB41, 0x969FFB41, 0x96A0FB41, 0x96A1FB41, 0x96A2FB41, 0x96A3FB41, 0x96A4FB41, 0x96A5FB41, 0x96A6FB41, 0x96A7FB41, 0x96A8FB41, 0x96A9FB41, 0x96AAFB41, 0x96ABFB41, 0x96ACFB41, 0x96ADFB41, 0x96AEFB41, 0x96AFFB41, 0x96B0FB41, 0x96B1FB41, 0x96B2FB41, 0x96B3FB41, 0x96B4FB41, 0x96B5FB41, 0x96B6FB41, 0x96B7FB41, 0x96B8FB41, 0x96B9FB41, 0x96BAFB41, 0x96BBFB41, 0x96BCFB41, 0x96BDFB41, 0x96BEFB41, 0x96BFFB41, 0x96C0FB41, 0x96C1FB41, 0x96C2FB41, 0x96C3FB41, 0x96C4FB41, 0x96C5FB41, 0x96C6FB41, 0x96C7FB41, 0x96C8FB41, 0x96C9FB41, 0x96CAFB41, 0x96CBFB41, 0x96CCFB41, 0x96CDFB41, 0x96CEFB41, 0x96CFFB41, 0x96D0FB41, 0x96D1FB41, 0x96D2FB41, 0x96D3FB41, 0x96D4FB41, 0x96D5FB41, 0x96D6FB41, 0x96D7FB41, 0x96D8FB41, 0x96D9FB41, 0x96DAFB41, 0x96DBFB41, 0x96DCFB41, 0x96DDFB41, 0x96DEFB41, 0x96DFFB41, 0x96E0FB41, 0x96E1FB41, 0x96E2FB41, 0x96E3FB41, 0x96E4FB41, 0x96E5FB41, 0x96E6FB41, 0x96E7FB41, 0x96E8FB41, 0x96E9FB41, 0x96EAFB41, 0x96EBFB41, 0x96ECFB41, 0x96EDFB41, 0x96EEFB41, 0x96EFFB41, 0x96F0FB41, 0x96F1FB41, 0x96F2FB41, 0x96F3FB41, 0x96F4FB41, 0x96F5FB41, 0x96F6FB41, 0x96F7FB41, 0x96F8FB41, 0x96F9FB41, 0x96FAFB41, 0x96FBFB41, 0x96FCFB41, 0x96FDFB41, 0x96FEFB41, 0x96FFFB41, 0x9700FB41, 0x9701FB41, 0x9702FB41, 0x9703FB41, 0x9704FB41, 0x9705FB41, 0x9706FB41, 0x9707FB41, 0x9708FB41, 0x9709FB41, 0x970AFB41, 0x970BFB41, 0x970CFB41, 0x970DFB41, 0x970EFB41, 0x970FFB41, 0x9710FB41, 0x9711FB41, 0x9712FB41, 0x9713FB41, 0x9714FB41, 0x9715FB41, 0x9716FB41, 0x9717FB41, 0x9718FB41, 0x9719FB41, 0x971AFB41, 0x971BFB41, 0x971CFB41, 0x971DFB41, 0x971EFB41, 0x971FFB41, 0x9720FB41, 0x9721FB41, 0x9722FB41, 0x9723FB41, 0x9724FB41, 0x9725FB41, 0x9726FB41, 0x9727FB41, /* 967E */
+ 0x9728FB41, 0x9729FB41, 0x972AFB41, 0x972BFB41, 0x972CFB41, 0x972DFB41, 0x972EFB41, 0x972FFB41, 0x9730FB41, 0x9731FB41, 0x9732FB41, 0x9733FB41, 0x9734FB41, 0x9735FB41, 0x9736FB41, 0x9737FB41, 0x9738FB41, 0x9739FB41, 0x973AFB41, 0x973BFB41, 0x973CFB41, 0x973DFB41, 0x973EFB41, 0x973FFB41, 0x9740FB41, 0x9741FB41, 0x9742FB41, 0x9743FB41, 0x9744FB41, 0x9745FB41, 0x9746FB41, 0x9747FB41, 0x9748FB41, 0x9749FB41, 0x974AFB41, 0x974BFB41, 0x974CFB41, 0x974DFB41, 0x974EFB41, 0x974FFB41, 0x9750FB41, 0x9751FB41, 0x9752FB41, 0x9753FB41, 0x9754FB41, 0x9755FB41, 0x9756FB41, 0x9757FB41, 0x9758FB41, 0x9759FB41, 0x975AFB41, 0x975BFB41, 0x975CFB41, 0x975DFB41, 0x975EFB41, 0x975FFB41, 0x9760FB41, 0x9761FB41, 0x9762FB41, 0x9763FB41, 0x9764FB41, 0x9765FB41, 0x9766FB41, 0x9767FB41, 0x9768FB41, 0x9769FB41, 0x976AFB41, 0x976BFB41, 0x976CFB41, 0x976DFB41, 0x976EFB41, 0x976FFB41, 0x9770FB41, 0x9771FB41, 0x9772FB41, 0x9773FB41, 0x9774FB41, 0x9775FB41, 0x9776FB41, 0x9777FB41, 0x9778FB41, 0x9779FB41, 0x977AFB41, 0x977BFB41, 0x977CFB41, 0x977DFB41, 0x977EFB41, 0x977FFB41, 0x9780FB41, 0x9781FB41, 0x9782FB41, 0x9783FB41, 0x9784FB41, 0x9785FB41, 0x9786FB41, 0x9787FB41, 0x9788FB41, 0x9789FB41, 0x978AFB41, 0x978BFB41, 0x978CFB41, 0x978DFB41, 0x978EFB41, 0x978FFB41, 0x9790FB41, 0x9791FB41, 0x9792FB41, 0x9793FB41, 0x9794FB41, 0x9795FB41, 0x9796FB41, 0x9797FB41, 0x9798FB41, 0x9799FB41, 0x979AFB41, 0x979BFB41, 0x979CFB41, 0x979DFB41, 0x979EFB41, 0x979FFB41, 0x97A0FB41, 0x97A1FB41, 0x97A2FB41, 0x97A3FB41, 0x97A4FB41, 0x97A5FB41, 0x97A6FB41, 0x97A7FB41, 0x97A8FB41, 0x97A9FB41, 0x97AAFB41, 0x97ABFB41, 0x97ACFB41, 0x97ADFB41, 0x97AEFB41, 0x97AFFB41, 0x97B0FB41, 0x97B1FB41, 0x97B2FB41, 0x97B3FB41, 0x97B4FB41, 0x97B5FB41, 0x97B6FB41, 0x97B7FB41, 0x97B8FB41, 0x97B9FB41, 0x97BAFB41, 0x97BBFB41, 0x97BCFB41, 0x97BDFB41, 0x97BEFB41, 0x97BFFB41, 0x97C0FB41, 0x97C1FB41, 0x97C2FB41, 0x97C3FB41, 0x97C4FB41, 0x97C5FB41, 0x97C6FB41, 0x97C7FB41, 0x97C8FB41, 0x97C9FB41, 0x97CAFB41, 0x97CBFB41, 0x97CCFB41, 0x97CDFB41, 0x97CEFB41, 0x97CFFB41, 0x97D0FB41, 0x97D1FB41, /* 9728 */
+ 0x97D2FB41, 0x97D3FB41, 0x97D4FB41, 0x97D5FB41, 0x97D6FB41, 0x97D7FB41, 0x97D8FB41, 0x97D9FB41, 0x97DAFB41, 0x97DBFB41, 0x97DCFB41, 0x97DDFB41, 0x97DEFB41, 0x97DFFB41, 0x97E0FB41, 0x97E1FB41, 0x97E2FB41, 0x97E3FB41, 0x97E4FB41, 0x97E5FB41, 0x97E6FB41, 0x97E7FB41, 0x97E8FB41, 0x97E9FB41, 0x97EAFB41, 0x97EBFB41, 0x97ECFB41, 0x97EDFB41, 0x97EEFB41, 0x97EFFB41, 0x97F0FB41, 0x97F1FB41, 0x97F2FB41, 0x97F3FB41, 0x97F4FB41, 0x97F5FB41, 0x97F6FB41, 0x97F7FB41, 0x97F8FB41, 0x97F9FB41, 0x97FAFB41, 0x97FBFB41, 0x97FCFB41, 0x97FDFB41, 0x97FEFB41, 0x97FFFB41, 0x9800FB41, 0x9801FB41, 0x9802FB41, 0x9803FB41, 0x9804FB41, 0x9805FB41, 0x9806FB41, 0x9807FB41, 0x9808FB41, 0x9809FB41, 0x980AFB41, 0x980BFB41, 0x980CFB41, 0x980DFB41, 0x980EFB41, 0x980FFB41, 0x9810FB41, 0x9811FB41, 0x9812FB41, 0x9813FB41, 0x9814FB41, 0x9815FB41, 0x9816FB41, 0x9817FB41, 0x9818FB41, 0x9819FB41, 0x981AFB41, 0x981BFB41, 0x981CFB41, 0x981DFB41, 0x981EFB41, 0x981FFB41, 0x9820FB41, 0x9821FB41, 0x9822FB41, 0x9823FB41, 0x9824FB41, 0x9825FB41, 0x9826FB41, 0x9827FB41, 0x9828FB41, 0x9829FB41, 0x982AFB41, 0x982BFB41, 0x982CFB41, 0x982DFB41, 0x982EFB41, 0x982FFB41, 0x9830FB41, 0x9831FB41, 0x9832FB41, 0x9833FB41, 0x9834FB41, 0x9835FB41, 0x9836FB41, 0x9837FB41, 0x9838FB41, 0x9839FB41, 0x983AFB41, 0x983BFB41, 0x983CFB41, 0x983DFB41, 0x983EFB41, 0x983FFB41, 0x9840FB41, 0x9841FB41, 0x9842FB41, 0x9843FB41, 0x9844FB41, 0x9845FB41, 0x9846FB41, 0x9847FB41, 0x9848FB41, 0x9849FB41, 0x984AFB41, 0x984BFB41, 0x984CFB41, 0x984DFB41, 0x984EFB41, 0x984FFB41, 0x9850FB41, 0x9851FB41, 0x9852FB41, 0x9853FB41, 0x9854FB41, 0x9855FB41, 0x9856FB41, 0x9857FB41, 0x9858FB41, 0x9859FB41, 0x985AFB41, 0x985BFB41, 0x985CFB41, 0x985DFB41, 0x985EFB41, 0x985FFB41, 0x9860FB41, 0x9861FB41, 0x9862FB41, 0x9863FB41, 0x9864FB41, 0x9865FB41, 0x9866FB41, 0x9867FB41, 0x9868FB41, 0x9869FB41, 0x986AFB41, 0x986BFB41, 0x986CFB41, 0x986DFB41, 0x986EFB41, 0x986FFB41, 0x9870FB41, 0x9871FB41, 0x9872FB41, 0x9873FB41, 0x9874FB41, 0x9875FB41, 0x9876FB41, 0x9877FB41, 0x9878FB41, 0x9879FB41, 0x987AFB41, 0x987BFB41, /* 97D2 */
+ 0x987CFB41, 0x987DFB41, 0x987EFB41, 0x987FFB41, 0x9880FB41, 0x9881FB41, 0x9882FB41, 0x9883FB41, 0x9884FB41, 0x9885FB41, 0x9886FB41, 0x9887FB41, 0x9888FB41, 0x9889FB41, 0x988AFB41, 0x988BFB41, 0x988CFB41, 0x988DFB41, 0x988EFB41, 0x988FFB41, 0x9890FB41, 0x9891FB41, 0x9892FB41, 0x9893FB41, 0x9894FB41, 0x9895FB41, 0x9896FB41, 0x9897FB41, 0x9898FB41, 0x9899FB41, 0x989AFB41, 0x989BFB41, 0x989CFB41, 0x989DFB41, 0x989EFB41, 0x989FFB41, 0x98A0FB41, 0x98A1FB41, 0x98A2FB41, 0x98A3FB41, 0x98A4FB41, 0x98A5FB41, 0x98A6FB41, 0x98A7FB41, 0x98A8FB41, 0x98A9FB41, 0x98AAFB41, 0x98ABFB41, 0x98ACFB41, 0x98ADFB41, 0x98AEFB41, 0x98AFFB41, 0x98B0FB41, 0x98B1FB41, 0x98B2FB41, 0x98B3FB41, 0x98B4FB41, 0x98B5FB41, 0x98B6FB41, 0x98B7FB41, 0x98B8FB41, 0x98B9FB41, 0x98BAFB41, 0x98BBFB41, 0x98BCFB41, 0x98BDFB41, 0x98BEFB41, 0x98BFFB41, 0x98C0FB41, 0x98C1FB41, 0x98C2FB41, 0x98C3FB41, 0x98C4FB41, 0x98C5FB41, 0x98C6FB41, 0x98C7FB41, 0x98C8FB41, 0x98C9FB41, 0x98CAFB41, 0x98CBFB41, 0x98CCFB41, 0x98CDFB41, 0x98CEFB41, 0x98CFFB41, 0x98D0FB41, 0x98D1FB41, 0x98D2FB41, 0x98D3FB41, 0x98D4FB41, 0x98D5FB41, 0x98D6FB41, 0x98D7FB41, 0x98D8FB41, 0x98D9FB41, 0x98DAFB41, 0x98DBFB41, 0x98DCFB41, 0x98DDFB41, 0x98DEFB41, 0x98DFFB41, 0x98E0FB41, 0x98E1FB41, 0x98E2FB41, 0x98E3FB41, 0x98E4FB41, 0x98E5FB41, 0x98E6FB41, 0x98E7FB41, 0x98E8FB41, 0x98E9FB41, 0x98EAFB41, 0x98EBFB41, 0x98ECFB41, 0x98EDFB41, 0x98EEFB41, 0x98EFFB41, 0x98F0FB41, 0x98F1FB41, 0x98F2FB41, 0x98F3FB41, 0x98F4FB41, 0x98F5FB41, 0x98F6FB41, 0x98F7FB41, 0x98F8FB41, 0x98F9FB41, 0x98FAFB41, 0x98FBFB41, 0x98FCFB41, 0x98FDFB41, 0x98FEFB41, 0x98FFFB41, 0x9900FB41, 0x9901FB41, 0x9902FB41, 0x9903FB41, 0x9904FB41, 0x9905FB41, 0x9906FB41, 0x9907FB41, 0x9908FB41, 0x9909FB41, 0x990AFB41, 0x990BFB41, 0x990CFB41, 0x990DFB41, 0x990EFB41, 0x990FFB41, 0x9910FB41, 0x9911FB41, 0x9912FB41, 0x9913FB41, 0x9914FB41, 0x9915FB41, 0x9916FB41, 0x9917FB41, 0x9918FB41, 0x9919FB41, 0x991AFB41, 0x991BFB41, 0x991CFB41, 0x991DFB41, 0x991EFB41, 0x991FFB41, 0x9920FB41, 0x9921FB41, 0x9922FB41, 0x9923FB41, 0x9924FB41, 0x9925FB41, /* 987C */
+ 0x9926FB41, 0x9927FB41, 0x9928FB41, 0x9929FB41, 0x992AFB41, 0x992BFB41, 0x992CFB41, 0x992DFB41, 0x992EFB41, 0x992FFB41, 0x9930FB41, 0x9931FB41, 0x9932FB41, 0x9933FB41, 0x9934FB41, 0x9935FB41, 0x9936FB41, 0x9937FB41, 0x9938FB41, 0x9939FB41, 0x993AFB41, 0x993BFB41, 0x993CFB41, 0x993DFB41, 0x993EFB41, 0x993FFB41, 0x9940FB41, 0x9941FB41, 0x9942FB41, 0x9943FB41, 0x9944FB41, 0x9945FB41, 0x9946FB41, 0x9947FB41, 0x9948FB41, 0x9949FB41, 0x994AFB41, 0x994BFB41, 0x994CFB41, 0x994DFB41, 0x994EFB41, 0x994FFB41, 0x9950FB41, 0x9951FB41, 0x9952FB41, 0x9953FB41, 0x9954FB41, 0x9955FB41, 0x9956FB41, 0x9957FB41, 0x9958FB41, 0x9959FB41, 0x995AFB41, 0x995BFB41, 0x995CFB41, 0x995DFB41, 0x995EFB41, 0x995FFB41, 0x9960FB41, 0x9961FB41, 0x9962FB41, 0x9963FB41, 0x9964FB41, 0x9965FB41, 0x9966FB41, 0x9967FB41, 0x9968FB41, 0x9969FB41, 0x996AFB41, 0x996BFB41, 0x996CFB41, 0x996DFB41, 0x996EFB41, 0x996FFB41, 0x9970FB41, 0x9971FB41, 0x9972FB41, 0x9973FB41, 0x9974FB41, 0x9975FB41, 0x9976FB41, 0x9977FB41, 0x9978FB41, 0x9979FB41, 0x997AFB41, 0x997BFB41, 0x997CFB41, 0x997DFB41, 0x997EFB41, 0x997FFB41, 0x9980FB41, 0x9981FB41, 0x9982FB41, 0x9983FB41, 0x9984FB41, 0x9985FB41, 0x9986FB41, 0x9987FB41, 0x9988FB41, 0x9989FB41, 0x998AFB41, 0x998BFB41, 0x998CFB41, 0x998DFB41, 0x998EFB41, 0x998FFB41, 0x9990FB41, 0x9991FB41, 0x9992FB41, 0x9993FB41, 0x9994FB41, 0x9995FB41, 0x9996FB41, 0x9997FB41, 0x9998FB41, 0x9999FB41, 0x999AFB41, 0x999BFB41, 0x999CFB41, 0x999DFB41, 0x999EFB41, 0x999FFB41, 0x99A0FB41, 0x99A1FB41, 0x99A2FB41, 0x99A3FB41, 0x99A4FB41, 0x99A5FB41, 0x99A6FB41, 0x99A7FB41, 0x99A8FB41, 0x99A9FB41, 0x99AAFB41, 0x99ABFB41, 0x99ACFB41, 0x99ADFB41, 0x99AEFB41, 0x99AFFB41, 0x99B0FB41, 0x99B1FB41, 0x99B2FB41, 0x99B3FB41, 0x99B4FB41, 0x99B5FB41, 0x99B6FB41, 0x99B7FB41, 0x99B8FB41, 0x99B9FB41, 0x99BAFB41, 0x99BBFB41, 0x99BCFB41, 0x99BDFB41, 0x99BEFB41, 0x99BFFB41, 0x99C0FB41, 0x99C1FB41, 0x99C2FB41, 0x99C3FB41, 0x99C4FB41, 0x99C5FB41, 0x99C6FB41, 0x99C7FB41, 0x99C8FB41, 0x99C9FB41, 0x99CAFB41, 0x99CBFB41, 0x99CCFB41, 0x99CDFB41, 0x99CEFB41, 0x99CFFB41, /* 9926 */
+ 0x99D0FB41, 0x99D1FB41, 0x99D2FB41, 0x99D3FB41, 0x99D4FB41, 0x99D5FB41, 0x99D6FB41, 0x99D7FB41, 0x99D8FB41, 0x99D9FB41, 0x99DAFB41, 0x99DBFB41, 0x99DCFB41, 0x99DDFB41, 0x99DEFB41, 0x99DFFB41, 0x99E0FB41, 0x99E1FB41, 0x99E2FB41, 0x99E3FB41, 0x99E4FB41, 0x99E5FB41, 0x99E6FB41, 0x99E7FB41, 0x99E8FB41, 0x99E9FB41, 0x99EAFB41, 0x99EBFB41, 0x99ECFB41, 0x99EDFB41, 0x99EEFB41, 0x99EFFB41, 0x99F0FB41, 0x99F1FB41, 0x99F2FB41, 0x99F3FB41, 0x99F4FB41, 0x99F5FB41, 0x99F6FB41, 0x99F7FB41, 0x99F8FB41, 0x99F9FB41, 0x99FAFB41, 0x99FBFB41, 0x99FCFB41, 0x99FDFB41, 0x99FEFB41, 0x99FFFB41, 0x9A00FB41, 0x9A01FB41, 0x9A02FB41, 0x9A03FB41, 0x9A04FB41, 0x9A05FB41, 0x9A06FB41, 0x9A07FB41, 0x9A08FB41, 0x9A09FB41, 0x9A0AFB41, 0x9A0BFB41, 0x9A0CFB41, 0x9A0DFB41, 0x9A0EFB41, 0x9A0FFB41, 0x9A10FB41, 0x9A11FB41, 0x9A12FB41, 0x9A13FB41, 0x9A14FB41, 0x9A15FB41, 0x9A16FB41, 0x9A17FB41, 0x9A18FB41, 0x9A19FB41, 0x9A1AFB41, 0x9A1BFB41, 0x9A1CFB41, 0x9A1DFB41, 0x9A1EFB41, 0x9A1FFB41, 0x9A20FB41, 0x9A21FB41, 0x9A22FB41, 0x9A23FB41, 0x9A24FB41, 0x9A25FB41, 0x9A26FB41, 0x9A27FB41, 0x9A28FB41, 0x9A29FB41, 0x9A2AFB41, 0x9A2BFB41, 0x9A2CFB41, 0x9A2DFB41, 0x9A2EFB41, 0x9A2FFB41, 0x9A30FB41, 0x9A31FB41, 0x9A32FB41, 0x9A33FB41, 0x9A34FB41, 0x9A35FB41, 0x9A36FB41, 0x9A37FB41, 0x9A38FB41, 0x9A39FB41, 0x9A3AFB41, 0x9A3BFB41, 0x9A3CFB41, 0x9A3DFB41, 0x9A3EFB41, 0x9A3FFB41, 0x9A40FB41, 0x9A41FB41, 0x9A42FB41, 0x9A43FB41, 0x9A44FB41, 0x9A45FB41, 0x9A46FB41, 0x9A47FB41, 0x9A48FB41, 0x9A49FB41, 0x9A4AFB41, 0x9A4BFB41, 0x9A4CFB41, 0x9A4DFB41, 0x9A4EFB41, 0x9A4FFB41, 0x9A50FB41, 0x9A51FB41, 0x9A52FB41, 0x9A53FB41, 0x9A54FB41, 0x9A55FB41, 0x9A56FB41, 0x9A57FB41, 0x9A58FB41, 0x9A59FB41, 0x9A5AFB41, 0x9A5BFB41, 0x9A5CFB41, 0x9A5DFB41, 0x9A5EFB41, 0x9A5FFB41, 0x9A60FB41, 0x9A61FB41, 0x9A62FB41, 0x9A63FB41, 0x9A64FB41, 0x9A65FB41, 0x9A66FB41, 0x9A67FB41, 0x9A68FB41, 0x9A69FB41, 0x9A6AFB41, 0x9A6BFB41, 0x9A6CFB41, 0x9A6DFB41, 0x9A6EFB41, 0x9A6FFB41, 0x9A70FB41, 0x9A71FB41, 0x9A72FB41, 0x9A73FB41, 0x9A74FB41, 0x9A75FB41, 0x9A76FB41, 0x9A77FB41, 0x9A78FB41, 0x9A79FB41, /* 99D0 */
+ 0x9A7AFB41, 0x9A7BFB41, 0x9A7CFB41, 0x9A7DFB41, 0x9A7EFB41, 0x9A7FFB41, 0x9A80FB41, 0x9A81FB41, 0x9A82FB41, 0x9A83FB41, 0x9A84FB41, 0x9A85FB41, 0x9A86FB41, 0x9A87FB41, 0x9A88FB41, 0x9A89FB41, 0x9A8AFB41, 0x9A8BFB41, 0x9A8CFB41, 0x9A8DFB41, 0x9A8EFB41, 0x9A8FFB41, 0x9A90FB41, 0x9A91FB41, 0x9A92FB41, 0x9A93FB41, 0x9A94FB41, 0x9A95FB41, 0x9A96FB41, 0x9A97FB41, 0x9A98FB41, 0x9A99FB41, 0x9A9AFB41, 0x9A9BFB41, 0x9A9CFB41, 0x9A9DFB41, 0x9A9EFB41, 0x9A9FFB41, 0x9AA0FB41, 0x9AA1FB41, 0x9AA2FB41, 0x9AA3FB41, 0x9AA4FB41, 0x9AA5FB41, 0x9AA6FB41, 0x9AA7FB41, 0x9AA8FB41, 0x9AA9FB41, 0x9AAAFB41, 0x9AABFB41, 0x9AACFB41, 0x9AADFB41, 0x9AAEFB41, 0x9AAFFB41, 0x9AB0FB41, 0x9AB1FB41, 0x9AB2FB41, 0x9AB3FB41, 0x9AB4FB41, 0x9AB5FB41, 0x9AB6FB41, 0x9AB7FB41, 0x9AB8FB41, 0x9AB9FB41, 0x9ABAFB41, 0x9ABBFB41, 0x9ABCFB41, 0x9ABDFB41, 0x9ABEFB41, 0x9ABFFB41, 0x9AC0FB41, 0x9AC1FB41, 0x9AC2FB41, 0x9AC3FB41, 0x9AC4FB41, 0x9AC5FB41, 0x9AC6FB41, 0x9AC7FB41, 0x9AC8FB41, 0x9AC9FB41, 0x9ACAFB41, 0x9ACBFB41, 0x9ACCFB41, 0x9ACDFB41, 0x9ACEFB41, 0x9ACFFB41, 0x9AD0FB41, 0x9AD1FB41, 0x9AD2FB41, 0x9AD3FB41, 0x9AD4FB41, 0x9AD5FB41, 0x9AD6FB41, 0x9AD7FB41, 0x9AD8FB41, 0x9AD9FB41, 0x9ADAFB41, 0x9ADBFB41, 0x9ADCFB41, 0x9ADDFB41, 0x9ADEFB41, 0x9ADFFB41, 0x9AE0FB41, 0x9AE1FB41, 0x9AE2FB41, 0x9AE3FB41, 0x9AE4FB41, 0x9AE5FB41, 0x9AE6FB41, 0x9AE7FB41, 0x9AE8FB41, 0x9AE9FB41, 0x9AEAFB41, 0x9AEBFB41, 0x9AECFB41, 0x9AEDFB41, 0x9AEEFB41, 0x9AEFFB41, 0x9AF0FB41, 0x9AF1FB41, 0x9AF2FB41, 0x9AF3FB41, 0x9AF4FB41, 0x9AF5FB41, 0x9AF6FB41, 0x9AF7FB41, 0x9AF8FB41, 0x9AF9FB41, 0x9AFAFB41, 0x9AFBFB41, 0x9AFCFB41, 0x9AFDFB41, 0x9AFEFB41, 0x9AFFFB41, 0x9B00FB41, 0x9B01FB41, 0x9B02FB41, 0x9B03FB41, 0x9B04FB41, 0x9B05FB41, 0x9B06FB41, 0x9B07FB41, 0x9B08FB41, 0x9B09FB41, 0x9B0AFB41, 0x9B0BFB41, 0x9B0CFB41, 0x9B0DFB41, 0x9B0EFB41, 0x9B0FFB41, 0x9B10FB41, 0x9B11FB41, 0x9B12FB41, 0x9B13FB41, 0x9B14FB41, 0x9B15FB41, 0x9B16FB41, 0x9B17FB41, 0x9B18FB41, 0x9B19FB41, 0x9B1AFB41, 0x9B1BFB41, 0x9B1CFB41, 0x9B1DFB41, 0x9B1EFB41, 0x9B1FFB41, 0x9B20FB41, 0x9B21FB41, 0x9B22FB41, 0x9B23FB41, /* 9A7A */
+ 0x9B24FB41, 0x9B25FB41, 0x9B26FB41, 0x9B27FB41, 0x9B28FB41, 0x9B29FB41, 0x9B2AFB41, 0x9B2BFB41, 0x9B2CFB41, 0x9B2DFB41, 0x9B2EFB41, 0x9B2FFB41, 0x9B30FB41, 0x9B31FB41, 0x9B32FB41, 0x9B33FB41, 0x9B34FB41, 0x9B35FB41, 0x9B36FB41, 0x9B37FB41, 0x9B38FB41, 0x9B39FB41, 0x9B3AFB41, 0x9B3BFB41, 0x9B3CFB41, 0x9B3DFB41, 0x9B3EFB41, 0x9B3FFB41, 0x9B40FB41, 0x9B41FB41, 0x9B42FB41, 0x9B43FB41, 0x9B44FB41, 0x9B45FB41, 0x9B46FB41, 0x9B47FB41, 0x9B48FB41, 0x9B49FB41, 0x9B4AFB41, 0x9B4BFB41, 0x9B4CFB41, 0x9B4DFB41, 0x9B4EFB41, 0x9B4FFB41, 0x9B50FB41, 0x9B51FB41, 0x9B52FB41, 0x9B53FB41, 0x9B54FB41, 0x9B55FB41, 0x9B56FB41, 0x9B57FB41, 0x9B58FB41, 0x9B59FB41, 0x9B5AFB41, 0x9B5BFB41, 0x9B5CFB41, 0x9B5DFB41, 0x9B5EFB41, 0x9B5FFB41, 0x9B60FB41, 0x9B61FB41, 0x9B62FB41, 0x9B63FB41, 0x9B64FB41, 0x9B65FB41, 0x9B66FB41, 0x9B67FB41, 0x9B68FB41, 0x9B69FB41, 0x9B6AFB41, 0x9B6BFB41, 0x9B6CFB41, 0x9B6DFB41, 0x9B6EFB41, 0x9B6FFB41, 0x9B70FB41, 0x9B71FB41, 0x9B72FB41, 0x9B73FB41, 0x9B74FB41, 0x9B75FB41, 0x9B76FB41, 0x9B77FB41, 0x9B78FB41, 0x9B79FB41, 0x9B7AFB41, 0x9B7BFB41, 0x9B7CFB41, 0x9B7DFB41, 0x9B7EFB41, 0x9B7FFB41, 0x9B80FB41, 0x9B81FB41, 0x9B82FB41, 0x9B83FB41, 0x9B84FB41, 0x9B85FB41, 0x9B86FB41, 0x9B87FB41, 0x9B88FB41, 0x9B89FB41, 0x9B8AFB41, 0x9B8BFB41, 0x9B8CFB41, 0x9B8DFB41, 0x9B8EFB41, 0x9B8FFB41, 0x9B90FB41, 0x9B91FB41, 0x9B92FB41, 0x9B93FB41, 0x9B94FB41, 0x9B95FB41, 0x9B96FB41, 0x9B97FB41, 0x9B98FB41, 0x9B99FB41, 0x9B9AFB41, 0x9B9BFB41, 0x9B9CFB41, 0x9B9DFB41, 0x9B9EFB41, 0x9B9FFB41, 0x9BA0FB41, 0x9BA1FB41, 0x9BA2FB41, 0x9BA3FB41, 0x9BA4FB41, 0x9BA5FB41, 0x9BA6FB41, 0x9BA7FB41, 0x9BA8FB41, 0x9BA9FB41, 0x9BAAFB41, 0x9BABFB41, 0x9BACFB41, 0x9BADFB41, 0x9BAEFB41, 0x9BAFFB41, 0x9BB0FB41, 0x9BB1FB41, 0x9BB2FB41, 0x9BB3FB41, 0x9BB4FB41, 0x9BB5FB41, 0x9BB6FB41, 0x9BB7FB41, 0x9BB8FB41, 0x9BB9FB41, 0x9BBAFB41, 0x9BBBFB41, 0x9BBCFB41, 0x9BBDFB41, 0x9BBEFB41, 0x9BBFFB41, 0x9BC0FB41, 0x9BC1FB41, 0x9BC2FB41, 0x9BC3FB41, 0x9BC4FB41, 0x9BC5FB41, 0x9BC6FB41, 0x9BC7FB41, 0x9BC8FB41, 0x9BC9FB41, 0x9BCAFB41, 0x9BCBFB41, 0x9BCCFB41, 0x9BCDFB41, /* 9B24 */
+ 0x9BCEFB41, 0x9BCFFB41, 0x9BD0FB41, 0x9BD1FB41, 0x9BD2FB41, 0x9BD3FB41, 0x9BD4FB41, 0x9BD5FB41, 0x9BD6FB41, 0x9BD7FB41, 0x9BD8FB41, 0x9BD9FB41, 0x9BDAFB41, 0x9BDBFB41, 0x9BDCFB41, 0x9BDDFB41, 0x9BDEFB41, 0x9BDFFB41, 0x9BE0FB41, 0x9BE1FB41, 0x9BE2FB41, 0x9BE3FB41, 0x9BE4FB41, 0x9BE5FB41, 0x9BE6FB41, 0x9BE7FB41, 0x9BE8FB41, 0x9BE9FB41, 0x9BEAFB41, 0x9BEBFB41, 0x9BECFB41, 0x9BEDFB41, 0x9BEEFB41, 0x9BEFFB41, 0x9BF0FB41, 0x9BF1FB41, 0x9BF2FB41, 0x9BF3FB41, 0x9BF4FB41, 0x9BF5FB41, 0x9BF6FB41, 0x9BF7FB41, 0x9BF8FB41, 0x9BF9FB41, 0x9BFAFB41, 0x9BFBFB41, 0x9BFCFB41, 0x9BFDFB41, 0x9BFEFB41, 0x9BFFFB41, 0x9C00FB41, 0x9C01FB41, 0x9C02FB41, 0x9C03FB41, 0x9C04FB41, 0x9C05FB41, 0x9C06FB41, 0x9C07FB41, 0x9C08FB41, 0x9C09FB41, 0x9C0AFB41, 0x9C0BFB41, 0x9C0CFB41, 0x9C0DFB41, 0x9C0EFB41, 0x9C0FFB41, 0x9C10FB41, 0x9C11FB41, 0x9C12FB41, 0x9C13FB41, 0x9C14FB41, 0x9C15FB41, 0x9C16FB41, 0x9C17FB41, 0x9C18FB41, 0x9C19FB41, 0x9C1AFB41, 0x9C1BFB41, 0x9C1CFB41, 0x9C1DFB41, 0x9C1EFB41, 0x9C1FFB41, 0x9C20FB41, 0x9C21FB41, 0x9C22FB41, 0x9C23FB41, 0x9C24FB41, 0x9C25FB41, 0x9C26FB41, 0x9C27FB41, 0x9C28FB41, 0x9C29FB41, 0x9C2AFB41, 0x9C2BFB41, 0x9C2CFB41, 0x9C2DFB41, 0x9C2EFB41, 0x9C2FFB41, 0x9C30FB41, 0x9C31FB41, 0x9C32FB41, 0x9C33FB41, 0x9C34FB41, 0x9C35FB41, 0x9C36FB41, 0x9C37FB41, 0x9C38FB41, 0x9C39FB41, 0x9C3AFB41, 0x9C3BFB41, 0x9C3CFB41, 0x9C3DFB41, 0x9C3EFB41, 0x9C3FFB41, 0x9C40FB41, 0x9C41FB41, 0x9C42FB41, 0x9C43FB41, 0x9C44FB41, 0x9C45FB41, 0x9C46FB41, 0x9C47FB41, 0x9C48FB41, 0x9C49FB41, 0x9C4AFB41, 0x9C4BFB41, 0x9C4CFB41, 0x9C4DFB41, 0x9C4EFB41, 0x9C4FFB41, 0x9C50FB41, 0x9C51FB41, 0x9C52FB41, 0x9C53FB41, 0x9C54FB41, 0x9C55FB41, 0x9C56FB41, 0x9C57FB41, 0x9C58FB41, 0x9C59FB41, 0x9C5AFB41, 0x9C5BFB41, 0x9C5CFB41, 0x9C5DFB41, 0x9C5EFB41, 0x9C5FFB41, 0x9C60FB41, 0x9C61FB41, 0x9C62FB41, 0x9C63FB41, 0x9C64FB41, 0x9C65FB41, 0x9C66FB41, 0x9C67FB41, 0x9C68FB41, 0x9C69FB41, 0x9C6AFB41, 0x9C6BFB41, 0x9C6CFB41, 0x9C6DFB41, 0x9C6EFB41, 0x9C6FFB41, 0x9C70FB41, 0x9C71FB41, 0x9C72FB41, 0x9C73FB41, 0x9C74FB41, 0x9C75FB41, 0x9C76FB41, 0x9C77FB41, /* 9BCE */
+ 0x9C78FB41, 0x9C79FB41, 0x9C7AFB41, 0x9C7BFB41, 0x9C7CFB41, 0x9C7DFB41, 0x9C7EFB41, 0x9C7FFB41, 0x9C80FB41, 0x9C81FB41, 0x9C82FB41, 0x9C83FB41, 0x9C84FB41, 0x9C85FB41, 0x9C86FB41, 0x9C87FB41, 0x9C88FB41, 0x9C89FB41, 0x9C8AFB41, 0x9C8BFB41, 0x9C8CFB41, 0x9C8DFB41, 0x9C8EFB41, 0x9C8FFB41, 0x9C90FB41, 0x9C91FB41, 0x9C92FB41, 0x9C93FB41, 0x9C94FB41, 0x9C95FB41, 0x9C96FB41, 0x9C97FB41, 0x9C98FB41, 0x9C99FB41, 0x9C9AFB41, 0x9C9BFB41, 0x9C9CFB41, 0x9C9DFB41, 0x9C9EFB41, 0x9C9FFB41, 0x9CA0FB41, 0x9CA1FB41, 0x9CA2FB41, 0x9CA3FB41, 0x9CA4FB41, 0x9CA5FB41, 0x9CA6FB41, 0x9CA7FB41, 0x9CA8FB41, 0x9CA9FB41, 0x9CAAFB41, 0x9CABFB41, 0x9CACFB41, 0x9CADFB41, 0x9CAEFB41, 0x9CAFFB41, 0x9CB0FB41, 0x9CB1FB41, 0x9CB2FB41, 0x9CB3FB41, 0x9CB4FB41, 0x9CB5FB41, 0x9CB6FB41, 0x9CB7FB41, 0x9CB8FB41, 0x9CB9FB41, 0x9CBAFB41, 0x9CBBFB41, 0x9CBCFB41, 0x9CBDFB41, 0x9CBEFB41, 0x9CBFFB41, 0x9CC0FB41, 0x9CC1FB41, 0x9CC2FB41, 0x9CC3FB41, 0x9CC4FB41, 0x9CC5FB41, 0x9CC6FB41, 0x9CC7FB41, 0x9CC8FB41, 0x9CC9FB41, 0x9CCAFB41, 0x9CCBFB41, 0x9CCCFB41, 0x9CCDFB41, 0x9CCEFB41, 0x9CCFFB41, 0x9CD0FB41, 0x9CD1FB41, 0x9CD2FB41, 0x9CD3FB41, 0x9CD4FB41, 0x9CD5FB41, 0x9CD6FB41, 0x9CD7FB41, 0x9CD8FB41, 0x9CD9FB41, 0x9CDAFB41, 0x9CDBFB41, 0x9CDCFB41, 0x9CDDFB41, 0x9CDEFB41, 0x9CDFFB41, 0x9CE0FB41, 0x9CE1FB41, 0x9CE2FB41, 0x9CE3FB41, 0x9CE4FB41, 0x9CE5FB41, 0x9CE6FB41, 0x9CE7FB41, 0x9CE8FB41, 0x9CE9FB41, 0x9CEAFB41, 0x9CEBFB41, 0x9CECFB41, 0x9CEDFB41, 0x9CEEFB41, 0x9CEFFB41, 0x9CF0FB41, 0x9CF1FB41, 0x9CF2FB41, 0x9CF3FB41, 0x9CF4FB41, 0x9CF5FB41, 0x9CF6FB41, 0x9CF7FB41, 0x9CF8FB41, 0x9CF9FB41, 0x9CFAFB41, 0x9CFBFB41, 0x9CFCFB41, 0x9CFDFB41, 0x9CFEFB41, 0x9CFFFB41, 0x9D00FB41, 0x9D01FB41, 0x9D02FB41, 0x9D03FB41, 0x9D04FB41, 0x9D05FB41, 0x9D06FB41, 0x9D07FB41, 0x9D08FB41, 0x9D09FB41, 0x9D0AFB41, 0x9D0BFB41, 0x9D0CFB41, 0x9D0DFB41, 0x9D0EFB41, 0x9D0FFB41, 0x9D10FB41, 0x9D11FB41, 0x9D12FB41, 0x9D13FB41, 0x9D14FB41, 0x9D15FB41, 0x9D16FB41, 0x9D17FB41, 0x9D18FB41, 0x9D19FB41, 0x9D1AFB41, 0x9D1BFB41, 0x9D1CFB41, 0x9D1DFB41, 0x9D1EFB41, 0x9D1FFB41, 0x9D20FB41, 0x9D21FB41, /* 9C78 */
+ 0x9D22FB41, 0x9D23FB41, 0x9D24FB41, 0x9D25FB41, 0x9D26FB41, 0x9D27FB41, 0x9D28FB41, 0x9D29FB41, 0x9D2AFB41, 0x9D2BFB41, 0x9D2CFB41, 0x9D2DFB41, 0x9D2EFB41, 0x9D2FFB41, 0x9D30FB41, 0x9D31FB41, 0x9D32FB41, 0x9D33FB41, 0x9D34FB41, 0x9D35FB41, 0x9D36FB41, 0x9D37FB41, 0x9D38FB41, 0x9D39FB41, 0x9D3AFB41, 0x9D3BFB41, 0x9D3CFB41, 0x9D3DFB41, 0x9D3EFB41, 0x9D3FFB41, 0x9D40FB41, 0x9D41FB41, 0x9D42FB41, 0x9D43FB41, 0x9D44FB41, 0x9D45FB41, 0x9D46FB41, 0x9D47FB41, 0x9D48FB41, 0x9D49FB41, 0x9D4AFB41, 0x9D4BFB41, 0x9D4CFB41, 0x9D4DFB41, 0x9D4EFB41, 0x9D4FFB41, 0x9D50FB41, 0x9D51FB41, 0x9D52FB41, 0x9D53FB41, 0x9D54FB41, 0x9D55FB41, 0x9D56FB41, 0x9D57FB41, 0x9D58FB41, 0x9D59FB41, 0x9D5AFB41, 0x9D5BFB41, 0x9D5CFB41, 0x9D5DFB41, 0x9D5EFB41, 0x9D5FFB41, 0x9D60FB41, 0x9D61FB41, 0x9D62FB41, 0x9D63FB41, 0x9D64FB41, 0x9D65FB41, 0x9D66FB41, 0x9D67FB41, 0x9D68FB41, 0x9D69FB41, 0x9D6AFB41, 0x9D6BFB41, 0x9D6CFB41, 0x9D6DFB41, 0x9D6EFB41, 0x9D6FFB41, 0x9D70FB41, 0x9D71FB41, 0x9D72FB41, 0x9D73FB41, 0x9D74FB41, 0x9D75FB41, 0x9D76FB41, 0x9D77FB41, 0x9D78FB41, 0x9D79FB41, 0x9D7AFB41, 0x9D7BFB41, 0x9D7CFB41, 0x9D7DFB41, 0x9D7EFB41, 0x9D7FFB41, 0x9D80FB41, 0x9D81FB41, 0x9D82FB41, 0x9D83FB41, 0x9D84FB41, 0x9D85FB41, 0x9D86FB41, 0x9D87FB41, 0x9D88FB41, 0x9D89FB41, 0x9D8AFB41, 0x9D8BFB41, 0x9D8CFB41, 0x9D8DFB41, 0x9D8EFB41, 0x9D8FFB41, 0x9D90FB41, 0x9D91FB41, 0x9D92FB41, 0x9D93FB41, 0x9D94FB41, 0x9D95FB41, 0x9D96FB41, 0x9D97FB41, 0x9D98FB41, 0x9D99FB41, 0x9D9AFB41, 0x9D9BFB41, 0x9D9CFB41, 0x9D9DFB41, 0x9D9EFB41, 0x9D9FFB41, 0x9DA0FB41, 0x9DA1FB41, 0x9DA2FB41, 0x9DA3FB41, 0x9DA4FB41, 0x9DA5FB41, 0x9DA6FB41, 0x9DA7FB41, 0x9DA8FB41, 0x9DA9FB41, 0x9DAAFB41, 0x9DABFB41, 0x9DACFB41, 0x9DADFB41, 0x9DAEFB41, 0x9DAFFB41, 0x9DB0FB41, 0x9DB1FB41, 0x9DB2FB41, 0x9DB3FB41, 0x9DB4FB41, 0x9DB5FB41, 0x9DB6FB41, 0x9DB7FB41, 0x9DB8FB41, 0x9DB9FB41, 0x9DBAFB41, 0x9DBBFB41, 0x9DBCFB41, 0x9DBDFB41, 0x9DBEFB41, 0x9DBFFB41, 0x9DC0FB41, 0x9DC1FB41, 0x9DC2FB41, 0x9DC3FB41, 0x9DC4FB41, 0x9DC5FB41, 0x9DC6FB41, 0x9DC7FB41, 0x9DC8FB41, 0x9DC9FB41, 0x9DCAFB41, 0x9DCBFB41, /* 9D22 */
+ 0x9DCCFB41, 0x9DCDFB41, 0x9DCEFB41, 0x9DCFFB41, 0x9DD0FB41, 0x9DD1FB41, 0x9DD2FB41, 0x9DD3FB41, 0x9DD4FB41, 0x9DD5FB41, 0x9DD6FB41, 0x9DD7FB41, 0x9DD8FB41, 0x9DD9FB41, 0x9DDAFB41, 0x9DDBFB41, 0x9DDCFB41, 0x9DDDFB41, 0x9DDEFB41, 0x9DDFFB41, 0x9DE0FB41, 0x9DE1FB41, 0x9DE2FB41, 0x9DE3FB41, 0x9DE4FB41, 0x9DE5FB41, 0x9DE6FB41, 0x9DE7FB41, 0x9DE8FB41, 0x9DE9FB41, 0x9DEAFB41, 0x9DEBFB41, 0x9DECFB41, 0x9DEDFB41, 0x9DEEFB41, 0x9DEFFB41, 0x9DF0FB41, 0x9DF1FB41, 0x9DF2FB41, 0x9DF3FB41, 0x9DF4FB41, 0x9DF5FB41, 0x9DF6FB41, 0x9DF7FB41, 0x9DF8FB41, 0x9DF9FB41, 0x9DFAFB41, 0x9DFBFB41, 0x9DFCFB41, 0x9DFDFB41, 0x9DFEFB41, 0x9DFFFB41, 0x9E00FB41, 0x9E01FB41, 0x9E02FB41, 0x9E03FB41, 0x9E04FB41, 0x9E05FB41, 0x9E06FB41, 0x9E07FB41, 0x9E08FB41, 0x9E09FB41, 0x9E0AFB41, 0x9E0BFB41, 0x9E0CFB41, 0x9E0DFB41, 0x9E0EFB41, 0x9E0FFB41, 0x9E10FB41, 0x9E11FB41, 0x9E12FB41, 0x9E13FB41, 0x9E14FB41, 0x9E15FB41, 0x9E16FB41, 0x9E17FB41, 0x9E18FB41, 0x9E19FB41, 0x9E1AFB41, 0x9E1BFB41, 0x9E1CFB41, 0x9E1DFB41, 0x9E1EFB41, 0x9E1FFB41, 0x9E20FB41, 0x9E21FB41, 0x9E22FB41, 0x9E23FB41, 0x9E24FB41, 0x9E25FB41, 0x9E26FB41, 0x9E27FB41, 0x9E28FB41, 0x9E29FB41, 0x9E2AFB41, 0x9E2BFB41, 0x9E2CFB41, 0x9E2DFB41, 0x9E2EFB41, 0x9E2FFB41, 0x9E30FB41, 0x9E31FB41, 0x9E32FB41, 0x9E33FB41, 0x9E34FB41, 0x9E35FB41, 0x9E36FB41, 0x9E37FB41, 0x9E38FB41, 0x9E39FB41, 0x9E3AFB41, 0x9E3BFB41, 0x9E3CFB41, 0x9E3DFB41, 0x9E3EFB41, 0x9E3FFB41, 0x9E40FB41, 0x9E41FB41, 0x9E42FB41, 0x9E43FB41, 0x9E44FB41, 0x9E45FB41, 0x9E46FB41, 0x9E47FB41, 0x9E48FB41, 0x9E49FB41, 0x9E4AFB41, 0x9E4BFB41, 0x9E4CFB41, 0x9E4DFB41, 0x9E4EFB41, 0x9E4FFB41, 0x9E50FB41, 0x9E51FB41, 0x9E52FB41, 0x9E53FB41, 0x9E54FB41, 0x9E55FB41, 0x9E56FB41, 0x9E57FB41, 0x9E58FB41, 0x9E59FB41, 0x9E5AFB41, 0x9E5BFB41, 0x9E5CFB41, 0x9E5DFB41, 0x9E5EFB41, 0x9E5FFB41, 0x9E60FB41, 0x9E61FB41, 0x9E62FB41, 0x9E63FB41, 0x9E64FB41, 0x9E65FB41, 0x9E66FB41, 0x9E67FB41, 0x9E68FB41, 0x9E69FB41, 0x9E6AFB41, 0x9E6BFB41, 0x9E6CFB41, 0x9E6DFB41, 0x9E6EFB41, 0x9E6FFB41, 0x9E70FB41, 0x9E71FB41, 0x9E72FB41, 0x9E73FB41, 0x9E74FB41, 0x9E75FB41, /* 9DCC */
+ 0x9E76FB41, 0x9E77FB41, 0x9E78FB41, 0x9E79FB41, 0x9E7AFB41, 0x9E7BFB41, 0x9E7CFB41, 0x9E7DFB41, 0x9E7EFB41, 0x9E7FFB41, 0x9E80FB41, 0x9E81FB41, 0x9E82FB41, 0x9E83FB41, 0x9E84FB41, 0x9E85FB41, 0x9E86FB41, 0x9E87FB41, 0x9E88FB41, 0x9E89FB41, 0x9E8AFB41, 0x9E8BFB41, 0x9E8CFB41, 0x9E8DFB41, 0x9E8EFB41, 0x9E8FFB41, 0x9E90FB41, 0x9E91FB41, 0x9E92FB41, 0x9E93FB41, 0x9E94FB41, 0x9E95FB41, 0x9E96FB41, 0x9E97FB41, 0x9E98FB41, 0x9E99FB41, 0x9E9AFB41, 0x9E9BFB41, 0x9E9CFB41, 0x9E9DFB41, 0x9E9EFB41, 0x9E9FFB41, 0x9EA0FB41, 0x9EA1FB41, 0x9EA2FB41, 0x9EA3FB41, 0x9EA4FB41, 0x9EA5FB41, 0x9EA6FB41, 0x9EA7FB41, 0x9EA8FB41, 0x9EA9FB41, 0x9EAAFB41, 0x9EABFB41, 0x9EACFB41, 0x9EADFB41, 0x9EAEFB41, 0x9EAFFB41, 0x9EB0FB41, 0x9EB1FB41, 0x9EB2FB41, 0x9EB3FB41, 0x9EB4FB41, 0x9EB5FB41, 0x9EB6FB41, 0x9EB7FB41, 0x9EB8FB41, 0x9EB9FB41, 0x9EBAFB41, 0x9EBBFB41, 0x9EBCFB41, 0x9EBDFB41, 0x9EBEFB41, 0x9EBFFB41, 0x9EC0FB41, 0x9EC1FB41, 0x9EC2FB41, 0x9EC3FB41, 0x9EC4FB41, 0x9EC5FB41, 0x9EC6FB41, 0x9EC7FB41, 0x9EC8FB41, 0x9EC9FB41, 0x9ECAFB41, 0x9ECBFB41, 0x9ECCFB41, 0x9ECDFB41, 0x9ECEFB41, 0x9ECFFB41, 0x9ED0FB41, 0x9ED1FB41, 0x9ED2FB41, 0x9ED3FB41, 0x9ED4FB41, 0x9ED5FB41, 0x9ED6FB41, 0x9ED7FB41, 0x9ED8FB41, 0x9ED9FB41, 0x9EDAFB41, 0x9EDBFB41, 0x9EDCFB41, 0x9EDDFB41, 0x9EDEFB41, 0x9EDFFB41, 0x9EE0FB41, 0x9EE1FB41, 0x9EE2FB41, 0x9EE3FB41, 0x9EE4FB41, 0x9EE5FB41, 0x9EE6FB41, 0x9EE7FB41, 0x9EE8FB41, 0x9EE9FB41, 0x9EEAFB41, 0x9EEBFB41, 0x9EECFB41, 0x9EEDFB41, 0x9EEEFB41, 0x9EEFFB41, 0x9EF0FB41, 0x9EF1FB41, 0x9EF2FB41, 0x9EF3FB41, 0x9EF4FB41, 0x9EF5FB41, 0x9EF6FB41, 0x9EF7FB41, 0x9EF8FB41, 0x9EF9FB41, 0x9EFAFB41, 0x9EFBFB41, 0x9EFCFB41, 0x9EFDFB41, 0x9EFEFB41, 0x9EFFFB41, 0x9F00FB41, 0x9F01FB41, 0x9F02FB41, 0x9F03FB41, 0x9F04FB41, 0x9F05FB41, 0x9F06FB41, 0x9F07FB41, 0x9F08FB41, 0x9F09FB41, 0x9F0AFB41, 0x9F0BFB41, 0x9F0CFB41, 0x9F0DFB41, 0x9F0EFB41, 0x9F0FFB41, 0x9F10FB41, 0x9F11FB41, 0x9F12FB41, 0x9F13FB41, 0x9F14FB41, 0x9F15FB41, 0x9F16FB41, 0x9F17FB41, 0x9F18FB41, 0x9F19FB41, 0x9F1AFB41, 0x9F1BFB41, 0x9F1CFB41, 0x9F1DFB41, 0x9F1EFB41, 0x9F1FFB41, /* 9E76 */
+ 0x9F20FB41, 0x9F21FB41, 0x9F22FB41, 0x9F23FB41, 0x9F24FB41, 0x9F25FB41, 0x9F26FB41, 0x9F27FB41, 0x9F28FB41, 0x9F29FB41, 0x9F2AFB41, 0x9F2BFB41, 0x9F2CFB41, 0x9F2DFB41, 0x9F2EFB41, 0x9F2FFB41, 0x9F30FB41, 0x9F31FB41, 0x9F32FB41, 0x9F33FB41, 0x9F34FB41, 0x9F35FB41, 0x9F36FB41, 0x9F37FB41, 0x9F38FB41, 0x9F39FB41, 0x9F3AFB41, 0x9F3BFB41, 0x9F3CFB41, 0x9F3DFB41, 0x9F3EFB41, 0x9F3FFB41, 0x9F40FB41, 0x9F41FB41, 0x9F42FB41, 0x9F43FB41, 0x9F44FB41, 0x9F45FB41, 0x9F46FB41, 0x9F47FB41, 0x9F48FB41, 0x9F49FB41, 0x9F4AFB41, 0x9F4BFB41, 0x9F4CFB41, 0x9F4DFB41, 0x9F4EFB41, 0x9F4FFB41, 0x9F50FB41, 0x9F51FB41, 0x9F52FB41, 0x9F53FB41, 0x9F54FB41, 0x9F55FB41, 0x9F56FB41, 0x9F57FB41, 0x9F58FB41, 0x9F59FB41, 0x9F5AFB41, 0x9F5BFB41, 0x9F5CFB41, 0x9F5DFB41, 0x9F5EFB41, 0x9F5FFB41, 0x9F60FB41, 0x9F61FB41, 0x9F62FB41, 0x9F63FB41, 0x9F64FB41, 0x9F65FB41, 0x9F66FB41, 0x9F67FB41, 0x9F68FB41, 0x9F69FB41, 0x9F6AFB41, 0x9F6BFB41, 0x9F6CFB41, 0x9F6DFB41, 0x9F6EFB41, 0x9F6FFB41, 0x9F70FB41, 0x9F71FB41, 0x9F72FB41, 0x9F73FB41, 0x9F74FB41, 0x9F75FB41, 0x9F76FB41, 0x9F77FB41, 0x9F78FB41, 0x9F79FB41, 0x9F7AFB41, 0x9F7BFB41, 0x9F7CFB41, 0x9F7DFB41, 0x9F7EFB41, 0x9F7FFB41, 0x9F80FB41, 0x9F81FB41, 0x9F82FB41, 0x9F83FB41, 0x9F84FB41, 0x9F85FB41, 0x9F86FB41, 0x9F87FB41, 0x9F88FB41, 0x9F89FB41, 0x9F8AFB41, 0x9F8BFB41, 0x9F8CFB41, 0x9F8DFB41, 0x9F8EFB41, 0x9F8FFB41, 0x9F90FB41, 0x9F91FB41, 0x9F92FB41, 0x9F93FB41, 0x9F94FB41, 0x9F95FB41, 0x9F96FB41, 0x9F97FB41, 0x9F98FB41, 0x9F99FB41, 0x9F9AFB41, 0x9F9BFB41, 0x9F9CFB41, 0x9F9DFB41, 0x9F9EFB41, 0x9F9FFB41, 0x9FA0FB41, 0x9FA1FB41, 0x9FA2FB41, 0x9FA3FB41, 0x9FA4FB41, 0x9FA5FB41, 0x9FA6FBC1, 0x9FA7FBC1, 0x9FA8FBC1, 0x9FA9FBC1, 0x9FAAFBC1, 0x9FABFBC1, 0x9FACFBC1, 0x9FADFBC1, 0x9FAEFBC1, 0x9FAFFBC1, 0x9FB0FBC1, 0x9FB1FBC1, 0x9FB2FBC1, 0x9FB3FBC1, 0x9FB4FBC1, 0x9FB5FBC1, 0x9FB6FBC1, 0x9FB7FBC1, 0x9FB8FBC1, 0x9FB9FBC1, 0x9FBAFBC1, 0x9FBBFBC1, 0x9FBCFBC1, 0x9FBDFBC1, 0x9FBEFBC1, 0x9FBFFBC1, 0x9FC0FBC1, 0x9FC1FBC1, 0x9FC2FBC1, 0x9FC3FBC1, 0x9FC4FBC1, 0x9FC5FBC1, 0x9FC6FBC1, 0x9FC7FBC1, 0x9FC8FBC1, 0x9FC9FBC1, /* 9F20 */
+ 0x9FCAFBC1, 0x9FCBFBC1, 0x9FCCFBC1, 0x9FCDFBC1, 0x9FCEFBC1, 0x9FCFFBC1, 0x9FD0FBC1, 0x9FD1FBC1, 0x9FD2FBC1, 0x9FD3FBC1, 0x9FD4FBC1, 0x9FD5FBC1, 0x9FD6FBC1, 0x9FD7FBC1, 0x9FD8FBC1, 0x9FD9FBC1, 0x9FDAFBC1, 0x9FDBFBC1, 0x9FDCFBC1, 0x9FDDFBC1, 0x9FDEFBC1, 0x9FDFFBC1, 0x9FE0FBC1, 0x9FE1FBC1, 0x9FE2FBC1, 0x9FE3FBC1, 0x9FE4FBC1, 0x9FE5FBC1, 0x9FE6FBC1, 0x9FE7FBC1, 0x9FE8FBC1, 0x9FE9FBC1, 0x9FEAFBC1, 0x9FEBFBC1, 0x9FECFBC1, 0x9FEDFBC1, 0x9FEEFBC1, 0x9FEFFBC1, 0x9FF0FBC1, 0x9FF1FBC1, 0x9FF2FBC1, 0x9FF3FBC1, 0x9FF4FBC1, 0x9FF5FBC1, 0x9FF6FBC1, 0x9FF7FBC1, 0x9FF8FBC1, 0x9FF9FBC1, 0x9FFAFBC1, 0x9FFBFBC1, 0x9FFCFBC1, 0x9FFDFBC1, 0x9FFEFBC1, 0x9FFFFBC1, 0x1EB1, 0x1EB2, 0x1EB3, 0x1EB4, 0x1EB5, 0x1EB6, 0x1EB7, 0x1EB8, 0x1EB9, 0x1EBA, 0x1EBB, 0x1EBC, 0x1EBD, 0x1EBE, 0x1EBF, 0x1EC0, 0x1EC1, 0x1EC2, 0x1EC3, 0x1EC4, 0x1EC5, 0x1EC6, 0x1EC7, 0x1EC8, 0x1EC9, 0x1ECA, 0x1ECB, 0x1ECC, 0x1ECD, 0x1ECE, 0x1ECF, 0x1ED0, 0x1ED1, 0x1ED2, 0x1ED3, 0x1ED4, 0x1ED5, 0x1ED6, 0x1ED7, 0x1ED8, 0x1ED9, 0x1EDA, 0x1EDB, 0x1EDC, 0x1EDD, 0x1EDE, 0x1EDF, 0x1EE0, 0x1EE1, 0x1EE2, 0x1EE3, 0x1EE4, 0x1EE5, 0x1EE6, 0x1EE7, 0x1EE8, 0x1EE9, 0x1EEA, 0x1EEB, 0x1EEC, 0x1EED, 0x1EEE, 0x1EEF, 0x1EF0, 0x1EF1, 0x1EF2, 0x1EF3, 0x1EF4, 0x1EF5, 0x1EF6, 0x1EF7, 0x1EF8, 0x1EF9, 0x1EFA, 0x1EFB, 0x1EFC, 0x1EFD, 0x1EFE, 0x1EFF, 0x1F00, 0x1F01, 0x1F02, 0x1F03, 0x1F04, 0x1F05, 0x1F06, 0x1F07, 0x1F08, 0x1F09, 0x1F0A, 0x1F0B, 0x1F0C, 0x1F0D, 0x1F0E, 0x1F0F, 0x1F10, 0x1F11, 0x1F12, 0x1F13, 0x1F14, 0x1F15, 0x1F16, 0x1F17, 0x1F18, 0x1F19, 0x1F1A, 0x1F1B, 0x1F1C, 0x1F1D, 0x1F1E, 0x1F1F, 0x1F20, 0x1F21, 0x1F22, 0x1F23, 0x1F24, 0x1F25, 0x1F26, 0x1F27, 0x1F28, 0x1F29, 0x1F2A, 0x1F2B, 0x1F2C, 0x1F2D, 0x1F2E, 0x1F2F, 0x1F30, 0x1F31, 0x1F32, 0x1F33, 0x1F34, 0x1F35, 0x1F36, 0x1F37, 0x1F38, 0x1F39, 0x1F3A, 0x1F3B, 0x1F3C, 0x1F3D, 0x1F3E, 0x1F3F, 0x1F40, 0x1F41, 0x1F42, 0x1F43, 0x1F44, 0x1F45, 0x1F46, 0x1F47, 0x1F48, 0x1F49, 0x1F4A, 0x1F4B, 0x1F4C, 0x1F4D, 0x1F4E, 0x1F4F, 0x1F50, 0x1F51, 0x1F52, 0x1F53, 0x1F54, 0x1F55, 0x1F56, 0x1F57, 0x1F58, 0x1F59, 0x1F5A, 0x1F5B, 0x1F5C, 0x1F5D, 0x1F5E, 0x1F5F, /* 9FCA */
+ 0x1F60, 0x1F61, 0x1F62, 0x1F63, 0x1F64, 0x1F65, 0x1F66, 0x1F67, 0x1F68, 0x1F69, 0x1F6A, 0x1F6B, 0x1F6C, 0x1F6D, 0x1F6E, 0x1F6F, 0x1F70, 0x1F71, 0x1F72, 0x1F73, 0x1F74, 0x1F75, 0x1F76, 0x1F77, 0x1F78, 0x1F79, 0x1F7A, 0x1F7B, 0x1F7C, 0x1F7D, 0x1F7E, 0x1F7F, 0x1F80, 0x1F81, 0x1F82, 0x1F83, 0x1F84, 0x1F85, 0x1F86, 0x1F87, 0x1F88, 0x1F89, 0x1F8A, 0x1F8B, 0x1F8C, 0x1F8D, 0x1F8E, 0x1F8F, 0x1F90, 0x1F91, 0x1F92, 0x1F93, 0x1F94, 0x1F95, 0x1F96, 0x1F97, 0x1F98, 0x1F99, 0x1F9A, 0x1F9B, 0x1F9C, 0x1F9D, 0x1F9E, 0x1F9F, 0x1FA0, 0x1FA1, 0x1FA2, 0x1FA3, 0x1FA4, 0x1FA5, 0x1FA6, 0x1FA7, 0x1FA8, 0x1FA9, 0x1FAA, 0x1FAB, 0x1FAC, 0x1FAD, 0x1FAE, 0x1FAF, 0x1FB0, 0x1FB1, 0x1FB2, 0x1FB3, 0x1FB4, 0x1FB5, 0x1FB6, 0x1FB7, 0x1FB8, 0x1FB9, 0x1FBA, 0x1FBB, 0x1FBC, 0x1FBD, 0x1FBE, 0x1FBF, 0x1FC0, 0x1FC1, 0x1FC2, 0x1FC3, 0x1FC4, 0x1FC5, 0x1FC6, 0x1FC7, 0x1FC8, 0x1FC9, 0x1FCA, 0x1FCB, 0x1FCC, 0x1FCD, 0x1FCE, 0x1FCF, 0x1FD0, 0x1FD1, 0x1FD2, 0x1FD3, 0x1FD4, 0x1FD5, 0x1FD6, 0x1FD7, 0x1FD8, 0x1FD9, 0x1FDA, 0x1FDB, 0x1FDC, 0x1FDD, 0x1FDE, 0x1FDF, 0x1FE0, 0x1FE1, 0x1FE2, 0x1FE3, 0x1FE4, 0x1FE5, 0x1FE6, 0x1FE7, 0x1FE8, 0x1FE9, 0x1FEA, 0x1FEB, 0x1FEC, 0x1FED, 0x1FEE, 0x1FEF, 0x1FF0, 0x1FF1, 0x1FF2, 0x1FF3, 0x1FF4, 0x1FF5, 0x1FF6, 0x1FF7, 0x1FF8, 0x1FF9, 0x1FFA, 0x1FFB, 0x1FFC, 0x1FFD, 0x1FFE, 0x1FFF, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x200B, 0x200C, 0x200D, 0x200E, 0x200F, 0x2010, 0x2011, 0x2012, 0x2013, 0x2014, 0x2015, 0x2016, 0x2017, 0x2018, 0x2019, 0x201A, 0x201B, 0x201C, 0x201D, 0x201E, 0x201F, 0x2020, 0x2021, 0x2022, 0x2023, 0x2024, 0x2025, 0x2026, 0x2027, 0x2028, 0x2029, 0x202A, 0x202B, 0x202C, 0x202D, 0x202E, 0x202F, 0x2030, 0x2031, 0x2032, 0x2033, 0x2034, 0x2035, 0x2036, 0x2037, 0x2038, 0x2039, 0x203A, 0x203B, 0x203C, 0x203D, 0x203E, 0x203F, 0x2040, 0x2041, 0x2042, 0x2043, 0x2044, 0x2045, 0x2046, 0x2047, 0x2048, 0x2049, 0x204A, 0x204B, 0x204C, 0x204D, 0x204E, 0x204F, 0x2050, 0x2051, 0x2052, 0x2053, 0x2054, 0x2055, 0x2056, 0x2057, 0x2058, 0x2059, 0x205A, 0x205B, 0x205C, 0x205D, 0x205E, 0x205F, /* A0AF */
+ 0x2060, 0x2061, 0x2062, 0x2063, 0x2064, 0x2065, 0x2066, 0x2067, 0x2068, 0x2069, 0x206A, 0x206B, 0x206C, 0x206D, 0x206E, 0x206F, 0x2070, 0x2071, 0x2072, 0x2073, 0x2074, 0x2075, 0x2076, 0x2077, 0x2078, 0x2079, 0x207A, 0x207B, 0x207C, 0x207D, 0x207E, 0x207F, 0x2080, 0x2081, 0x2082, 0x2083, 0x2084, 0x2085, 0x2086, 0x2087, 0x2088, 0x2089, 0x208A, 0x208B, 0x208C, 0x208D, 0x208E, 0x208F, 0x2090, 0x2091, 0x2092, 0x2093, 0x2094, 0x2095, 0x2096, 0x2097, 0x2098, 0x2099, 0x209A, 0x209B, 0x209C, 0x209D, 0x209E, 0x209F, 0x20A0, 0x20A1, 0x20A2, 0x20A3, 0x20A4, 0x20A5, 0x20A6, 0x20A7, 0x20A8, 0x20A9, 0x20AA, 0x20AB, 0x20AC, 0x20AD, 0x20AE, 0x20AF, 0x20B0, 0x20B1, 0x20B2, 0x20B3, 0x20B4, 0x20B5, 0x20B6, 0x20B7, 0x20B8, 0x20B9, 0x20BA, 0x20BB, 0x20BC, 0x20BD, 0x20BE, 0x20BF, 0x20C0, 0x20C1, 0x20C2, 0x20C3, 0x20C4, 0x20C5, 0x20C6, 0x20C7, 0x20C8, 0x20C9, 0x20CA, 0x20CB, 0x20CC, 0x20CD, 0x20CE, 0x20CF, 0x20D0, 0x20D1, 0x20D2, 0x20D3, 0x20D4, 0x20D5, 0x20D6, 0x20D7, 0x20D8, 0x20D9, 0x20DA, 0x20DB, 0x20DC, 0x20DD, 0x20DE, 0x20DF, 0x20E0, 0x20E1, 0x20E2, 0x20E3, 0x20E4, 0x20E5, 0x20E6, 0x20E7, 0x20E8, 0x20E9, 0x20EA, 0x20EB, 0x20EC, 0x20ED, 0x20EE, 0x20EF, 0x20F0, 0x20F1, 0x20F2, 0x20F3, 0x20F4, 0x20F5, 0x20F6, 0x20F7, 0x20F8, 0x20F9, 0x20FA, 0x20FB, 0x20FC, 0x20FD, 0x20FE, 0x20FF, 0x2100, 0x2101, 0x2102, 0x2103, 0x2104, 0x2105, 0x2106, 0x2107, 0x2108, 0x2109, 0x210A, 0x210B, 0x210C, 0x210D, 0x210E, 0x210F, 0x2110, 0x2111, 0x2112, 0x2113, 0x2114, 0x2115, 0x2116, 0x2117, 0x2118, 0x2119, 0x211A, 0x211B, 0x211C, 0x211D, 0x211E, 0x211F, 0x2120, 0x2121, 0x2122, 0x2123, 0x2124, 0x2125, 0x2126, 0x2127, 0x2128, 0x2129, 0x212A, 0x212B, 0x212C, 0x212D, 0x212E, 0x212F, 0x2130, 0x2131, 0x2132, 0x2133, 0x2134, 0x2135, 0x2136, 0x2137, 0x2138, 0x2139, 0x213A, 0x213B, 0x213C, 0x213D, 0x213E, 0x213F, 0x2140, 0x2141, 0x2142, 0x2143, 0x2144, 0x2145, 0x2146, 0x2147, 0x2148, 0x2149, 0x214A, 0x214B, 0x214C, 0x214D, 0x214E, 0x214F, 0x2150, 0x2151, 0x2152, 0x2153, 0x2154, 0x2155, 0x2156, 0x2157, 0x2158, 0x2159, 0x215A, 0x215B, 0x215C, 0x215D, 0x215E, 0x215F, /* A1AF */
+ 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F, 0x2180, 0x2181, 0x2182, 0x2183, 0x2184, 0x2185, 0x2186, 0x2187, 0x2188, 0x2189, 0x218A, 0x218B, 0x218C, 0x218D, 0x218E, 0x218F, 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x2196, 0x2197, 0x2198, 0x2199, 0x219A, 0x219B, 0x219C, 0x219D, 0x219E, 0x219F, 0x21A0, 0x21A1, 0x21A2, 0x21A3, 0x21A4, 0x21A5, 0x21A6, 0x21A7, 0x21A8, 0x21A9, 0x21AA, 0x21AB, 0x21AC, 0x21AD, 0x21AE, 0x21AF, 0x21B0, 0x21B1, 0x21B2, 0x21B3, 0x21B4, 0x21B5, 0x21B6, 0x21B7, 0x21B8, 0x21B9, 0x21BA, 0x21BB, 0x21BC, 0x21BD, 0x21BE, 0x21BF, 0x21C0, 0x21C1, 0x21C2, 0x21C3, 0x21C4, 0x21C5, 0x21C6, 0x21C7, 0x21C8, 0x21C9, 0x21CA, 0x21CB, 0x21CC, 0x21CD, 0x21CE, 0x21CF, 0x21D0, 0x21D1, 0x21D2, 0x21D3, 0x21D4, 0x21D5, 0x21D6, 0x21D7, 0x21D8, 0x21D9, 0x21DA, 0x21DB, 0x21DC, 0x21DD, 0x21DE, 0x21DF, 0x21E0, 0x21E1, 0x21E2, 0x21E3, 0x21E4, 0x21E5, 0x21E6, 0x21E7, 0x21E8, 0x21E9, 0x21EA, 0x21EB, 0x21EC, 0x21ED, 0x21EE, 0x21EF, 0x21F0, 0x21F1, 0x21F2, 0x21F3, 0x21F4, 0x21F5, 0x21F6, 0x21F7, 0x21F8, 0x21F9, 0x21FA, 0x21FB, 0x21FC, 0x21FD, 0x21FE, 0x21FF, 0x2200, 0x2201, 0x2202, 0x2203, 0x2204, 0x2205, 0x2206, 0x2207, 0x2208, 0x2209, 0x220A, 0x220B, 0x220C, 0x220D, 0x220E, 0x220F, 0x2210, 0x2211, 0x2212, 0x2213, 0x2214, 0x2215, 0x2216, 0x2217, 0x2218, 0x2219, 0x221A, 0x221B, 0x221C, 0x221D, 0x221E, 0x221F, 0x2220, 0x2221, 0x2222, 0x2223, 0x2224, 0x2225, 0x2226, 0x2227, 0x2228, 0x2229, 0x222A, 0x222B, 0x222C, 0x222D, 0x222E, 0x222F, 0x2230, 0x2231, 0x2232, 0x2233, 0x2234, 0x2235, 0x2236, 0x2237, 0x2238, 0x2239, 0x223A, 0x223B, 0x223C, 0x223D, 0x223E, 0x223F, 0x2240, 0x2241, 0x2242, 0x2243, 0x2244, 0x2245, 0x2246, 0x2247, 0x2248, 0x2249, 0x224A, 0x224B, 0x224C, 0x224D, 0x224E, 0x224F, 0x2250, 0x2251, 0x2252, 0x2253, 0x2254, 0x2255, 0x2256, 0x2257, 0x2258, 0x2259, 0x225A, 0x225B, 0x225C, 0x225D, 0x225E, 0x225F, /* A2AF */
+ 0x2260, 0x2261, 0x2262, 0x2263, 0x2264, 0x2265, 0x2266, 0x2267, 0x2268, 0x2269, 0x226A, 0x226B, 0x226C, 0x226D, 0x226E, 0x226F, 0x2270, 0x2271, 0x2272, 0x2273, 0x2274, 0x2275, 0x2276, 0x2277, 0x2278, 0x2279, 0x227A, 0x227B, 0x227C, 0x227D, 0x227E, 0x227F, 0x2280, 0x2281, 0x2282, 0x2283, 0x2284, 0x2285, 0x2286, 0x2287, 0x2288, 0x2289, 0x228A, 0x228B, 0x228C, 0x228D, 0x228E, 0x228F, 0x2290, 0x2291, 0x2292, 0x2293, 0x2294, 0x2295, 0x2296, 0x2297, 0x2298, 0x2299, 0x229A, 0x229B, 0x229C, 0x229D, 0x229E, 0x229F, 0x22A0, 0x22A1, 0x22A2, 0x22A3, 0x22A4, 0x22A5, 0x22A6, 0x22A7, 0x22A8, 0x22A9, 0x22AA, 0x22AB, 0x22AC, 0x22AD, 0x22AE, 0x22AF, 0x22B0, 0x22B1, 0x22B2, 0x22B3, 0x22B4, 0x22B5, 0x22B6, 0x22B7, 0x22B8, 0x22B9, 0x22BA, 0x22BB, 0x22BC, 0x22BD, 0x22BE, 0x22BF, 0x22C0, 0x22C1, 0x22C2, 0x22C3, 0x22C4, 0x22C5, 0x22C6, 0x22C7, 0x22C8, 0x22C9, 0x22CA, 0x22CB, 0x22CC, 0x22CD, 0x22CE, 0x22CF, 0x22D0, 0x22D1, 0x22D2, 0x22D3, 0x22D4, 0x22D5, 0x22D6, 0x22D7, 0x22D8, 0x22D9, 0x22DA, 0x22DB, 0x22DC, 0x22DD, 0x22DE, 0x22DF, 0x22E0, 0x22E1, 0x22E2, 0x22E3, 0x22E4, 0x22E5, 0x22E6, 0x22E7, 0x22E8, 0x22E9, 0x22EA, 0x22EB, 0x22EC, 0x22ED, 0x22EE, 0x22EF, 0x22F0, 0x22F1, 0x22F2, 0x22F3, 0x22F4, 0x22F5, 0x22F6, 0x22F7, 0x22F8, 0x22F9, 0x22FA, 0x22FB, 0x22FC, 0x22FD, 0x22FE, 0x22FF, 0x2300, 0x2301, 0x2302, 0x2303, 0x2304, 0x2305, 0x2306, 0x2307, 0x2308, 0x2309, 0x230A, 0x230B, 0x230C, 0x230D, 0x230E, 0x230F, 0x2310, 0x2311, 0x2312, 0x2313, 0x2314, 0x2315, 0x2316, 0x2317, 0x2318, 0x2319, 0x231A, 0x231B, 0x231C, 0x231D, 0x231E, 0x231F, 0x2320, 0x2321, 0x2322, 0x2323, 0x2324, 0x2325, 0x2326, 0x2327, 0x2328, 0x2329, 0x232A, 0x232B, 0x232C, 0x232D, 0x232E, 0x232F, 0x2330, 0x2331, 0x2332, 0x2333, 0x2334, 0x2335, 0x2336, 0x2337, 0x2338, 0x2339, 0x233A, 0x233B, 0x233C, 0x233D, 0xA48DFBC1, 0xA48EFBC1, 0xA48FFBC1, 0xBCE, 0xBCF, 0xBD0, 0xBD1, 0xBD2, 0xBD3, 0xBD4, 0xBD5, 0xBD6, 0xBD7, 0xBD8, 0xBD9, 0xBDA, 0xBDB, 0xBDC, 0xBDD, 0xBDE, 0xBDF, 0xBE0, 0xBE1, 0xBE2, 0xBE3, 0xBE4, 0xBE5, 0xBE6, 0xBE7, 0xBE8, 0xBE9, 0xBEA, 0xBEB, 0xBEC, 0xBED, 0xBEE, /* A3AF */
+ 0xBEF, 0xBF0, 0xBF1, 0xBF2, 0xBF3, 0xBF4, 0xBF5, 0xBF6, 0xBF7, 0xBF8, 0xBF9, 0xBFA, 0xBFB, 0xBFC, 0xBFD, 0xBFE, 0xBFF, 0xC00, 0xC01, 0xC02, 0xC03, 0xC04, 0xA4C7FBC1, 0xA4C8FBC1, 0xA4C9FBC1, 0xA4CAFBC1, 0xA4CBFBC1, 0xA4CCFBC1, 0xA4CDFBC1, 0xA4CEFBC1, 0xA4CFFBC1, 0xA4D0FBC1, 0xA4D1FBC1, 0xA4D2FBC1, 0xA4D3FBC1, 0xA4D4FBC1, 0xA4D5FBC1, 0xA4D6FBC1, 0xA4D7FBC1, 0xA4D8FBC1, 0xA4D9FBC1, 0xA4DAFBC1, 0xA4DBFBC1, 0xA4DCFBC1, 0xA4DDFBC1, 0xA4DEFBC1, 0xA4DFFBC1, 0xA4E0FBC1, 0xA4E1FBC1, 0xA4E2FBC1, 0xA4E3FBC1, 0xA4E4FBC1, 0xA4E5FBC1, 0xA4E6FBC1, 0xA4E7FBC1, 0xA4E8FBC1, 0xA4E9FBC1, 0xA4EAFBC1, 0xA4EBFBC1, 0xA4ECFBC1, 0xA4EDFBC1, 0xA4EEFBC1, 0xA4EFFBC1, 0xA4F0FBC1, 0xA4F1FBC1, 0xA4F2FBC1, 0xA4F3FBC1, 0xA4F4FBC1, 0xA4F5FBC1, 0xA4F6FBC1, 0xA4F7FBC1, 0xA4F8FBC1, 0xA4F9FBC1, 0xA4FAFBC1, 0xA4FBFBC1, 0xA4FCFBC1, 0xA4FDFBC1, 0xA4FEFBC1, 0xA4FFFBC1, 0xA500FBC1, 0xA501FBC1, 0xA502FBC1, 0xA503FBC1, 0xA504FBC1, 0xA505FBC1, 0xA506FBC1, 0xA507FBC1, 0xA508FBC1, 0xA509FBC1, 0xA50AFBC1, 0xA50BFBC1, 0xA50CFBC1, 0xA50DFBC1, 0xA50EFBC1, 0xA50FFBC1, 0xA510FBC1, 0xA511FBC1, 0xA512FBC1, 0xA513FBC1, 0xA514FBC1, 0xA515FBC1, 0xA516FBC1, 0xA517FBC1, 0xA518FBC1, 0xA519FBC1, 0xA51AFBC1, 0xA51BFBC1, 0xA51CFBC1, 0xA51DFBC1, 0xA51EFBC1, 0xA51FFBC1, 0xA520FBC1, 0xA521FBC1, 0xA522FBC1, 0xA523FBC1, 0xA524FBC1, 0xA525FBC1, 0xA526FBC1, 0xA527FBC1, 0xA528FBC1, 0xA529FBC1, 0xA52AFBC1, 0xA52BFBC1, 0xA52CFBC1, 0xA52DFBC1, 0xA52EFBC1, 0xA52FFBC1, 0xA530FBC1, 0xA531FBC1, 0xA532FBC1, 0xA533FBC1, 0xA534FBC1, 0xA535FBC1, 0xA536FBC1, 0xA537FBC1, 0xA538FBC1, 0xA539FBC1, 0xA53AFBC1, 0xA53BFBC1, 0xA53CFBC1, 0xA53DFBC1, 0xA53EFBC1, 0xA53FFBC1, 0xA540FBC1, 0xA541FBC1, 0xA542FBC1, 0xA543FBC1, 0xA544FBC1, 0xA545FBC1, 0xA546FBC1, 0xA547FBC1, 0xA548FBC1, 0xA549FBC1, 0xA54AFBC1, 0xA54BFBC1, 0xA54CFBC1, 0xA54DFBC1, 0xA54EFBC1, 0xA54FFBC1, 0xA550FBC1, 0xA551FBC1, 0xA552FBC1, 0xA553FBC1, 0xA554FBC1, 0xA555FBC1, 0xA556FBC1, 0xA557FBC1, 0xA558FBC1, 0xA559FBC1, 0xA55AFBC1, 0xA55BFBC1, 0xA55CFBC1, 0xA55DFBC1, 0xA55EFBC1, 0xA55FFBC1, 0xA560FBC1, 0xA561FBC1, 0xA562FBC1, 0xA563FBC1, /* A4B1 */
+ 0xA564FBC1, 0xA565FBC1, 0xA566FBC1, 0xA567FBC1, 0xA568FBC1, 0xA569FBC1, 0xA56AFBC1, 0xA56BFBC1, 0xA56CFBC1, 0xA56DFBC1, 0xA56EFBC1, 0xA56FFBC1, 0xA570FBC1, 0xA571FBC1, 0xA572FBC1, 0xA573FBC1, 0xA574FBC1, 0xA575FBC1, 0xA576FBC1, 0xA577FBC1, 0xA578FBC1, 0xA579FBC1, 0xA57AFBC1, 0xA57BFBC1, 0xA57CFBC1, 0xA57DFBC1, 0xA57EFBC1, 0xA57FFBC1, 0xA580FBC1, 0xA581FBC1, 0xA582FBC1, 0xA583FBC1, 0xA584FBC1, 0xA585FBC1, 0xA586FBC1, 0xA587FBC1, 0xA588FBC1, 0xA589FBC1, 0xA58AFBC1, 0xA58BFBC1, 0xA58CFBC1, 0xA58DFBC1, 0xA58EFBC1, 0xA58FFBC1, 0xA590FBC1, 0xA591FBC1, 0xA592FBC1, 0xA593FBC1, 0xA594FBC1, 0xA595FBC1, 0xA596FBC1, 0xA597FBC1, 0xA598FBC1, 0xA599FBC1, 0xA59AFBC1, 0xA59BFBC1, 0xA59CFBC1, 0xA59DFBC1, 0xA59EFBC1, 0xA59FFBC1, 0xA5A0FBC1, 0xA5A1FBC1, 0xA5A2FBC1, 0xA5A3FBC1, 0xA5A4FBC1, 0xA5A5FBC1, 0xA5A6FBC1, 0xA5A7FBC1, 0xA5A8FBC1, 0xA5A9FBC1, 0xA5AAFBC1, 0xA5ABFBC1, 0xA5ACFBC1, 0xA5ADFBC1, 0xA5AEFBC1, 0xA5AFFBC1, 0xA5B0FBC1, 0xA5B1FBC1, 0xA5B2FBC1, 0xA5B3FBC1, 0xA5B4FBC1, 0xA5B5FBC1, 0xA5B6FBC1, 0xA5B7FBC1, 0xA5B8FBC1, 0xA5B9FBC1, 0xA5BAFBC1, 0xA5BBFBC1, 0xA5BCFBC1, 0xA5BDFBC1, 0xA5BEFBC1, 0xA5BFFBC1, 0xA5C0FBC1, 0xA5C1FBC1, 0xA5C2FBC1, 0xA5C3FBC1, 0xA5C4FBC1, 0xA5C5FBC1, 0xA5C6FBC1, 0xA5C7FBC1, 0xA5C8FBC1, 0xA5C9FBC1, 0xA5CAFBC1, 0xA5CBFBC1, 0xA5CCFBC1, 0xA5CDFBC1, 0xA5CEFBC1, 0xA5CFFBC1, 0xA5D0FBC1, 0xA5D1FBC1, 0xA5D2FBC1, 0xA5D3FBC1, 0xA5D4FBC1, 0xA5D5FBC1, 0xA5D6FBC1, 0xA5D7FBC1, 0xA5D8FBC1, 0xA5D9FBC1, 0xA5DAFBC1, 0xA5DBFBC1, 0xA5DCFBC1, 0xA5DDFBC1, 0xA5DEFBC1, 0xA5DFFBC1, 0xA5E0FBC1, 0xA5E1FBC1, 0xA5E2FBC1, 0xA5E3FBC1, 0xA5E4FBC1, 0xA5E5FBC1, 0xA5E6FBC1, 0xA5E7FBC1, 0xA5E8FBC1, 0xA5E9FBC1, 0xA5EAFBC1, 0xA5EBFBC1, 0xA5ECFBC1, 0xA5EDFBC1, 0xA5EEFBC1, 0xA5EFFBC1, 0xA5F0FBC1, 0xA5F1FBC1, 0xA5F2FBC1, 0xA5F3FBC1, 0xA5F4FBC1, 0xA5F5FBC1, 0xA5F6FBC1, 0xA5F7FBC1, 0xA5F8FBC1, 0xA5F9FBC1, 0xA5FAFBC1, 0xA5FBFBC1, 0xA5FCFBC1, 0xA5FDFBC1, 0xA5FEFBC1, 0xA5FFFBC1, 0xA600FBC1, 0xA601FBC1, 0xA602FBC1, 0xA603FBC1, 0xA604FBC1, 0xA605FBC1, 0xA606FBC1, 0xA607FBC1, 0xA608FBC1, 0xA609FBC1, 0xA60AFBC1, 0xA60BFBC1, 0xA60CFBC1, 0xA60DFBC1, /* A564 */
+ 0xA60EFBC1, 0xA60FFBC1, 0xA610FBC1, 0xA611FBC1, 0xA612FBC1, 0xA613FBC1, 0xA614FBC1, 0xA615FBC1, 0xA616FBC1, 0xA617FBC1, 0xA618FBC1, 0xA619FBC1, 0xA61AFBC1, 0xA61BFBC1, 0xA61CFBC1, 0xA61DFBC1, 0xA61EFBC1, 0xA61FFBC1, 0xA620FBC1, 0xA621FBC1, 0xA622FBC1, 0xA623FBC1, 0xA624FBC1, 0xA625FBC1, 0xA626FBC1, 0xA627FBC1, 0xA628FBC1, 0xA629FBC1, 0xA62AFBC1, 0xA62BFBC1, 0xA62CFBC1, 0xA62DFBC1, 0xA62EFBC1, 0xA62FFBC1, 0xA630FBC1, 0xA631FBC1, 0xA632FBC1, 0xA633FBC1, 0xA634FBC1, 0xA635FBC1, 0xA636FBC1, 0xA637FBC1, 0xA638FBC1, 0xA639FBC1, 0xA63AFBC1, 0xA63BFBC1, 0xA63CFBC1, 0xA63DFBC1, 0xA63EFBC1, 0xA63FFBC1, 0xA640FBC1, 0xA641FBC1, 0xA642FBC1, 0xA643FBC1, 0xA644FBC1, 0xA645FBC1, 0xA646FBC1, 0xA647FBC1, 0xA648FBC1, 0xA649FBC1, 0xA64AFBC1, 0xA64BFBC1, 0xA64CFBC1, 0xA64DFBC1, 0xA64EFBC1, 0xA64FFBC1, 0xA650FBC1, 0xA651FBC1, 0xA652FBC1, 0xA653FBC1, 0xA654FBC1, 0xA655FBC1, 0xA656FBC1, 0xA657FBC1, 0xA658FBC1, 0xA659FBC1, 0xA65AFBC1, 0xA65BFBC1, 0xA65CFBC1, 0xA65DFBC1, 0xA65EFBC1, 0xA65FFBC1, 0xA660FBC1, 0xA661FBC1, 0xA662FBC1, 0xA663FBC1, 0xA664FBC1, 0xA665FBC1, 0xA666FBC1, 0xA667FBC1, 0xA668FBC1, 0xA669FBC1, 0xA66AFBC1, 0xA66BFBC1, 0xA66CFBC1, 0xA66DFBC1, 0xA66EFBC1, 0xA66FFBC1, 0xA670FBC1, 0xA671FBC1, 0xA672FBC1, 0xA673FBC1, 0xA674FBC1, 0xA675FBC1, 0xA676FBC1, 0xA677FBC1, 0xA678FBC1, 0xA679FBC1, 0xA67AFBC1, 0xA67BFBC1, 0xA67CFBC1, 0xA67DFBC1, 0xA67EFBC1, 0xA67FFBC1, 0xA680FBC1, 0xA681FBC1, 0xA682FBC1, 0xA683FBC1, 0xA684FBC1, 0xA685FBC1, 0xA686FBC1, 0xA687FBC1, 0xA688FBC1, 0xA689FBC1, 0xA68AFBC1, 0xA68BFBC1, 0xA68CFBC1, 0xA68DFBC1, 0xA68EFBC1, 0xA68FFBC1, 0xA690FBC1, 0xA691FBC1, 0xA692FBC1, 0xA693FBC1, 0xA694FBC1, 0xA695FBC1, 0xA696FBC1, 0xA697FBC1, 0xA698FBC1, 0xA699FBC1, 0xA69AFBC1, 0xA69BFBC1, 0xA69CFBC1, 0xA69DFBC1, 0xA69EFBC1, 0xA69FFBC1, 0xA6A0FBC1, 0xA6A1FBC1, 0xA6A2FBC1, 0xA6A3FBC1, 0xA6A4FBC1, 0xA6A5FBC1, 0xA6A6FBC1, 0xA6A7FBC1, 0xA6A8FBC1, 0xA6A9FBC1, 0xA6AAFBC1, 0xA6ABFBC1, 0xA6ACFBC1, 0xA6ADFBC1, 0xA6AEFBC1, 0xA6AFFBC1, 0xA6B0FBC1, 0xA6B1FBC1, 0xA6B2FBC1, 0xA6B3FBC1, 0xA6B4FBC1, 0xA6B5FBC1, 0xA6B6FBC1, 0xA6B7FBC1, /* A60E */
+ 0xA6B8FBC1, 0xA6B9FBC1, 0xA6BAFBC1, 0xA6BBFBC1, 0xA6BCFBC1, 0xA6BDFBC1, 0xA6BEFBC1, 0xA6BFFBC1, 0xA6C0FBC1, 0xA6C1FBC1, 0xA6C2FBC1, 0xA6C3FBC1, 0xA6C4FBC1, 0xA6C5FBC1, 0xA6C6FBC1, 0xA6C7FBC1, 0xA6C8FBC1, 0xA6C9FBC1, 0xA6CAFBC1, 0xA6CBFBC1, 0xA6CCFBC1, 0xA6CDFBC1, 0xA6CEFBC1, 0xA6CFFBC1, 0xA6D0FBC1, 0xA6D1FBC1, 0xA6D2FBC1, 0xA6D3FBC1, 0xA6D4FBC1, 0xA6D5FBC1, 0xA6D6FBC1, 0xA6D7FBC1, 0xA6D8FBC1, 0xA6D9FBC1, 0xA6DAFBC1, 0xA6DBFBC1, 0xA6DCFBC1, 0xA6DDFBC1, 0xA6DEFBC1, 0xA6DFFBC1, 0xA6E0FBC1, 0xA6E1FBC1, 0xA6E2FBC1, 0xA6E3FBC1, 0xA6E4FBC1, 0xA6E5FBC1, 0xA6E6FBC1, 0xA6E7FBC1, 0xA6E8FBC1, 0xA6E9FBC1, 0xA6EAFBC1, 0xA6EBFBC1, 0xA6ECFBC1, 0xA6EDFBC1, 0xA6EEFBC1, 0xA6EFFBC1, 0xA6F0FBC1, 0xA6F1FBC1, 0xA6F2FBC1, 0xA6F3FBC1, 0xA6F4FBC1, 0xA6F5FBC1, 0xA6F6FBC1, 0xA6F7FBC1, 0xA6F8FBC1, 0xA6F9FBC1, 0xA6FAFBC1, 0xA6FBFBC1, 0xA6FCFBC1, 0xA6FDFBC1, 0xA6FEFBC1, 0xA6FFFBC1, 0xA700FBC1, 0xA701FBC1, 0xA702FBC1, 0xA703FBC1, 0xA704FBC1, 0xA705FBC1, 0xA706FBC1, 0xA707FBC1, 0xA708FBC1, 0xA709FBC1, 0xA70AFBC1, 0xA70BFBC1, 0xA70CFBC1, 0xA70DFBC1, 0xA70EFBC1, 0xA70FFBC1, 0xA710FBC1, 0xA711FBC1, 0xA712FBC1, 0xA713FBC1, 0xA714FBC1, 0xA715FBC1, 0xA716FBC1, 0xA717FBC1, 0xA718FBC1, 0xA719FBC1, 0xA71AFBC1, 0xA71BFBC1, 0xA71CFBC1, 0xA71DFBC1, 0xA71EFBC1, 0xA71FFBC1, 0xA720FBC1, 0xA721FBC1, 0xA722FBC1, 0xA723FBC1, 0xA724FBC1, 0xA725FBC1, 0xA726FBC1, 0xA727FBC1, 0xA728FBC1, 0xA729FBC1, 0xA72AFBC1, 0xA72BFBC1, 0xA72CFBC1, 0xA72DFBC1, 0xA72EFBC1, 0xA72FFBC1, 0xA730FBC1, 0xA731FBC1, 0xA732FBC1, 0xA733FBC1, 0xA734FBC1, 0xA735FBC1, 0xA736FBC1, 0xA737FBC1, 0xA738FBC1, 0xA739FBC1, 0xA73AFBC1, 0xA73BFBC1, 0xA73CFBC1, 0xA73DFBC1, 0xA73EFBC1, 0xA73FFBC1, 0xA740FBC1, 0xA741FBC1, 0xA742FBC1, 0xA743FBC1, 0xA744FBC1, 0xA745FBC1, 0xA746FBC1, 0xA747FBC1, 0xA748FBC1, 0xA749FBC1, 0xA74AFBC1, 0xA74BFBC1, 0xA74CFBC1, 0xA74DFBC1, 0xA74EFBC1, 0xA74FFBC1, 0xA750FBC1, 0xA751FBC1, 0xA752FBC1, 0xA753FBC1, 0xA754FBC1, 0xA755FBC1, 0xA756FBC1, 0xA757FBC1, 0xA758FBC1, 0xA759FBC1, 0xA75AFBC1, 0xA75BFBC1, 0xA75CFBC1, 0xA75DFBC1, 0xA75EFBC1, 0xA75FFBC1, 0xA760FBC1, 0xA761FBC1, /* A6B8 */
+ 0xA762FBC1, 0xA763FBC1, 0xA764FBC1, 0xA765FBC1, 0xA766FBC1, 0xA767FBC1, 0xA768FBC1, 0xA769FBC1, 0xA76AFBC1, 0xA76BFBC1, 0xA76CFBC1, 0xA76DFBC1, 0xA76EFBC1, 0xA76FFBC1, 0xA770FBC1, 0xA771FBC1, 0xA772FBC1, 0xA773FBC1, 0xA774FBC1, 0xA775FBC1, 0xA776FBC1, 0xA777FBC1, 0xA778FBC1, 0xA779FBC1, 0xA77AFBC1, 0xA77BFBC1, 0xA77CFBC1, 0xA77DFBC1, 0xA77EFBC1, 0xA77FFBC1, 0xA780FBC1, 0xA781FBC1, 0xA782FBC1, 0xA783FBC1, 0xA784FBC1, 0xA785FBC1, 0xA786FBC1, 0xA787FBC1, 0xA788FBC1, 0xA789FBC1, 0xA78AFBC1, 0xA78BFBC1, 0xA78CFBC1, 0xA78DFBC1, 0xA78EFBC1, 0xA78FFBC1, 0xA790FBC1, 0xA791FBC1, 0xA792FBC1, 0xA793FBC1, 0xA794FBC1, 0xA795FBC1, 0xA796FBC1, 0xA797FBC1, 0xA798FBC1, 0xA799FBC1, 0xA79AFBC1, 0xA79BFBC1, 0xA79CFBC1, 0xA79DFBC1, 0xA79EFBC1, 0xA79FFBC1, 0xA7A0FBC1, 0xA7A1FBC1, 0xA7A2FBC1, 0xA7A3FBC1, 0xA7A4FBC1, 0xA7A5FBC1, 0xA7A6FBC1, 0xA7A7FBC1, 0xA7A8FBC1, 0xA7A9FBC1, 0xA7AAFBC1, 0xA7ABFBC1, 0xA7ACFBC1, 0xA7ADFBC1, 0xA7AEFBC1, 0xA7AFFBC1, 0xA7B0FBC1, 0xA7B1FBC1, 0xA7B2FBC1, 0xA7B3FBC1, 0xA7B4FBC1, 0xA7B5FBC1, 0xA7B6FBC1, 0xA7B7FBC1, 0xA7B8FBC1, 0xA7B9FBC1, 0xA7BAFBC1, 0xA7BBFBC1, 0xA7BCFBC1, 0xA7BDFBC1, 0xA7BEFBC1, 0xA7BFFBC1, 0xA7C0FBC1, 0xA7C1FBC1, 0xA7C2FBC1, 0xA7C3FBC1, 0xA7C4FBC1, 0xA7C5FBC1, 0xA7C6FBC1, 0xA7C7FBC1, 0xA7C8FBC1, 0xA7C9FBC1, 0xA7CAFBC1, 0xA7CBFBC1, 0xA7CCFBC1, 0xA7CDFBC1, 0xA7CEFBC1, 0xA7CFFBC1, 0xA7D0FBC1, 0xA7D1FBC1, 0xA7D2FBC1, 0xA7D3FBC1, 0xA7D4FBC1, 0xA7D5FBC1, 0xA7D6FBC1, 0xA7D7FBC1, 0xA7D8FBC1, 0xA7D9FBC1, 0xA7DAFBC1, 0xA7DBFBC1, 0xA7DCFBC1, 0xA7DDFBC1, 0xA7DEFBC1, 0xA7DFFBC1, 0xA7E0FBC1, 0xA7E1FBC1, 0xA7E2FBC1, 0xA7E3FBC1, 0xA7E4FBC1, 0xA7E5FBC1, 0xA7E6FBC1, 0xA7E7FBC1, 0xA7E8FBC1, 0xA7E9FBC1, 0xA7EAFBC1, 0xA7EBFBC1, 0xA7ECFBC1, 0xA7EDFBC1, 0xA7EEFBC1, 0xA7EFFBC1, 0xA7F0FBC1, 0xA7F1FBC1, 0xA7F2FBC1, 0xA7F3FBC1, 0xA7F4FBC1, 0xA7F5FBC1, 0xA7F6FBC1, 0xA7F7FBC1, 0xA7F8FBC1, 0xA7F9FBC1, 0xA7FAFBC1, 0xA7FBFBC1, 0xA7FCFBC1, 0xA7FDFBC1, 0xA7FEFBC1, 0xA7FFFBC1, 0xA800FBC1, 0xA801FBC1, 0xA802FBC1, 0xA803FBC1, 0xA804FBC1, 0xA805FBC1, 0xA806FBC1, 0xA807FBC1, 0xA808FBC1, 0xA809FBC1, 0xA80AFBC1, 0xA80BFBC1, /* A762 */
+ 0xA80CFBC1, 0xA80DFBC1, 0xA80EFBC1, 0xA80FFBC1, 0xA810FBC1, 0xA811FBC1, 0xA812FBC1, 0xA813FBC1, 0xA814FBC1, 0xA815FBC1, 0xA816FBC1, 0xA817FBC1, 0xA818FBC1, 0xA819FBC1, 0xA81AFBC1, 0xA81BFBC1, 0xA81CFBC1, 0xA81DFBC1, 0xA81EFBC1, 0xA81FFBC1, 0xA820FBC1, 0xA821FBC1, 0xA822FBC1, 0xA823FBC1, 0xA824FBC1, 0xA825FBC1, 0xA826FBC1, 0xA827FBC1, 0xA828FBC1, 0xA829FBC1, 0xA82AFBC1, 0xA82BFBC1, 0xA82CFBC1, 0xA82DFBC1, 0xA82EFBC1, 0xA82FFBC1, 0xA830FBC1, 0xA831FBC1, 0xA832FBC1, 0xA833FBC1, 0xA834FBC1, 0xA835FBC1, 0xA836FBC1, 0xA837FBC1, 0xA838FBC1, 0xA839FBC1, 0xA83AFBC1, 0xA83BFBC1, 0xA83CFBC1, 0xA83DFBC1, 0xA83EFBC1, 0xA83FFBC1, 0xA840FBC1, 0xA841FBC1, 0xA842FBC1, 0xA843FBC1, 0xA844FBC1, 0xA845FBC1, 0xA846FBC1, 0xA847FBC1, 0xA848FBC1, 0xA849FBC1, 0xA84AFBC1, 0xA84BFBC1, 0xA84CFBC1, 0xA84DFBC1, 0xA84EFBC1, 0xA84FFBC1, 0xA850FBC1, 0xA851FBC1, 0xA852FBC1, 0xA853FBC1, 0xA854FBC1, 0xA855FBC1, 0xA856FBC1, 0xA857FBC1, 0xA858FBC1, 0xA859FBC1, 0xA85AFBC1, 0xA85BFBC1, 0xA85CFBC1, 0xA85DFBC1, 0xA85EFBC1, 0xA85FFBC1, 0xA860FBC1, 0xA861FBC1, 0xA862FBC1, 0xA863FBC1, 0xA864FBC1, 0xA865FBC1, 0xA866FBC1, 0xA867FBC1, 0xA868FBC1, 0xA869FBC1, 0xA86AFBC1, 0xA86BFBC1, 0xA86CFBC1, 0xA86DFBC1, 0xA86EFBC1, 0xA86FFBC1, 0xA870FBC1, 0xA871FBC1, 0xA872FBC1, 0xA873FBC1, 0xA874FBC1, 0xA875FBC1, 0xA876FBC1, 0xA877FBC1, 0xA878FBC1, 0xA879FBC1, 0xA87AFBC1, 0xA87BFBC1, 0xA87CFBC1, 0xA87DFBC1, 0xA87EFBC1, 0xA87FFBC1, 0xA880FBC1, 0xA881FBC1, 0xA882FBC1, 0xA883FBC1, 0xA884FBC1, 0xA885FBC1, 0xA886FBC1, 0xA887FBC1, 0xA888FBC1, 0xA889FBC1, 0xA88AFBC1, 0xA88BFBC1, 0xA88CFBC1, 0xA88DFBC1, 0xA88EFBC1, 0xA88FFBC1, 0xA890FBC1, 0xA891FBC1, 0xA892FBC1, 0xA893FBC1, 0xA894FBC1, 0xA895FBC1, 0xA896FBC1, 0xA897FBC1, 0xA898FBC1, 0xA899FBC1, 0xA89AFBC1, 0xA89BFBC1, 0xA89CFBC1, 0xA89DFBC1, 0xA89EFBC1, 0xA89FFBC1, 0xA8A0FBC1, 0xA8A1FBC1, 0xA8A2FBC1, 0xA8A3FBC1, 0xA8A4FBC1, 0xA8A5FBC1, 0xA8A6FBC1, 0xA8A7FBC1, 0xA8A8FBC1, 0xA8A9FBC1, 0xA8AAFBC1, 0xA8ABFBC1, 0xA8ACFBC1, 0xA8ADFBC1, 0xA8AEFBC1, 0xA8AFFBC1, 0xA8B0FBC1, 0xA8B1FBC1, 0xA8B2FBC1, 0xA8B3FBC1, 0xA8B4FBC1, 0xA8B5FBC1, /* A80C */
+ 0xA8B6FBC1, 0xA8B7FBC1, 0xA8B8FBC1, 0xA8B9FBC1, 0xA8BAFBC1, 0xA8BBFBC1, 0xA8BCFBC1, 0xA8BDFBC1, 0xA8BEFBC1, 0xA8BFFBC1, 0xA8C0FBC1, 0xA8C1FBC1, 0xA8C2FBC1, 0xA8C3FBC1, 0xA8C4FBC1, 0xA8C5FBC1, 0xA8C6FBC1, 0xA8C7FBC1, 0xA8C8FBC1, 0xA8C9FBC1, 0xA8CAFBC1, 0xA8CBFBC1, 0xA8CCFBC1, 0xA8CDFBC1, 0xA8CEFBC1, 0xA8CFFBC1, 0xA8D0FBC1, 0xA8D1FBC1, 0xA8D2FBC1, 0xA8D3FBC1, 0xA8D4FBC1, 0xA8D5FBC1, 0xA8D6FBC1, 0xA8D7FBC1, 0xA8D8FBC1, 0xA8D9FBC1, 0xA8DAFBC1, 0xA8DBFBC1, 0xA8DCFBC1, 0xA8DDFBC1, 0xA8DEFBC1, 0xA8DFFBC1, 0xA8E0FBC1, 0xA8E1FBC1, 0xA8E2FBC1, 0xA8E3FBC1, 0xA8E4FBC1, 0xA8E5FBC1, 0xA8E6FBC1, 0xA8E7FBC1, 0xA8E8FBC1, 0xA8E9FBC1, 0xA8EAFBC1, 0xA8EBFBC1, 0xA8ECFBC1, 0xA8EDFBC1, 0xA8EEFBC1, 0xA8EFFBC1, 0xA8F0FBC1, 0xA8F1FBC1, 0xA8F2FBC1, 0xA8F3FBC1, 0xA8F4FBC1, 0xA8F5FBC1, 0xA8F6FBC1, 0xA8F7FBC1, 0xA8F8FBC1, 0xA8F9FBC1, 0xA8FAFBC1, 0xA8FBFBC1, 0xA8FCFBC1, 0xA8FDFBC1, 0xA8FEFBC1, 0xA8FFFBC1, 0xA900FBC1, 0xA901FBC1, 0xA902FBC1, 0xA903FBC1, 0xA904FBC1, 0xA905FBC1, 0xA906FBC1, 0xA907FBC1, 0xA908FBC1, 0xA909FBC1, 0xA90AFBC1, 0xA90BFBC1, 0xA90CFBC1, 0xA90DFBC1, 0xA90EFBC1, 0xA90FFBC1, 0xA910FBC1, 0xA911FBC1, 0xA912FBC1, 0xA913FBC1, 0xA914FBC1, 0xA915FBC1, 0xA916FBC1, 0xA917FBC1, 0xA918FBC1, 0xA919FBC1, 0xA91AFBC1, 0xA91BFBC1, 0xA91CFBC1, 0xA91DFBC1, 0xA91EFBC1, 0xA91FFBC1, 0xA920FBC1, 0xA921FBC1, 0xA922FBC1, 0xA923FBC1, 0xA924FBC1, 0xA925FBC1, 0xA926FBC1, 0xA927FBC1, 0xA928FBC1, 0xA929FBC1, 0xA92AFBC1, 0xA92BFBC1, 0xA92CFBC1, 0xA92DFBC1, 0xA92EFBC1, 0xA92FFBC1, 0xA930FBC1, 0xA931FBC1, 0xA932FBC1, 0xA933FBC1, 0xA934FBC1, 0xA935FBC1, 0xA936FBC1, 0xA937FBC1, 0xA938FBC1, 0xA939FBC1, 0xA93AFBC1, 0xA93BFBC1, 0xA93CFBC1, 0xA93DFBC1, 0xA93EFBC1, 0xA93FFBC1, 0xA940FBC1, 0xA941FBC1, 0xA942FBC1, 0xA943FBC1, 0xA944FBC1, 0xA945FBC1, 0xA946FBC1, 0xA947FBC1, 0xA948FBC1, 0xA949FBC1, 0xA94AFBC1, 0xA94BFBC1, 0xA94CFBC1, 0xA94DFBC1, 0xA94EFBC1, 0xA94FFBC1, 0xA950FBC1, 0xA951FBC1, 0xA952FBC1, 0xA953FBC1, 0xA954FBC1, 0xA955FBC1, 0xA956FBC1, 0xA957FBC1, 0xA958FBC1, 0xA959FBC1, 0xA95AFBC1, 0xA95BFBC1, 0xA95CFBC1, 0xA95DFBC1, 0xA95EFBC1, 0xA95FFBC1, /* A8B6 */
+ 0xA960FBC1, 0xA961FBC1, 0xA962FBC1, 0xA963FBC1, 0xA964FBC1, 0xA965FBC1, 0xA966FBC1, 0xA967FBC1, 0xA968FBC1, 0xA969FBC1, 0xA96AFBC1, 0xA96BFBC1, 0xA96CFBC1, 0xA96DFBC1, 0xA96EFBC1, 0xA96FFBC1, 0xA970FBC1, 0xA971FBC1, 0xA972FBC1, 0xA973FBC1, 0xA974FBC1, 0xA975FBC1, 0xA976FBC1, 0xA977FBC1, 0xA978FBC1, 0xA979FBC1, 0xA97AFBC1, 0xA97BFBC1, 0xA97CFBC1, 0xA97DFBC1, 0xA97EFBC1, 0xA97FFBC1, 0xA980FBC1, 0xA981FBC1, 0xA982FBC1, 0xA983FBC1, 0xA984FBC1, 0xA985FBC1, 0xA986FBC1, 0xA987FBC1, 0xA988FBC1, 0xA989FBC1, 0xA98AFBC1, 0xA98BFBC1, 0xA98CFBC1, 0xA98DFBC1, 0xA98EFBC1, 0xA98FFBC1, 0xA990FBC1, 0xA991FBC1, 0xA992FBC1, 0xA993FBC1, 0xA994FBC1, 0xA995FBC1, 0xA996FBC1, 0xA997FBC1, 0xA998FBC1, 0xA999FBC1, 0xA99AFBC1, 0xA99BFBC1, 0xA99CFBC1, 0xA99DFBC1, 0xA99EFBC1, 0xA99FFBC1, 0xA9A0FBC1, 0xA9A1FBC1, 0xA9A2FBC1, 0xA9A3FBC1, 0xA9A4FBC1, 0xA9A5FBC1, 0xA9A6FBC1, 0xA9A7FBC1, 0xA9A8FBC1, 0xA9A9FBC1, 0xA9AAFBC1, 0xA9ABFBC1, 0xA9ACFBC1, 0xA9ADFBC1, 0xA9AEFBC1, 0xA9AFFBC1, 0xA9B0FBC1, 0xA9B1FBC1, 0xA9B2FBC1, 0xA9B3FBC1, 0xA9B4FBC1, 0xA9B5FBC1, 0xA9B6FBC1, 0xA9B7FBC1, 0xA9B8FBC1, 0xA9B9FBC1, 0xA9BAFBC1, 0xA9BBFBC1, 0xA9BCFBC1, 0xA9BDFBC1, 0xA9BEFBC1, 0xA9BFFBC1, 0xA9C0FBC1, 0xA9C1FBC1, 0xA9C2FBC1, 0xA9C3FBC1, 0xA9C4FBC1, 0xA9C5FBC1, 0xA9C6FBC1, 0xA9C7FBC1, 0xA9C8FBC1, 0xA9C9FBC1, 0xA9CAFBC1, 0xA9CBFBC1, 0xA9CCFBC1, 0xA9CDFBC1, 0xA9CEFBC1, 0xA9CFFBC1, 0xA9D0FBC1, 0xA9D1FBC1, 0xA9D2FBC1, 0xA9D3FBC1, 0xA9D4FBC1, 0xA9D5FBC1, 0xA9D6FBC1, 0xA9D7FBC1, 0xA9D8FBC1, 0xA9D9FBC1, 0xA9DAFBC1, 0xA9DBFBC1, 0xA9DCFBC1, 0xA9DDFBC1, 0xA9DEFBC1, 0xA9DFFBC1, 0xA9E0FBC1, 0xA9E1FBC1, 0xA9E2FBC1, 0xA9E3FBC1, 0xA9E4FBC1, 0xA9E5FBC1, 0xA9E6FBC1, 0xA9E7FBC1, 0xA9E8FBC1, 0xA9E9FBC1, 0xA9EAFBC1, 0xA9EBFBC1, 0xA9ECFBC1, 0xA9EDFBC1, 0xA9EEFBC1, 0xA9EFFBC1, 0xA9F0FBC1, 0xA9F1FBC1, 0xA9F2FBC1, 0xA9F3FBC1, 0xA9F4FBC1, 0xA9F5FBC1, 0xA9F6FBC1, 0xA9F7FBC1, 0xA9F8FBC1, 0xA9F9FBC1, 0xA9FAFBC1, 0xA9FBFBC1, 0xA9FCFBC1, 0xA9FDFBC1, 0xA9FEFBC1, 0xA9FFFBC1, 0xAA00FBC1, 0xAA01FBC1, 0xAA02FBC1, 0xAA03FBC1, 0xAA04FBC1, 0xAA05FBC1, 0xAA06FBC1, 0xAA07FBC1, 0xAA08FBC1, 0xAA09FBC1, /* A960 */
+ 0xAA0AFBC1, 0xAA0BFBC1, 0xAA0CFBC1, 0xAA0DFBC1, 0xAA0EFBC1, 0xAA0FFBC1, 0xAA10FBC1, 0xAA11FBC1, 0xAA12FBC1, 0xAA13FBC1, 0xAA14FBC1, 0xAA15FBC1, 0xAA16FBC1, 0xAA17FBC1, 0xAA18FBC1, 0xAA19FBC1, 0xAA1AFBC1, 0xAA1BFBC1, 0xAA1CFBC1, 0xAA1DFBC1, 0xAA1EFBC1, 0xAA1FFBC1, 0xAA20FBC1, 0xAA21FBC1, 0xAA22FBC1, 0xAA23FBC1, 0xAA24FBC1, 0xAA25FBC1, 0xAA26FBC1, 0xAA27FBC1, 0xAA28FBC1, 0xAA29FBC1, 0xAA2AFBC1, 0xAA2BFBC1, 0xAA2CFBC1, 0xAA2DFBC1, 0xAA2EFBC1, 0xAA2FFBC1, 0xAA30FBC1, 0xAA31FBC1, 0xAA32FBC1, 0xAA33FBC1, 0xAA34FBC1, 0xAA35FBC1, 0xAA36FBC1, 0xAA37FBC1, 0xAA38FBC1, 0xAA39FBC1, 0xAA3AFBC1, 0xAA3BFBC1, 0xAA3CFBC1, 0xAA3DFBC1, 0xAA3EFBC1, 0xAA3FFBC1, 0xAA40FBC1, 0xAA41FBC1, 0xAA42FBC1, 0xAA43FBC1, 0xAA44FBC1, 0xAA45FBC1, 0xAA46FBC1, 0xAA47FBC1, 0xAA48FBC1, 0xAA49FBC1, 0xAA4AFBC1, 0xAA4BFBC1, 0xAA4CFBC1, 0xAA4DFBC1, 0xAA4EFBC1, 0xAA4FFBC1, 0xAA50FBC1, 0xAA51FBC1, 0xAA52FBC1, 0xAA53FBC1, 0xAA54FBC1, 0xAA55FBC1, 0xAA56FBC1, 0xAA57FBC1, 0xAA58FBC1, 0xAA59FBC1, 0xAA5AFBC1, 0xAA5BFBC1, 0xAA5CFBC1, 0xAA5DFBC1, 0xAA5EFBC1, 0xAA5FFBC1, 0xAA60FBC1, 0xAA61FBC1, 0xAA62FBC1, 0xAA63FBC1, 0xAA64FBC1, 0xAA65FBC1, 0xAA66FBC1, 0xAA67FBC1, 0xAA68FBC1, 0xAA69FBC1, 0xAA6AFBC1, 0xAA6BFBC1, 0xAA6CFBC1, 0xAA6DFBC1, 0xAA6EFBC1, 0xAA6FFBC1, 0xAA70FBC1, 0xAA71FBC1, 0xAA72FBC1, 0xAA73FBC1, 0xAA74FBC1, 0xAA75FBC1, 0xAA76FBC1, 0xAA77FBC1, 0xAA78FBC1, 0xAA79FBC1, 0xAA7AFBC1, 0xAA7BFBC1, 0xAA7CFBC1, 0xAA7DFBC1, 0xAA7EFBC1, 0xAA7FFBC1, 0xAA80FBC1, 0xAA81FBC1, 0xAA82FBC1, 0xAA83FBC1, 0xAA84FBC1, 0xAA85FBC1, 0xAA86FBC1, 0xAA87FBC1, 0xAA88FBC1, 0xAA89FBC1, 0xAA8AFBC1, 0xAA8BFBC1, 0xAA8CFBC1, 0xAA8DFBC1, 0xAA8EFBC1, 0xAA8FFBC1, 0xAA90FBC1, 0xAA91FBC1, 0xAA92FBC1, 0xAA93FBC1, 0xAA94FBC1, 0xAA95FBC1, 0xAA96FBC1, 0xAA97FBC1, 0xAA98FBC1, 0xAA99FBC1, 0xAA9AFBC1, 0xAA9BFBC1, 0xAA9CFBC1, 0xAA9DFBC1, 0xAA9EFBC1, 0xAA9FFBC1, 0xAAA0FBC1, 0xAAA1FBC1, 0xAAA2FBC1, 0xAAA3FBC1, 0xAAA4FBC1, 0xAAA5FBC1, 0xAAA6FBC1, 0xAAA7FBC1, 0xAAA8FBC1, 0xAAA9FBC1, 0xAAAAFBC1, 0xAAABFBC1, 0xAAACFBC1, 0xAAADFBC1, 0xAAAEFBC1, 0xAAAFFBC1, 0xAAB0FBC1, 0xAAB1FBC1, 0xAAB2FBC1, 0xAAB3FBC1, /* AA0A */
+ 0xAAB4FBC1, 0xAAB5FBC1, 0xAAB6FBC1, 0xAAB7FBC1, 0xAAB8FBC1, 0xAAB9FBC1, 0xAABAFBC1, 0xAABBFBC1, 0xAABCFBC1, 0xAABDFBC1, 0xAABEFBC1, 0xAABFFBC1, 0xAAC0FBC1, 0xAAC1FBC1, 0xAAC2FBC1, 0xAAC3FBC1, 0xAAC4FBC1, 0xAAC5FBC1, 0xAAC6FBC1, 0xAAC7FBC1, 0xAAC8FBC1, 0xAAC9FBC1, 0xAACAFBC1, 0xAACBFBC1, 0xAACCFBC1, 0xAACDFBC1, 0xAACEFBC1, 0xAACFFBC1, 0xAAD0FBC1, 0xAAD1FBC1, 0xAAD2FBC1, 0xAAD3FBC1, 0xAAD4FBC1, 0xAAD5FBC1, 0xAAD6FBC1, 0xAAD7FBC1, 0xAAD8FBC1, 0xAAD9FBC1, 0xAADAFBC1, 0xAADBFBC1, 0xAADCFBC1, 0xAADDFBC1, 0xAADEFBC1, 0xAADFFBC1, 0xAAE0FBC1, 0xAAE1FBC1, 0xAAE2FBC1, 0xAAE3FBC1, 0xAAE4FBC1, 0xAAE5FBC1, 0xAAE6FBC1, 0xAAE7FBC1, 0xAAE8FBC1, 0xAAE9FBC1, 0xAAEAFBC1, 0xAAEBFBC1, 0xAAECFBC1, 0xAAEDFBC1, 0xAAEEFBC1, 0xAAEFFBC1, 0xAAF0FBC1, 0xAAF1FBC1, 0xAAF2FBC1, 0xAAF3FBC1, 0xAAF4FBC1, 0xAAF5FBC1, 0xAAF6FBC1, 0xAAF7FBC1, 0xAAF8FBC1, 0xAAF9FBC1, 0xAAFAFBC1, 0xAAFBFBC1, 0xAAFCFBC1, 0xAAFDFBC1, 0xAAFEFBC1, 0xAAFFFBC1, 0xAB00FBC1, 0xAB01FBC1, 0xAB02FBC1, 0xAB03FBC1, 0xAB04FBC1, 0xAB05FBC1, 0xAB06FBC1, 0xAB07FBC1, 0xAB08FBC1, 0xAB09FBC1, 0xAB0AFBC1, 0xAB0BFBC1, 0xAB0CFBC1, 0xAB0DFBC1, 0xAB0EFBC1, 0xAB0FFBC1, 0xAB10FBC1, 0xAB11FBC1, 0xAB12FBC1, 0xAB13FBC1, 0xAB14FBC1, 0xAB15FBC1, 0xAB16FBC1, 0xAB17FBC1, 0xAB18FBC1, 0xAB19FBC1, 0xAB1AFBC1, 0xAB1BFBC1, 0xAB1CFBC1, 0xAB1DFBC1, 0xAB1EFBC1, 0xAB1FFBC1, 0xAB20FBC1, 0xAB21FBC1, 0xAB22FBC1, 0xAB23FBC1, 0xAB24FBC1, 0xAB25FBC1, 0xAB26FBC1, 0xAB27FBC1, 0xAB28FBC1, 0xAB29FBC1, 0xAB2AFBC1, 0xAB2BFBC1, 0xAB2CFBC1, 0xAB2DFBC1, 0xAB2EFBC1, 0xAB2FFBC1, 0xAB30FBC1, 0xAB31FBC1, 0xAB32FBC1, 0xAB33FBC1, 0xAB34FBC1, 0xAB35FBC1, 0xAB36FBC1, 0xAB37FBC1, 0xAB38FBC1, 0xAB39FBC1, 0xAB3AFBC1, 0xAB3BFBC1, 0xAB3CFBC1, 0xAB3DFBC1, 0xAB3EFBC1, 0xAB3FFBC1, 0xAB40FBC1, 0xAB41FBC1, 0xAB42FBC1, 0xAB43FBC1, 0xAB44FBC1, 0xAB45FBC1, 0xAB46FBC1, 0xAB47FBC1, 0xAB48FBC1, 0xAB49FBC1, 0xAB4AFBC1, 0xAB4BFBC1, 0xAB4CFBC1, 0xAB4DFBC1, 0xAB4EFBC1, 0xAB4FFBC1, 0xAB50FBC1, 0xAB51FBC1, 0xAB52FBC1, 0xAB53FBC1, 0xAB54FBC1, 0xAB55FBC1, 0xAB56FBC1, 0xAB57FBC1, 0xAB58FBC1, 0xAB59FBC1, 0xAB5AFBC1, 0xAB5BFBC1, 0xAB5CFBC1, 0xAB5DFBC1, /* AAB4 */
+ 0xAB5EFBC1, 0xAB5FFBC1, 0xAB60FBC1, 0xAB61FBC1, 0xAB62FBC1, 0xAB63FBC1, 0xAB64FBC1, 0xAB65FBC1, 0xAB66FBC1, 0xAB67FBC1, 0xAB68FBC1, 0xAB69FBC1, 0xAB6AFBC1, 0xAB6BFBC1, 0xAB6CFBC1, 0xAB6DFBC1, 0xAB6EFBC1, 0xAB6FFBC1, 0xAB70FBC1, 0xAB71FBC1, 0xAB72FBC1, 0xAB73FBC1, 0xAB74FBC1, 0xAB75FBC1, 0xAB76FBC1, 0xAB77FBC1, 0xAB78FBC1, 0xAB79FBC1, 0xAB7AFBC1, 0xAB7BFBC1, 0xAB7CFBC1, 0xAB7DFBC1, 0xAB7EFBC1, 0xAB7FFBC1, 0xAB80FBC1, 0xAB81FBC1, 0xAB82FBC1, 0xAB83FBC1, 0xAB84FBC1, 0xAB85FBC1, 0xAB86FBC1, 0xAB87FBC1, 0xAB88FBC1, 0xAB89FBC1, 0xAB8AFBC1, 0xAB8BFBC1, 0xAB8CFBC1, 0xAB8DFBC1, 0xAB8EFBC1, 0xAB8FFBC1, 0xAB90FBC1, 0xAB91FBC1, 0xAB92FBC1, 0xAB93FBC1, 0xAB94FBC1, 0xAB95FBC1, 0xAB96FBC1, 0xAB97FBC1, 0xAB98FBC1, 0xAB99FBC1, 0xAB9AFBC1, 0xAB9BFBC1, 0xAB9CFBC1, 0xAB9DFBC1, 0xAB9EFBC1, 0xAB9FFBC1, 0xABA0FBC1, 0xABA1FBC1, 0xABA2FBC1, 0xABA3FBC1, 0xABA4FBC1, 0xABA5FBC1, 0xABA6FBC1, 0xABA7FBC1, 0xABA8FBC1, 0xABA9FBC1, 0xABAAFBC1, 0xABABFBC1, 0xABACFBC1, 0xABADFBC1, 0xABAEFBC1, 0xABAFFBC1, 0xABB0FBC1, 0xABB1FBC1, 0xABB2FBC1, 0xABB3FBC1, 0xABB4FBC1, 0xABB5FBC1, 0xABB6FBC1, 0xABB7FBC1, 0xABB8FBC1, 0xABB9FBC1, 0xABBAFBC1, 0xABBBFBC1, 0xABBCFBC1, 0xABBDFBC1, 0xABBEFBC1, 0xABBFFBC1, 0xABC0FBC1, 0xABC1FBC1, 0xABC2FBC1, 0xABC3FBC1, 0xABC4FBC1, 0xABC5FBC1, 0xABC6FBC1, 0xABC7FBC1, 0xABC8FBC1, 0xABC9FBC1, 0xABCAFBC1, 0xABCBFBC1, 0xABCCFBC1, 0xABCDFBC1, 0xABCEFBC1, 0xABCFFBC1, 0xABD0FBC1, 0xABD1FBC1, 0xABD2FBC1, 0xABD3FBC1, 0xABD4FBC1, 0xABD5FBC1, 0xABD6FBC1, 0xABD7FBC1, 0xABD8FBC1, 0xABD9FBC1, 0xABDAFBC1, 0xABDBFBC1, 0xABDCFBC1, 0xABDDFBC1, 0xABDEFBC1, 0xABDFFBC1, 0xABE0FBC1, 0xABE1FBC1, 0xABE2FBC1, 0xABE3FBC1, 0xABE4FBC1, 0xABE5FBC1, 0xABE6FBC1, 0xABE7FBC1, 0xABE8FBC1, 0xABE9FBC1, 0xABEAFBC1, 0xABEBFBC1, 0xABECFBC1, 0xABEDFBC1, 0xABEEFBC1, 0xABEFFBC1, 0xABF0FBC1, 0xABF1FBC1, 0xABF2FBC1, 0xABF3FBC1, 0xABF4FBC1, 0xABF5FBC1, 0xABF6FBC1, 0xABF7FBC1, 0xABF8FBC1, 0xABF9FBC1, 0xABFAFBC1, 0xABFBFBC1, 0xABFCFBC1, 0xABFDFBC1, 0xABFEFBC1, 0xABFFFBC1, 0xAC00FBC1, 0xAC01FBC1, 0xAC02FBC1, 0xAC03FBC1, 0xAC04FBC1, 0xAC05FBC1, 0xAC06FBC1, 0xAC07FBC1, /* AB5E */
+ 0xAC08FBC1, 0xAC09FBC1, 0xAC0AFBC1, 0xAC0BFBC1, 0xAC0CFBC1, 0xAC0DFBC1, 0xAC0EFBC1, 0xAC0FFBC1, 0xAC10FBC1, 0xAC11FBC1, 0xAC12FBC1, 0xAC13FBC1, 0xAC14FBC1, 0xAC15FBC1, 0xAC16FBC1, 0xAC17FBC1, 0xAC18FBC1, 0xAC19FBC1, 0xAC1AFBC1, 0xAC1BFBC1, 0xAC1CFBC1, 0xAC1DFBC1, 0xAC1EFBC1, 0xAC1FFBC1, 0xAC20FBC1, 0xAC21FBC1, 0xAC22FBC1, 0xAC23FBC1, 0xAC24FBC1, 0xAC25FBC1, 0xAC26FBC1, 0xAC27FBC1, 0xAC28FBC1, 0xAC29FBC1, 0xAC2AFBC1, 0xAC2BFBC1, 0xAC2CFBC1, 0xAC2DFBC1, 0xAC2EFBC1, 0xAC2FFBC1, 0xAC30FBC1, 0xAC31FBC1, 0xAC32FBC1, 0xAC33FBC1, 0xAC34FBC1, 0xAC35FBC1, 0xAC36FBC1, 0xAC37FBC1, 0xAC38FBC1, 0xAC39FBC1, 0xAC3AFBC1, 0xAC3BFBC1, 0xAC3CFBC1, 0xAC3DFBC1, 0xAC3EFBC1, 0xAC3FFBC1, 0xAC40FBC1, 0xAC41FBC1, 0xAC42FBC1, 0xAC43FBC1, 0xAC44FBC1, 0xAC45FBC1, 0xAC46FBC1, 0xAC47FBC1, 0xAC48FBC1, 0xAC49FBC1, 0xAC4AFBC1, 0xAC4BFBC1, 0xAC4CFBC1, 0xAC4DFBC1, 0xAC4EFBC1, 0xAC4FFBC1, 0xAC50FBC1, 0xAC51FBC1, 0xAC52FBC1, 0xAC53FBC1, 0xAC54FBC1, 0xAC55FBC1, 0xAC56FBC1, 0xAC57FBC1, 0xAC58FBC1, 0xAC59FBC1, 0xAC5AFBC1, 0xAC5BFBC1, 0xAC5CFBC1, 0xAC5DFBC1, 0xAC5EFBC1, 0xAC5FFBC1, 0xAC60FBC1, 0xAC61FBC1, 0xAC62FBC1, 0xAC63FBC1, 0xAC64FBC1, 0xAC65FBC1, 0xAC66FBC1, 0xAC67FBC1, 0xAC68FBC1, 0xAC69FBC1, 0xAC6AFBC1, 0xAC6BFBC1, 0xAC6CFBC1, 0xAC6DFBC1, 0xAC6EFBC1, 0xAC6FFBC1, 0xAC70FBC1, 0xAC71FBC1, 0xAC72FBC1, 0xAC73FBC1, 0xAC74FBC1, 0xAC75FBC1, 0xAC76FBC1, 0xAC77FBC1, 0xAC78FBC1, 0xAC79FBC1, 0xAC7AFBC1, 0xAC7BFBC1, 0xAC7CFBC1, 0xAC7DFBC1, 0xAC7EFBC1, 0xAC7FFBC1, 0xAC80FBC1, 0xAC81FBC1, 0xAC82FBC1, 0xAC83FBC1, 0xAC84FBC1, 0xAC85FBC1, 0xAC86FBC1, 0xAC87FBC1, 0xAC88FBC1, 0xAC89FBC1, 0xAC8AFBC1, 0xAC8BFBC1, 0xAC8CFBC1, 0xAC8DFBC1, 0xAC8EFBC1, 0xAC8FFBC1, 0xAC90FBC1, 0xAC91FBC1, 0xAC92FBC1, 0xAC93FBC1, 0xAC94FBC1, 0xAC95FBC1, 0xAC96FBC1, 0xAC97FBC1, 0xAC98FBC1, 0xAC99FBC1, 0xAC9AFBC1, 0xAC9BFBC1, 0xAC9CFBC1, 0xAC9DFBC1, 0xAC9EFBC1, 0xAC9FFBC1, 0xACA0FBC1, 0xACA1FBC1, 0xACA2FBC1, 0xACA3FBC1, 0xACA4FBC1, 0xACA5FBC1, 0xACA6FBC1, 0xACA7FBC1, 0xACA8FBC1, 0xACA9FBC1, 0xACAAFBC1, 0xACABFBC1, 0xACACFBC1, 0xACADFBC1, 0xACAEFBC1, 0xACAFFBC1, 0xACB0FBC1, 0xACB1FBC1, /* AC08 */
+ 0xACB2FBC1, 0xACB3FBC1, 0xACB4FBC1, 0xACB5FBC1, 0xACB6FBC1, 0xACB7FBC1, 0xACB8FBC1, 0xACB9FBC1, 0xACBAFBC1, 0xACBBFBC1, 0xACBCFBC1, 0xACBDFBC1, 0xACBEFBC1, 0xACBFFBC1, 0xACC0FBC1, 0xACC1FBC1, 0xACC2FBC1, 0xACC3FBC1, 0xACC4FBC1, 0xACC5FBC1, 0xACC6FBC1, 0xACC7FBC1, 0xACC8FBC1, 0xACC9FBC1, 0xACCAFBC1, 0xACCBFBC1, 0xACCCFBC1, 0xACCDFBC1, 0xACCEFBC1, 0xACCFFBC1, 0xACD0FBC1, 0xACD1FBC1, 0xACD2FBC1, 0xACD3FBC1, 0xACD4FBC1, 0xACD5FBC1, 0xACD6FBC1, 0xACD7FBC1, 0xACD8FBC1, 0xACD9FBC1, 0xACDAFBC1, 0xACDBFBC1, 0xACDCFBC1, 0xACDDFBC1, 0xACDEFBC1, 0xACDFFBC1, 0xACE0FBC1, 0xACE1FBC1, 0xACE2FBC1, 0xACE3FBC1, 0xACE4FBC1, 0xACE5FBC1, 0xACE6FBC1, 0xACE7FBC1, 0xACE8FBC1, 0xACE9FBC1, 0xACEAFBC1, 0xACEBFBC1, 0xACECFBC1, 0xACEDFBC1, 0xACEEFBC1, 0xACEFFBC1, 0xACF0FBC1, 0xACF1FBC1, 0xACF2FBC1, 0xACF3FBC1, 0xACF4FBC1, 0xACF5FBC1, 0xACF6FBC1, 0xACF7FBC1, 0xACF8FBC1, 0xACF9FBC1, 0xACFAFBC1, 0xACFBFBC1, 0xACFCFBC1, 0xACFDFBC1, 0xACFEFBC1, 0xACFFFBC1, 0xAD00FBC1, 0xAD01FBC1, 0xAD02FBC1, 0xAD03FBC1, 0xAD04FBC1, 0xAD05FBC1, 0xAD06FBC1, 0xAD07FBC1, 0xAD08FBC1, 0xAD09FBC1, 0xAD0AFBC1, 0xAD0BFBC1, 0xAD0CFBC1, 0xAD0DFBC1, 0xAD0EFBC1, 0xAD0FFBC1, 0xAD10FBC1, 0xAD11FBC1, 0xAD12FBC1, 0xAD13FBC1, 0xAD14FBC1, 0xAD15FBC1, 0xAD16FBC1, 0xAD17FBC1, 0xAD18FBC1, 0xAD19FBC1, 0xAD1AFBC1, 0xAD1BFBC1, 0xAD1CFBC1, 0xAD1DFBC1, 0xAD1EFBC1, 0xAD1FFBC1, 0xAD20FBC1, 0xAD21FBC1, 0xAD22FBC1, 0xAD23FBC1, 0xAD24FBC1, 0xAD25FBC1, 0xAD26FBC1, 0xAD27FBC1, 0xAD28FBC1, 0xAD29FBC1, 0xAD2AFBC1, 0xAD2BFBC1, 0xAD2CFBC1, 0xAD2DFBC1, 0xAD2EFBC1, 0xAD2FFBC1, 0xAD30FBC1, 0xAD31FBC1, 0xAD32FBC1, 0xAD33FBC1, 0xAD34FBC1, 0xAD35FBC1, 0xAD36FBC1, 0xAD37FBC1, 0xAD38FBC1, 0xAD39FBC1, 0xAD3AFBC1, 0xAD3BFBC1, 0xAD3CFBC1, 0xAD3DFBC1, 0xAD3EFBC1, 0xAD3FFBC1, 0xAD40FBC1, 0xAD41FBC1, 0xAD42FBC1, 0xAD43FBC1, 0xAD44FBC1, 0xAD45FBC1, 0xAD46FBC1, 0xAD47FBC1, 0xAD48FBC1, 0xAD49FBC1, 0xAD4AFBC1, 0xAD4BFBC1, 0xAD4CFBC1, 0xAD4DFBC1, 0xAD4EFBC1, 0xAD4FFBC1, 0xAD50FBC1, 0xAD51FBC1, 0xAD52FBC1, 0xAD53FBC1, 0xAD54FBC1, 0xAD55FBC1, 0xAD56FBC1, 0xAD57FBC1, 0xAD58FBC1, 0xAD59FBC1, 0xAD5AFBC1, 0xAD5BFBC1, /* ACB2 */
+ 0xAD5CFBC1, 0xAD5DFBC1, 0xAD5EFBC1, 0xAD5FFBC1, 0xAD60FBC1, 0xAD61FBC1, 0xAD62FBC1, 0xAD63FBC1, 0xAD64FBC1, 0xAD65FBC1, 0xAD66FBC1, 0xAD67FBC1, 0xAD68FBC1, 0xAD69FBC1, 0xAD6AFBC1, 0xAD6BFBC1, 0xAD6CFBC1, 0xAD6DFBC1, 0xAD6EFBC1, 0xAD6FFBC1, 0xAD70FBC1, 0xAD71FBC1, 0xAD72FBC1, 0xAD73FBC1, 0xAD74FBC1, 0xAD75FBC1, 0xAD76FBC1, 0xAD77FBC1, 0xAD78FBC1, 0xAD79FBC1, 0xAD7AFBC1, 0xAD7BFBC1, 0xAD7CFBC1, 0xAD7DFBC1, 0xAD7EFBC1, 0xAD7FFBC1, 0xAD80FBC1, 0xAD81FBC1, 0xAD82FBC1, 0xAD83FBC1, 0xAD84FBC1, 0xAD85FBC1, 0xAD86FBC1, 0xAD87FBC1, 0xAD88FBC1, 0xAD89FBC1, 0xAD8AFBC1, 0xAD8BFBC1, 0xAD8CFBC1, 0xAD8DFBC1, 0xAD8EFBC1, 0xAD8FFBC1, 0xAD90FBC1, 0xAD91FBC1, 0xAD92FBC1, 0xAD93FBC1, 0xAD94FBC1, 0xAD95FBC1, 0xAD96FBC1, 0xAD97FBC1, 0xAD98FBC1, 0xAD99FBC1, 0xAD9AFBC1, 0xAD9BFBC1, 0xAD9CFBC1, 0xAD9DFBC1, 0xAD9EFBC1, 0xAD9FFBC1, 0xADA0FBC1, 0xADA1FBC1, 0xADA2FBC1, 0xADA3FBC1, 0xADA4FBC1, 0xADA5FBC1, 0xADA6FBC1, 0xADA7FBC1, 0xADA8FBC1, 0xADA9FBC1, 0xADAAFBC1, 0xADABFBC1, 0xADACFBC1, 0xADADFBC1, 0xADAEFBC1, 0xADAFFBC1, 0xADB0FBC1, 0xADB1FBC1, 0xADB2FBC1, 0xADB3FBC1, 0xADB4FBC1, 0xADB5FBC1, 0xADB6FBC1, 0xADB7FBC1, 0xADB8FBC1, 0xADB9FBC1, 0xADBAFBC1, 0xADBBFBC1, 0xADBCFBC1, 0xADBDFBC1, 0xADBEFBC1, 0xADBFFBC1, 0xADC0FBC1, 0xADC1FBC1, 0xADC2FBC1, 0xADC3FBC1, 0xADC4FBC1, 0xADC5FBC1, 0xADC6FBC1, 0xADC7FBC1, 0xADC8FBC1, 0xADC9FBC1, 0xADCAFBC1, 0xADCBFBC1, 0xADCCFBC1, 0xADCDFBC1, 0xADCEFBC1, 0xADCFFBC1, 0xADD0FBC1, 0xADD1FBC1, 0xADD2FBC1, 0xADD3FBC1, 0xADD4FBC1, 0xADD5FBC1, 0xADD6FBC1, 0xADD7FBC1, 0xADD8FBC1, 0xADD9FBC1, 0xADDAFBC1, 0xADDBFBC1, 0xADDCFBC1, 0xADDDFBC1, 0xADDEFBC1, 0xADDFFBC1, 0xADE0FBC1, 0xADE1FBC1, 0xADE2FBC1, 0xADE3FBC1, 0xADE4FBC1, 0xADE5FBC1, 0xADE6FBC1, 0xADE7FBC1, 0xADE8FBC1, 0xADE9FBC1, 0xADEAFBC1, 0xADEBFBC1, 0xADECFBC1, 0xADEDFBC1, 0xADEEFBC1, 0xADEFFBC1, 0xADF0FBC1, 0xADF1FBC1, 0xADF2FBC1, 0xADF3FBC1, 0xADF4FBC1, 0xADF5FBC1, 0xADF6FBC1, 0xADF7FBC1, 0xADF8FBC1, 0xADF9FBC1, 0xADFAFBC1, 0xADFBFBC1, 0xADFCFBC1, 0xADFDFBC1, 0xADFEFBC1, 0xADFFFBC1, 0xAE00FBC1, 0xAE01FBC1, 0xAE02FBC1, 0xAE03FBC1, 0xAE04FBC1, 0xAE05FBC1, /* AD5C */
+ 0xAE06FBC1, 0xAE07FBC1, 0xAE08FBC1, 0xAE09FBC1, 0xAE0AFBC1, 0xAE0BFBC1, 0xAE0CFBC1, 0xAE0DFBC1, 0xAE0EFBC1, 0xAE0FFBC1, 0xAE10FBC1, 0xAE11FBC1, 0xAE12FBC1, 0xAE13FBC1, 0xAE14FBC1, 0xAE15FBC1, 0xAE16FBC1, 0xAE17FBC1, 0xAE18FBC1, 0xAE19FBC1, 0xAE1AFBC1, 0xAE1BFBC1, 0xAE1CFBC1, 0xAE1DFBC1, 0xAE1EFBC1, 0xAE1FFBC1, 0xAE20FBC1, 0xAE21FBC1, 0xAE22FBC1, 0xAE23FBC1, 0xAE24FBC1, 0xAE25FBC1, 0xAE26FBC1, 0xAE27FBC1, 0xAE28FBC1, 0xAE29FBC1, 0xAE2AFBC1, 0xAE2BFBC1, 0xAE2CFBC1, 0xAE2DFBC1, 0xAE2EFBC1, 0xAE2FFBC1, 0xAE30FBC1, 0xAE31FBC1, 0xAE32FBC1, 0xAE33FBC1, 0xAE34FBC1, 0xAE35FBC1, 0xAE36FBC1, 0xAE37FBC1, 0xAE38FBC1, 0xAE39FBC1, 0xAE3AFBC1, 0xAE3BFBC1, 0xAE3CFBC1, 0xAE3DFBC1, 0xAE3EFBC1, 0xAE3FFBC1, 0xAE40FBC1, 0xAE41FBC1, 0xAE42FBC1, 0xAE43FBC1, 0xAE44FBC1, 0xAE45FBC1, 0xAE46FBC1, 0xAE47FBC1, 0xAE48FBC1, 0xAE49FBC1, 0xAE4AFBC1, 0xAE4BFBC1, 0xAE4CFBC1, 0xAE4DFBC1, 0xAE4EFBC1, 0xAE4FFBC1, 0xAE50FBC1, 0xAE51FBC1, 0xAE52FBC1, 0xAE53FBC1, 0xAE54FBC1, 0xAE55FBC1, 0xAE56FBC1, 0xAE57FBC1, 0xAE58FBC1, 0xAE59FBC1, 0xAE5AFBC1, 0xAE5BFBC1, 0xAE5CFBC1, 0xAE5DFBC1, 0xAE5EFBC1, 0xAE5FFBC1, 0xAE60FBC1, 0xAE61FBC1, 0xAE62FBC1, 0xAE63FBC1, 0xAE64FBC1, 0xAE65FBC1, 0xAE66FBC1, 0xAE67FBC1, 0xAE68FBC1, 0xAE69FBC1, 0xAE6AFBC1, 0xAE6BFBC1, 0xAE6CFBC1, 0xAE6DFBC1, 0xAE6EFBC1, 0xAE6FFBC1, 0xAE70FBC1, 0xAE71FBC1, 0xAE72FBC1, 0xAE73FBC1, 0xAE74FBC1, 0xAE75FBC1, 0xAE76FBC1, 0xAE77FBC1, 0xAE78FBC1, 0xAE79FBC1, 0xAE7AFBC1, 0xAE7BFBC1, 0xAE7CFBC1, 0xAE7DFBC1, 0xAE7EFBC1, 0xAE7FFBC1, 0xAE80FBC1, 0xAE81FBC1, 0xAE82FBC1, 0xAE83FBC1, 0xAE84FBC1, 0xAE85FBC1, 0xAE86FBC1, 0xAE87FBC1, 0xAE88FBC1, 0xAE89FBC1, 0xAE8AFBC1, 0xAE8BFBC1, 0xAE8CFBC1, 0xAE8DFBC1, 0xAE8EFBC1, 0xAE8FFBC1, 0xAE90FBC1, 0xAE91FBC1, 0xAE92FBC1, 0xAE93FBC1, 0xAE94FBC1, 0xAE95FBC1, 0xAE96FBC1, 0xAE97FBC1, 0xAE98FBC1, 0xAE99FBC1, 0xAE9AFBC1, 0xAE9BFBC1, 0xAE9CFBC1, 0xAE9DFBC1, 0xAE9EFBC1, 0xAE9FFBC1, 0xAEA0FBC1, 0xAEA1FBC1, 0xAEA2FBC1, 0xAEA3FBC1, 0xAEA4FBC1, 0xAEA5FBC1, 0xAEA6FBC1, 0xAEA7FBC1, 0xAEA8FBC1, 0xAEA9FBC1, 0xAEAAFBC1, 0xAEABFBC1, 0xAEACFBC1, 0xAEADFBC1, 0xAEAEFBC1, 0xAEAFFBC1, /* AE06 */
+ 0xAEB0FBC1, 0xAEB1FBC1, 0xAEB2FBC1, 0xAEB3FBC1, 0xAEB4FBC1, 0xAEB5FBC1, 0xAEB6FBC1, 0xAEB7FBC1, 0xAEB8FBC1, 0xAEB9FBC1, 0xAEBAFBC1, 0xAEBBFBC1, 0xAEBCFBC1, 0xAEBDFBC1, 0xAEBEFBC1, 0xAEBFFBC1, 0xAEC0FBC1, 0xAEC1FBC1, 0xAEC2FBC1, 0xAEC3FBC1, 0xAEC4FBC1, 0xAEC5FBC1, 0xAEC6FBC1, 0xAEC7FBC1, 0xAEC8FBC1, 0xAEC9FBC1, 0xAECAFBC1, 0xAECBFBC1, 0xAECCFBC1, 0xAECDFBC1, 0xAECEFBC1, 0xAECFFBC1, 0xAED0FBC1, 0xAED1FBC1, 0xAED2FBC1, 0xAED3FBC1, 0xAED4FBC1, 0xAED5FBC1, 0xAED6FBC1, 0xAED7FBC1, 0xAED8FBC1, 0xAED9FBC1, 0xAEDAFBC1, 0xAEDBFBC1, 0xAEDCFBC1, 0xAEDDFBC1, 0xAEDEFBC1, 0xAEDFFBC1, 0xAEE0FBC1, 0xAEE1FBC1, 0xAEE2FBC1, 0xAEE3FBC1, 0xAEE4FBC1, 0xAEE5FBC1, 0xAEE6FBC1, 0xAEE7FBC1, 0xAEE8FBC1, 0xAEE9FBC1, 0xAEEAFBC1, 0xAEEBFBC1, 0xAEECFBC1, 0xAEEDFBC1, 0xAEEEFBC1, 0xAEEFFBC1, 0xAEF0FBC1, 0xAEF1FBC1, 0xAEF2FBC1, 0xAEF3FBC1, 0xAEF4FBC1, 0xAEF5FBC1, 0xAEF6FBC1, 0xAEF7FBC1, 0xAEF8FBC1, 0xAEF9FBC1, 0xAEFAFBC1, 0xAEFBFBC1, 0xAEFCFBC1, 0xAEFDFBC1, 0xAEFEFBC1, 0xAEFFFBC1, 0xAF00FBC1, 0xAF01FBC1, 0xAF02FBC1, 0xAF03FBC1, 0xAF04FBC1, 0xAF05FBC1, 0xAF06FBC1, 0xAF07FBC1, 0xAF08FBC1, 0xAF09FBC1, 0xAF0AFBC1, 0xAF0BFBC1, 0xAF0CFBC1, 0xAF0DFBC1, 0xAF0EFBC1, 0xAF0FFBC1, 0xAF10FBC1, 0xAF11FBC1, 0xAF12FBC1, 0xAF13FBC1, 0xAF14FBC1, 0xAF15FBC1, 0xAF16FBC1, 0xAF17FBC1, 0xAF18FBC1, 0xAF19FBC1, 0xAF1AFBC1, 0xAF1BFBC1, 0xAF1CFBC1, 0xAF1DFBC1, 0xAF1EFBC1, 0xAF1FFBC1, 0xAF20FBC1, 0xAF21FBC1, 0xAF22FBC1, 0xAF23FBC1, 0xAF24FBC1, 0xAF25FBC1, 0xAF26FBC1, 0xAF27FBC1, 0xAF28FBC1, 0xAF29FBC1, 0xAF2AFBC1, 0xAF2BFBC1, 0xAF2CFBC1, 0xAF2DFBC1, 0xAF2EFBC1, 0xAF2FFBC1, 0xAF30FBC1, 0xAF31FBC1, 0xAF32FBC1, 0xAF33FBC1, 0xAF34FBC1, 0xAF35FBC1, 0xAF36FBC1, 0xAF37FBC1, 0xAF38FBC1, 0xAF39FBC1, 0xAF3AFBC1, 0xAF3BFBC1, 0xAF3CFBC1, 0xAF3DFBC1, 0xAF3EFBC1, 0xAF3FFBC1, 0xAF40FBC1, 0xAF41FBC1, 0xAF42FBC1, 0xAF43FBC1, 0xAF44FBC1, 0xAF45FBC1, 0xAF46FBC1, 0xAF47FBC1, 0xAF48FBC1, 0xAF49FBC1, 0xAF4AFBC1, 0xAF4BFBC1, 0xAF4CFBC1, 0xAF4DFBC1, 0xAF4EFBC1, 0xAF4FFBC1, 0xAF50FBC1, 0xAF51FBC1, 0xAF52FBC1, 0xAF53FBC1, 0xAF54FBC1, 0xAF55FBC1, 0xAF56FBC1, 0xAF57FBC1, 0xAF58FBC1, 0xAF59FBC1, /* AEB0 */
+ 0xAF5AFBC1, 0xAF5BFBC1, 0xAF5CFBC1, 0xAF5DFBC1, 0xAF5EFBC1, 0xAF5FFBC1, 0xAF60FBC1, 0xAF61FBC1, 0xAF62FBC1, 0xAF63FBC1, 0xAF64FBC1, 0xAF65FBC1, 0xAF66FBC1, 0xAF67FBC1, 0xAF68FBC1, 0xAF69FBC1, 0xAF6AFBC1, 0xAF6BFBC1, 0xAF6CFBC1, 0xAF6DFBC1, 0xAF6EFBC1, 0xAF6FFBC1, 0xAF70FBC1, 0xAF71FBC1, 0xAF72FBC1, 0xAF73FBC1, 0xAF74FBC1, 0xAF75FBC1, 0xAF76FBC1, 0xAF77FBC1, 0xAF78FBC1, 0xAF79FBC1, 0xAF7AFBC1, 0xAF7BFBC1, 0xAF7CFBC1, 0xAF7DFBC1, 0xAF7EFBC1, 0xAF7FFBC1, 0xAF80FBC1, 0xAF81FBC1, 0xAF82FBC1, 0xAF83FBC1, 0xAF84FBC1, 0xAF85FBC1, 0xAF86FBC1, 0xAF87FBC1, 0xAF88FBC1, 0xAF89FBC1, 0xAF8AFBC1, 0xAF8BFBC1, 0xAF8CFBC1, 0xAF8DFBC1, 0xAF8EFBC1, 0xAF8FFBC1, 0xAF90FBC1, 0xAF91FBC1, 0xAF92FBC1, 0xAF93FBC1, 0xAF94FBC1, 0xAF95FBC1, 0xAF96FBC1, 0xAF97FBC1, 0xAF98FBC1, 0xAF99FBC1, 0xAF9AFBC1, 0xAF9BFBC1, 0xAF9CFBC1, 0xAF9DFBC1, 0xAF9EFBC1, 0xAF9FFBC1, 0xAFA0FBC1, 0xAFA1FBC1, 0xAFA2FBC1, 0xAFA3FBC1, 0xAFA4FBC1, 0xAFA5FBC1, 0xAFA6FBC1, 0xAFA7FBC1, 0xAFA8FBC1, 0xAFA9FBC1, 0xAFAAFBC1, 0xAFABFBC1, 0xAFACFBC1, 0xAFADFBC1, 0xAFAEFBC1, 0xAFAFFBC1, 0xAFB0FBC1, 0xAFB1FBC1, 0xAFB2FBC1, 0xAFB3FBC1, 0xAFB4FBC1, 0xAFB5FBC1, 0xAFB6FBC1, 0xAFB7FBC1, 0xAFB8FBC1, 0xAFB9FBC1, 0xAFBAFBC1, 0xAFBBFBC1, 0xAFBCFBC1, 0xAFBDFBC1, 0xAFBEFBC1, 0xAFBFFBC1, 0xAFC0FBC1, 0xAFC1FBC1, 0xAFC2FBC1, 0xAFC3FBC1, 0xAFC4FBC1, 0xAFC5FBC1, 0xAFC6FBC1, 0xAFC7FBC1, 0xAFC8FBC1, 0xAFC9FBC1, 0xAFCAFBC1, 0xAFCBFBC1, 0xAFCCFBC1, 0xAFCDFBC1, 0xAFCEFBC1, 0xAFCFFBC1, 0xAFD0FBC1, 0xAFD1FBC1, 0xAFD2FBC1, 0xAFD3FBC1, 0xAFD4FBC1, 0xAFD5FBC1, 0xAFD6FBC1, 0xAFD7FBC1, 0xAFD8FBC1, 0xAFD9FBC1, 0xAFDAFBC1, 0xAFDBFBC1, 0xAFDCFBC1, 0xAFDDFBC1, 0xAFDEFBC1, 0xAFDFFBC1, 0xAFE0FBC1, 0xAFE1FBC1, 0xAFE2FBC1, 0xAFE3FBC1, 0xAFE4FBC1, 0xAFE5FBC1, 0xAFE6FBC1, 0xAFE7FBC1, 0xAFE8FBC1, 0xAFE9FBC1, 0xAFEAFBC1, 0xAFEBFBC1, 0xAFECFBC1, 0xAFEDFBC1, 0xAFEEFBC1, 0xAFEFFBC1, 0xAFF0FBC1, 0xAFF1FBC1, 0xAFF2FBC1, 0xAFF3FBC1, 0xAFF4FBC1, 0xAFF5FBC1, 0xAFF6FBC1, 0xAFF7FBC1, 0xAFF8FBC1, 0xAFF9FBC1, 0xAFFAFBC1, 0xAFFBFBC1, 0xAFFCFBC1, 0xAFFDFBC1, 0xAFFEFBC1, 0xAFFFFBC1, 0xB000FBC1, 0xB001FBC1, 0xB002FBC1, 0xB003FBC1, /* AF5A */
+ 0xB004FBC1, 0xB005FBC1, 0xB006FBC1, 0xB007FBC1, 0xB008FBC1, 0xB009FBC1, 0xB00AFBC1, 0xB00BFBC1, 0xB00CFBC1, 0xB00DFBC1, 0xB00EFBC1, 0xB00FFBC1, 0xB010FBC1, 0xB011FBC1, 0xB012FBC1, 0xB013FBC1, 0xB014FBC1, 0xB015FBC1, 0xB016FBC1, 0xB017FBC1, 0xB018FBC1, 0xB019FBC1, 0xB01AFBC1, 0xB01BFBC1, 0xB01CFBC1, 0xB01DFBC1, 0xB01EFBC1, 0xB01FFBC1, 0xB020FBC1, 0xB021FBC1, 0xB022FBC1, 0xB023FBC1, 0xB024FBC1, 0xB025FBC1, 0xB026FBC1, 0xB027FBC1, 0xB028FBC1, 0xB029FBC1, 0xB02AFBC1, 0xB02BFBC1, 0xB02CFBC1, 0xB02DFBC1, 0xB02EFBC1, 0xB02FFBC1, 0xB030FBC1, 0xB031FBC1, 0xB032FBC1, 0xB033FBC1, 0xB034FBC1, 0xB035FBC1, 0xB036FBC1, 0xB037FBC1, 0xB038FBC1, 0xB039FBC1, 0xB03AFBC1, 0xB03BFBC1, 0xB03CFBC1, 0xB03DFBC1, 0xB03EFBC1, 0xB03FFBC1, 0xB040FBC1, 0xB041FBC1, 0xB042FBC1, 0xB043FBC1, 0xB044FBC1, 0xB045FBC1, 0xB046FBC1, 0xB047FBC1, 0xB048FBC1, 0xB049FBC1, 0xB04AFBC1, 0xB04BFBC1, 0xB04CFBC1, 0xB04DFBC1, 0xB04EFBC1, 0xB04FFBC1, 0xB050FBC1, 0xB051FBC1, 0xB052FBC1, 0xB053FBC1, 0xB054FBC1, 0xB055FBC1, 0xB056FBC1, 0xB057FBC1, 0xB058FBC1, 0xB059FBC1, 0xB05AFBC1, 0xB05BFBC1, 0xB05CFBC1, 0xB05DFBC1, 0xB05EFBC1, 0xB05FFBC1, 0xB060FBC1, 0xB061FBC1, 0xB062FBC1, 0xB063FBC1, 0xB064FBC1, 0xB065FBC1, 0xB066FBC1, 0xB067FBC1, 0xB068FBC1, 0xB069FBC1, 0xB06AFBC1, 0xB06BFBC1, 0xB06CFBC1, 0xB06DFBC1, 0xB06EFBC1, 0xB06FFBC1, 0xB070FBC1, 0xB071FBC1, 0xB072FBC1, 0xB073FBC1, 0xB074FBC1, 0xB075FBC1, 0xB076FBC1, 0xB077FBC1, 0xB078FBC1, 0xB079FBC1, 0xB07AFBC1, 0xB07BFBC1, 0xB07CFBC1, 0xB07DFBC1, 0xB07EFBC1, 0xB07FFBC1, 0xB080FBC1, 0xB081FBC1, 0xB082FBC1, 0xB083FBC1, 0xB084FBC1, 0xB085FBC1, 0xB086FBC1, 0xB087FBC1, 0xB088FBC1, 0xB089FBC1, 0xB08AFBC1, 0xB08BFBC1, 0xB08CFBC1, 0xB08DFBC1, 0xB08EFBC1, 0xB08FFBC1, 0xB090FBC1, 0xB091FBC1, 0xB092FBC1, 0xB093FBC1, 0xB094FBC1, 0xB095FBC1, 0xB096FBC1, 0xB097FBC1, 0xB098FBC1, 0xB099FBC1, 0xB09AFBC1, 0xB09BFBC1, 0xB09CFBC1, 0xB09DFBC1, 0xB09EFBC1, 0xB09FFBC1, 0xB0A0FBC1, 0xB0A1FBC1, 0xB0A2FBC1, 0xB0A3FBC1, 0xB0A4FBC1, 0xB0A5FBC1, 0xB0A6FBC1, 0xB0A7FBC1, 0xB0A8FBC1, 0xB0A9FBC1, 0xB0AAFBC1, 0xB0ABFBC1, 0xB0ACFBC1, 0xB0ADFBC1, /* B004 */
+ 0xB0AEFBC1, 0xB0AFFBC1, 0xB0B0FBC1, 0xB0B1FBC1, 0xB0B2FBC1, 0xB0B3FBC1, 0xB0B4FBC1, 0xB0B5FBC1, 0xB0B6FBC1, 0xB0B7FBC1, 0xB0B8FBC1, 0xB0B9FBC1, 0xB0BAFBC1, 0xB0BBFBC1, 0xB0BCFBC1, 0xB0BDFBC1, 0xB0BEFBC1, 0xB0BFFBC1, 0xB0C0FBC1, 0xB0C1FBC1, 0xB0C2FBC1, 0xB0C3FBC1, 0xB0C4FBC1, 0xB0C5FBC1, 0xB0C6FBC1, 0xB0C7FBC1, 0xB0C8FBC1, 0xB0C9FBC1, 0xB0CAFBC1, 0xB0CBFBC1, 0xB0CCFBC1, 0xB0CDFBC1, 0xB0CEFBC1, 0xB0CFFBC1, 0xB0D0FBC1, 0xB0D1FBC1, 0xB0D2FBC1, 0xB0D3FBC1, 0xB0D4FBC1, 0xB0D5FBC1, 0xB0D6FBC1, 0xB0D7FBC1, 0xB0D8FBC1, 0xB0D9FBC1, 0xB0DAFBC1, 0xB0DBFBC1, 0xB0DCFBC1, 0xB0DDFBC1, 0xB0DEFBC1, 0xB0DFFBC1, 0xB0E0FBC1, 0xB0E1FBC1, 0xB0E2FBC1, 0xB0E3FBC1, 0xB0E4FBC1, 0xB0E5FBC1, 0xB0E6FBC1, 0xB0E7FBC1, 0xB0E8FBC1, 0xB0E9FBC1, 0xB0EAFBC1, 0xB0EBFBC1, 0xB0ECFBC1, 0xB0EDFBC1, 0xB0EEFBC1, 0xB0EFFBC1, 0xB0F0FBC1, 0xB0F1FBC1, 0xB0F2FBC1, 0xB0F3FBC1, 0xB0F4FBC1, 0xB0F5FBC1, 0xB0F6FBC1, 0xB0F7FBC1, 0xB0F8FBC1, 0xB0F9FBC1, 0xB0FAFBC1, 0xB0FBFBC1, 0xB0FCFBC1, 0xB0FDFBC1, 0xB0FEFBC1, 0xB0FFFBC1, 0xB100FBC1, 0xB101FBC1, 0xB102FBC1, 0xB103FBC1, 0xB104FBC1, 0xB105FBC1, 0xB106FBC1, 0xB107FBC1, 0xB108FBC1, 0xB109FBC1, 0xB10AFBC1, 0xB10BFBC1, 0xB10CFBC1, 0xB10DFBC1, 0xB10EFBC1, 0xB10FFBC1, 0xB110FBC1, 0xB111FBC1, 0xB112FBC1, 0xB113FBC1, 0xB114FBC1, 0xB115FBC1, 0xB116FBC1, 0xB117FBC1, 0xB118FBC1, 0xB119FBC1, 0xB11AFBC1, 0xB11BFBC1, 0xB11CFBC1, 0xB11DFBC1, 0xB11EFBC1, 0xB11FFBC1, 0xB120FBC1, 0xB121FBC1, 0xB122FBC1, 0xB123FBC1, 0xB124FBC1, 0xB125FBC1, 0xB126FBC1, 0xB127FBC1, 0xB128FBC1, 0xB129FBC1, 0xB12AFBC1, 0xB12BFBC1, 0xB12CFBC1, 0xB12DFBC1, 0xB12EFBC1, 0xB12FFBC1, 0xB130FBC1, 0xB131FBC1, 0xB132FBC1, 0xB133FBC1, 0xB134FBC1, 0xB135FBC1, 0xB136FBC1, 0xB137FBC1, 0xB138FBC1, 0xB139FBC1, 0xB13AFBC1, 0xB13BFBC1, 0xB13CFBC1, 0xB13DFBC1, 0xB13EFBC1, 0xB13FFBC1, 0xB140FBC1, 0xB141FBC1, 0xB142FBC1, 0xB143FBC1, 0xB144FBC1, 0xB145FBC1, 0xB146FBC1, 0xB147FBC1, 0xB148FBC1, 0xB149FBC1, 0xB14AFBC1, 0xB14BFBC1, 0xB14CFBC1, 0xB14DFBC1, 0xB14EFBC1, 0xB14FFBC1, 0xB150FBC1, 0xB151FBC1, 0xB152FBC1, 0xB153FBC1, 0xB154FBC1, 0xB155FBC1, 0xB156FBC1, 0xB157FBC1, /* B0AE */
+ 0xB158FBC1, 0xB159FBC1, 0xB15AFBC1, 0xB15BFBC1, 0xB15CFBC1, 0xB15DFBC1, 0xB15EFBC1, 0xB15FFBC1, 0xB160FBC1, 0xB161FBC1, 0xB162FBC1, 0xB163FBC1, 0xB164FBC1, 0xB165FBC1, 0xB166FBC1, 0xB167FBC1, 0xB168FBC1, 0xB169FBC1, 0xB16AFBC1, 0xB16BFBC1, 0xB16CFBC1, 0xB16DFBC1, 0xB16EFBC1, 0xB16FFBC1, 0xB170FBC1, 0xB171FBC1, 0xB172FBC1, 0xB173FBC1, 0xB174FBC1, 0xB175FBC1, 0xB176FBC1, 0xB177FBC1, 0xB178FBC1, 0xB179FBC1, 0xB17AFBC1, 0xB17BFBC1, 0xB17CFBC1, 0xB17DFBC1, 0xB17EFBC1, 0xB17FFBC1, 0xB180FBC1, 0xB181FBC1, 0xB182FBC1, 0xB183FBC1, 0xB184FBC1, 0xB185FBC1, 0xB186FBC1, 0xB187FBC1, 0xB188FBC1, 0xB189FBC1, 0xB18AFBC1, 0xB18BFBC1, 0xB18CFBC1, 0xB18DFBC1, 0xB18EFBC1, 0xB18FFBC1, 0xB190FBC1, 0xB191FBC1, 0xB192FBC1, 0xB193FBC1, 0xB194FBC1, 0xB195FBC1, 0xB196FBC1, 0xB197FBC1, 0xB198FBC1, 0xB199FBC1, 0xB19AFBC1, 0xB19BFBC1, 0xB19CFBC1, 0xB19DFBC1, 0xB19EFBC1, 0xB19FFBC1, 0xB1A0FBC1, 0xB1A1FBC1, 0xB1A2FBC1, 0xB1A3FBC1, 0xB1A4FBC1, 0xB1A5FBC1, 0xB1A6FBC1, 0xB1A7FBC1, 0xB1A8FBC1, 0xB1A9FBC1, 0xB1AAFBC1, 0xB1ABFBC1, 0xB1ACFBC1, 0xB1ADFBC1, 0xB1AEFBC1, 0xB1AFFBC1, 0xB1B0FBC1, 0xB1B1FBC1, 0xB1B2FBC1, 0xB1B3FBC1, 0xB1B4FBC1, 0xB1B5FBC1, 0xB1B6FBC1, 0xB1B7FBC1, 0xB1B8FBC1, 0xB1B9FBC1, 0xB1BAFBC1, 0xB1BBFBC1, 0xB1BCFBC1, 0xB1BDFBC1, 0xB1BEFBC1, 0xB1BFFBC1, 0xB1C0FBC1, 0xB1C1FBC1, 0xB1C2FBC1, 0xB1C3FBC1, 0xB1C4FBC1, 0xB1C5FBC1, 0xB1C6FBC1, 0xB1C7FBC1, 0xB1C8FBC1, 0xB1C9FBC1, 0xB1CAFBC1, 0xB1CBFBC1, 0xB1CCFBC1, 0xB1CDFBC1, 0xB1CEFBC1, 0xB1CFFBC1, 0xB1D0FBC1, 0xB1D1FBC1, 0xB1D2FBC1, 0xB1D3FBC1, 0xB1D4FBC1, 0xB1D5FBC1, 0xB1D6FBC1, 0xB1D7FBC1, 0xB1D8FBC1, 0xB1D9FBC1, 0xB1DAFBC1, 0xB1DBFBC1, 0xB1DCFBC1, 0xB1DDFBC1, 0xB1DEFBC1, 0xB1DFFBC1, 0xB1E0FBC1, 0xB1E1FBC1, 0xB1E2FBC1, 0xB1E3FBC1, 0xB1E4FBC1, 0xB1E5FBC1, 0xB1E6FBC1, 0xB1E7FBC1, 0xB1E8FBC1, 0xB1E9FBC1, 0xB1EAFBC1, 0xB1EBFBC1, 0xB1ECFBC1, 0xB1EDFBC1, 0xB1EEFBC1, 0xB1EFFBC1, 0xB1F0FBC1, 0xB1F1FBC1, 0xB1F2FBC1, 0xB1F3FBC1, 0xB1F4FBC1, 0xB1F5FBC1, 0xB1F6FBC1, 0xB1F7FBC1, 0xB1F8FBC1, 0xB1F9FBC1, 0xB1FAFBC1, 0xB1FBFBC1, 0xB1FCFBC1, 0xB1FDFBC1, 0xB1FEFBC1, 0xB1FFFBC1, 0xB200FBC1, 0xB201FBC1, /* B158 */
+ 0xB202FBC1, 0xB203FBC1, 0xB204FBC1, 0xB205FBC1, 0xB206FBC1, 0xB207FBC1, 0xB208FBC1, 0xB209FBC1, 0xB20AFBC1, 0xB20BFBC1, 0xB20CFBC1, 0xB20DFBC1, 0xB20EFBC1, 0xB20FFBC1, 0xB210FBC1, 0xB211FBC1, 0xB212FBC1, 0xB213FBC1, 0xB214FBC1, 0xB215FBC1, 0xB216FBC1, 0xB217FBC1, 0xB218FBC1, 0xB219FBC1, 0xB21AFBC1, 0xB21BFBC1, 0xB21CFBC1, 0xB21DFBC1, 0xB21EFBC1, 0xB21FFBC1, 0xB220FBC1, 0xB221FBC1, 0xB222FBC1, 0xB223FBC1, 0xB224FBC1, 0xB225FBC1, 0xB226FBC1, 0xB227FBC1, 0xB228FBC1, 0xB229FBC1, 0xB22AFBC1, 0xB22BFBC1, 0xB22CFBC1, 0xB22DFBC1, 0xB22EFBC1, 0xB22FFBC1, 0xB230FBC1, 0xB231FBC1, 0xB232FBC1, 0xB233FBC1, 0xB234FBC1, 0xB235FBC1, 0xB236FBC1, 0xB237FBC1, 0xB238FBC1, 0xB239FBC1, 0xB23AFBC1, 0xB23BFBC1, 0xB23CFBC1, 0xB23DFBC1, 0xB23EFBC1, 0xB23FFBC1, 0xB240FBC1, 0xB241FBC1, 0xB242FBC1, 0xB243FBC1, 0xB244FBC1, 0xB245FBC1, 0xB246FBC1, 0xB247FBC1, 0xB248FBC1, 0xB249FBC1, 0xB24AFBC1, 0xB24BFBC1, 0xB24CFBC1, 0xB24DFBC1, 0xB24EFBC1, 0xB24FFBC1, 0xB250FBC1, 0xB251FBC1, 0xB252FBC1, 0xB253FBC1, 0xB254FBC1, 0xB255FBC1, 0xB256FBC1, 0xB257FBC1, 0xB258FBC1, 0xB259FBC1, 0xB25AFBC1, 0xB25BFBC1, 0xB25CFBC1, 0xB25DFBC1, 0xB25EFBC1, 0xB25FFBC1, 0xB260FBC1, 0xB261FBC1, 0xB262FBC1, 0xB263FBC1, 0xB264FBC1, 0xB265FBC1, 0xB266FBC1, 0xB267FBC1, 0xB268FBC1, 0xB269FBC1, 0xB26AFBC1, 0xB26BFBC1, 0xB26CFBC1, 0xB26DFBC1, 0xB26EFBC1, 0xB26FFBC1, 0xB270FBC1, 0xB271FBC1, 0xB272FBC1, 0xB273FBC1, 0xB274FBC1, 0xB275FBC1, 0xB276FBC1, 0xB277FBC1, 0xB278FBC1, 0xB279FBC1, 0xB27AFBC1, 0xB27BFBC1, 0xB27CFBC1, 0xB27DFBC1, 0xB27EFBC1, 0xB27FFBC1, 0xB280FBC1, 0xB281FBC1, 0xB282FBC1, 0xB283FBC1, 0xB284FBC1, 0xB285FBC1, 0xB286FBC1, 0xB287FBC1, 0xB288FBC1, 0xB289FBC1, 0xB28AFBC1, 0xB28BFBC1, 0xB28CFBC1, 0xB28DFBC1, 0xB28EFBC1, 0xB28FFBC1, 0xB290FBC1, 0xB291FBC1, 0xB292FBC1, 0xB293FBC1, 0xB294FBC1, 0xB295FBC1, 0xB296FBC1, 0xB297FBC1, 0xB298FBC1, 0xB299FBC1, 0xB29AFBC1, 0xB29BFBC1, 0xB29CFBC1, 0xB29DFBC1, 0xB29EFBC1, 0xB29FFBC1, 0xB2A0FBC1, 0xB2A1FBC1, 0xB2A2FBC1, 0xB2A3FBC1, 0xB2A4FBC1, 0xB2A5FBC1, 0xB2A6FBC1, 0xB2A7FBC1, 0xB2A8FBC1, 0xB2A9FBC1, 0xB2AAFBC1, 0xB2ABFBC1, /* B202 */
+ 0xB2ACFBC1, 0xB2ADFBC1, 0xB2AEFBC1, 0xB2AFFBC1, 0xB2B0FBC1, 0xB2B1FBC1, 0xB2B2FBC1, 0xB2B3FBC1, 0xB2B4FBC1, 0xB2B5FBC1, 0xB2B6FBC1, 0xB2B7FBC1, 0xB2B8FBC1, 0xB2B9FBC1, 0xB2BAFBC1, 0xB2BBFBC1, 0xB2BCFBC1, 0xB2BDFBC1, 0xB2BEFBC1, 0xB2BFFBC1, 0xB2C0FBC1, 0xB2C1FBC1, 0xB2C2FBC1, 0xB2C3FBC1, 0xB2C4FBC1, 0xB2C5FBC1, 0xB2C6FBC1, 0xB2C7FBC1, 0xB2C8FBC1, 0xB2C9FBC1, 0xB2CAFBC1, 0xB2CBFBC1, 0xB2CCFBC1, 0xB2CDFBC1, 0xB2CEFBC1, 0xB2CFFBC1, 0xB2D0FBC1, 0xB2D1FBC1, 0xB2D2FBC1, 0xB2D3FBC1, 0xB2D4FBC1, 0xB2D5FBC1, 0xB2D6FBC1, 0xB2D7FBC1, 0xB2D8FBC1, 0xB2D9FBC1, 0xB2DAFBC1, 0xB2DBFBC1, 0xB2DCFBC1, 0xB2DDFBC1, 0xB2DEFBC1, 0xB2DFFBC1, 0xB2E0FBC1, 0xB2E1FBC1, 0xB2E2FBC1, 0xB2E3FBC1, 0xB2E4FBC1, 0xB2E5FBC1, 0xB2E6FBC1, 0xB2E7FBC1, 0xB2E8FBC1, 0xB2E9FBC1, 0xB2EAFBC1, 0xB2EBFBC1, 0xB2ECFBC1, 0xB2EDFBC1, 0xB2EEFBC1, 0xB2EFFBC1, 0xB2F0FBC1, 0xB2F1FBC1, 0xB2F2FBC1, 0xB2F3FBC1, 0xB2F4FBC1, 0xB2F5FBC1, 0xB2F6FBC1, 0xB2F7FBC1, 0xB2F8FBC1, 0xB2F9FBC1, 0xB2FAFBC1, 0xB2FBFBC1, 0xB2FCFBC1, 0xB2FDFBC1, 0xB2FEFBC1, 0xB2FFFBC1, 0xB300FBC1, 0xB301FBC1, 0xB302FBC1, 0xB303FBC1, 0xB304FBC1, 0xB305FBC1, 0xB306FBC1, 0xB307FBC1, 0xB308FBC1, 0xB309FBC1, 0xB30AFBC1, 0xB30BFBC1, 0xB30CFBC1, 0xB30DFBC1, 0xB30EFBC1, 0xB30FFBC1, 0xB310FBC1, 0xB311FBC1, 0xB312FBC1, 0xB313FBC1, 0xB314FBC1, 0xB315FBC1, 0xB316FBC1, 0xB317FBC1, 0xB318FBC1, 0xB319FBC1, 0xB31AFBC1, 0xB31BFBC1, 0xB31CFBC1, 0xB31DFBC1, 0xB31EFBC1, 0xB31FFBC1, 0xB320FBC1, 0xB321FBC1, 0xB322FBC1, 0xB323FBC1, 0xB324FBC1, 0xB325FBC1, 0xB326FBC1, 0xB327FBC1, 0xB328FBC1, 0xB329FBC1, 0xB32AFBC1, 0xB32BFBC1, 0xB32CFBC1, 0xB32DFBC1, 0xB32EFBC1, 0xB32FFBC1, 0xB330FBC1, 0xB331FBC1, 0xB332FBC1, 0xB333FBC1, 0xB334FBC1, 0xB335FBC1, 0xB336FBC1, 0xB337FBC1, 0xB338FBC1, 0xB339FBC1, 0xB33AFBC1, 0xB33BFBC1, 0xB33CFBC1, 0xB33DFBC1, 0xB33EFBC1, 0xB33FFBC1, 0xB340FBC1, 0xB341FBC1, 0xB342FBC1, 0xB343FBC1, 0xB344FBC1, 0xB345FBC1, 0xB346FBC1, 0xB347FBC1, 0xB348FBC1, 0xB349FBC1, 0xB34AFBC1, 0xB34BFBC1, 0xB34CFBC1, 0xB34DFBC1, 0xB34EFBC1, 0xB34FFBC1, 0xB350FBC1, 0xB351FBC1, 0xB352FBC1, 0xB353FBC1, 0xB354FBC1, 0xB355FBC1, /* B2AC */
+ 0xB356FBC1, 0xB357FBC1, 0xB358FBC1, 0xB359FBC1, 0xB35AFBC1, 0xB35BFBC1, 0xB35CFBC1, 0xB35DFBC1, 0xB35EFBC1, 0xB35FFBC1, 0xB360FBC1, 0xB361FBC1, 0xB362FBC1, 0xB363FBC1, 0xB364FBC1, 0xB365FBC1, 0xB366FBC1, 0xB367FBC1, 0xB368FBC1, 0xB369FBC1, 0xB36AFBC1, 0xB36BFBC1, 0xB36CFBC1, 0xB36DFBC1, 0xB36EFBC1, 0xB36FFBC1, 0xB370FBC1, 0xB371FBC1, 0xB372FBC1, 0xB373FBC1, 0xB374FBC1, 0xB375FBC1, 0xB376FBC1, 0xB377FBC1, 0xB378FBC1, 0xB379FBC1, 0xB37AFBC1, 0xB37BFBC1, 0xB37CFBC1, 0xB37DFBC1, 0xB37EFBC1, 0xB37FFBC1, 0xB380FBC1, 0xB381FBC1, 0xB382FBC1, 0xB383FBC1, 0xB384FBC1, 0xB385FBC1, 0xB386FBC1, 0xB387FBC1, 0xB388FBC1, 0xB389FBC1, 0xB38AFBC1, 0xB38BFBC1, 0xB38CFBC1, 0xB38DFBC1, 0xB38EFBC1, 0xB38FFBC1, 0xB390FBC1, 0xB391FBC1, 0xB392FBC1, 0xB393FBC1, 0xB394FBC1, 0xB395FBC1, 0xB396FBC1, 0xB397FBC1, 0xB398FBC1, 0xB399FBC1, 0xB39AFBC1, 0xB39BFBC1, 0xB39CFBC1, 0xB39DFBC1, 0xB39EFBC1, 0xB39FFBC1, 0xB3A0FBC1, 0xB3A1FBC1, 0xB3A2FBC1, 0xB3A3FBC1, 0xB3A4FBC1, 0xB3A5FBC1, 0xB3A6FBC1, 0xB3A7FBC1, 0xB3A8FBC1, 0xB3A9FBC1, 0xB3AAFBC1, 0xB3ABFBC1, 0xB3ACFBC1, 0xB3ADFBC1, 0xB3AEFBC1, 0xB3AFFBC1, 0xB3B0FBC1, 0xB3B1FBC1, 0xB3B2FBC1, 0xB3B3FBC1, 0xB3B4FBC1, 0xB3B5FBC1, 0xB3B6FBC1, 0xB3B7FBC1, 0xB3B8FBC1, 0xB3B9FBC1, 0xB3BAFBC1, 0xB3BBFBC1, 0xB3BCFBC1, 0xB3BDFBC1, 0xB3BEFBC1, 0xB3BFFBC1, 0xB3C0FBC1, 0xB3C1FBC1, 0xB3C2FBC1, 0xB3C3FBC1, 0xB3C4FBC1, 0xB3C5FBC1, 0xB3C6FBC1, 0xB3C7FBC1, 0xB3C8FBC1, 0xB3C9FBC1, 0xB3CAFBC1, 0xB3CBFBC1, 0xB3CCFBC1, 0xB3CDFBC1, 0xB3CEFBC1, 0xB3CFFBC1, 0xB3D0FBC1, 0xB3D1FBC1, 0xB3D2FBC1, 0xB3D3FBC1, 0xB3D4FBC1, 0xB3D5FBC1, 0xB3D6FBC1, 0xB3D7FBC1, 0xB3D8FBC1, 0xB3D9FBC1, 0xB3DAFBC1, 0xB3DBFBC1, 0xB3DCFBC1, 0xB3DDFBC1, 0xB3DEFBC1, 0xB3DFFBC1, 0xB3E0FBC1, 0xB3E1FBC1, 0xB3E2FBC1, 0xB3E3FBC1, 0xB3E4FBC1, 0xB3E5FBC1, 0xB3E6FBC1, 0xB3E7FBC1, 0xB3E8FBC1, 0xB3E9FBC1, 0xB3EAFBC1, 0xB3EBFBC1, 0xB3ECFBC1, 0xB3EDFBC1, 0xB3EEFBC1, 0xB3EFFBC1, 0xB3F0FBC1, 0xB3F1FBC1, 0xB3F2FBC1, 0xB3F3FBC1, 0xB3F4FBC1, 0xB3F5FBC1, 0xB3F6FBC1, 0xB3F7FBC1, 0xB3F8FBC1, 0xB3F9FBC1, 0xB3FAFBC1, 0xB3FBFBC1, 0xB3FCFBC1, 0xB3FDFBC1, 0xB3FEFBC1, 0xB3FFFBC1, /* B356 */
+ 0xB400FBC1, 0xB401FBC1, 0xB402FBC1, 0xB403FBC1, 0xB404FBC1, 0xB405FBC1, 0xB406FBC1, 0xB407FBC1, 0xB408FBC1, 0xB409FBC1, 0xB40AFBC1, 0xB40BFBC1, 0xB40CFBC1, 0xB40DFBC1, 0xB40EFBC1, 0xB40FFBC1, 0xB410FBC1, 0xB411FBC1, 0xB412FBC1, 0xB413FBC1, 0xB414FBC1, 0xB415FBC1, 0xB416FBC1, 0xB417FBC1, 0xB418FBC1, 0xB419FBC1, 0xB41AFBC1, 0xB41BFBC1, 0xB41CFBC1, 0xB41DFBC1, 0xB41EFBC1, 0xB41FFBC1, 0xB420FBC1, 0xB421FBC1, 0xB422FBC1, 0xB423FBC1, 0xB424FBC1, 0xB425FBC1, 0xB426FBC1, 0xB427FBC1, 0xB428FBC1, 0xB429FBC1, 0xB42AFBC1, 0xB42BFBC1, 0xB42CFBC1, 0xB42DFBC1, 0xB42EFBC1, 0xB42FFBC1, 0xB430FBC1, 0xB431FBC1, 0xB432FBC1, 0xB433FBC1, 0xB434FBC1, 0xB435FBC1, 0xB436FBC1, 0xB437FBC1, 0xB438FBC1, 0xB439FBC1, 0xB43AFBC1, 0xB43BFBC1, 0xB43CFBC1, 0xB43DFBC1, 0xB43EFBC1, 0xB43FFBC1, 0xB440FBC1, 0xB441FBC1, 0xB442FBC1, 0xB443FBC1, 0xB444FBC1, 0xB445FBC1, 0xB446FBC1, 0xB447FBC1, 0xB448FBC1, 0xB449FBC1, 0xB44AFBC1, 0xB44BFBC1, 0xB44CFBC1, 0xB44DFBC1, 0xB44EFBC1, 0xB44FFBC1, 0xB450FBC1, 0xB451FBC1, 0xB452FBC1, 0xB453FBC1, 0xB454FBC1, 0xB455FBC1, 0xB456FBC1, 0xB457FBC1, 0xB458FBC1, 0xB459FBC1, 0xB45AFBC1, 0xB45BFBC1, 0xB45CFBC1, 0xB45DFBC1, 0xB45EFBC1, 0xB45FFBC1, 0xB460FBC1, 0xB461FBC1, 0xB462FBC1, 0xB463FBC1, 0xB464FBC1, 0xB465FBC1, 0xB466FBC1, 0xB467FBC1, 0xB468FBC1, 0xB469FBC1, 0xB46AFBC1, 0xB46BFBC1, 0xB46CFBC1, 0xB46DFBC1, 0xB46EFBC1, 0xB46FFBC1, 0xB470FBC1, 0xB471FBC1, 0xB472FBC1, 0xB473FBC1, 0xB474FBC1, 0xB475FBC1, 0xB476FBC1, 0xB477FBC1, 0xB478FBC1, 0xB479FBC1, 0xB47AFBC1, 0xB47BFBC1, 0xB47CFBC1, 0xB47DFBC1, 0xB47EFBC1, 0xB47FFBC1, 0xB480FBC1, 0xB481FBC1, 0xB482FBC1, 0xB483FBC1, 0xB484FBC1, 0xB485FBC1, 0xB486FBC1, 0xB487FBC1, 0xB488FBC1, 0xB489FBC1, 0xB48AFBC1, 0xB48BFBC1, 0xB48CFBC1, 0xB48DFBC1, 0xB48EFBC1, 0xB48FFBC1, 0xB490FBC1, 0xB491FBC1, 0xB492FBC1, 0xB493FBC1, 0xB494FBC1, 0xB495FBC1, 0xB496FBC1, 0xB497FBC1, 0xB498FBC1, 0xB499FBC1, 0xB49AFBC1, 0xB49BFBC1, 0xB49CFBC1, 0xB49DFBC1, 0xB49EFBC1, 0xB49FFBC1, 0xB4A0FBC1, 0xB4A1FBC1, 0xB4A2FBC1, 0xB4A3FBC1, 0xB4A4FBC1, 0xB4A5FBC1, 0xB4A6FBC1, 0xB4A7FBC1, 0xB4A8FBC1, 0xB4A9FBC1, /* B400 */
+ 0xB4AAFBC1, 0xB4ABFBC1, 0xB4ACFBC1, 0xB4ADFBC1, 0xB4AEFBC1, 0xB4AFFBC1, 0xB4B0FBC1, 0xB4B1FBC1, 0xB4B2FBC1, 0xB4B3FBC1, 0xB4B4FBC1, 0xB4B5FBC1, 0xB4B6FBC1, 0xB4B7FBC1, 0xB4B8FBC1, 0xB4B9FBC1, 0xB4BAFBC1, 0xB4BBFBC1, 0xB4BCFBC1, 0xB4BDFBC1, 0xB4BEFBC1, 0xB4BFFBC1, 0xB4C0FBC1, 0xB4C1FBC1, 0xB4C2FBC1, 0xB4C3FBC1, 0xB4C4FBC1, 0xB4C5FBC1, 0xB4C6FBC1, 0xB4C7FBC1, 0xB4C8FBC1, 0xB4C9FBC1, 0xB4CAFBC1, 0xB4CBFBC1, 0xB4CCFBC1, 0xB4CDFBC1, 0xB4CEFBC1, 0xB4CFFBC1, 0xB4D0FBC1, 0xB4D1FBC1, 0xB4D2FBC1, 0xB4D3FBC1, 0xB4D4FBC1, 0xB4D5FBC1, 0xB4D6FBC1, 0xB4D7FBC1, 0xB4D8FBC1, 0xB4D9FBC1, 0xB4DAFBC1, 0xB4DBFBC1, 0xB4DCFBC1, 0xB4DDFBC1, 0xB4DEFBC1, 0xB4DFFBC1, 0xB4E0FBC1, 0xB4E1FBC1, 0xB4E2FBC1, 0xB4E3FBC1, 0xB4E4FBC1, 0xB4E5FBC1, 0xB4E6FBC1, 0xB4E7FBC1, 0xB4E8FBC1, 0xB4E9FBC1, 0xB4EAFBC1, 0xB4EBFBC1, 0xB4ECFBC1, 0xB4EDFBC1, 0xB4EEFBC1, 0xB4EFFBC1, 0xB4F0FBC1, 0xB4F1FBC1, 0xB4F2FBC1, 0xB4F3FBC1, 0xB4F4FBC1, 0xB4F5FBC1, 0xB4F6FBC1, 0xB4F7FBC1, 0xB4F8FBC1, 0xB4F9FBC1, 0xB4FAFBC1, 0xB4FBFBC1, 0xB4FCFBC1, 0xB4FDFBC1, 0xB4FEFBC1, 0xB4FFFBC1, 0xB500FBC1, 0xB501FBC1, 0xB502FBC1, 0xB503FBC1, 0xB504FBC1, 0xB505FBC1, 0xB506FBC1, 0xB507FBC1, 0xB508FBC1, 0xB509FBC1, 0xB50AFBC1, 0xB50BFBC1, 0xB50CFBC1, 0xB50DFBC1, 0xB50EFBC1, 0xB50FFBC1, 0xB510FBC1, 0xB511FBC1, 0xB512FBC1, 0xB513FBC1, 0xB514FBC1, 0xB515FBC1, 0xB516FBC1, 0xB517FBC1, 0xB518FBC1, 0xB519FBC1, 0xB51AFBC1, 0xB51BFBC1, 0xB51CFBC1, 0xB51DFBC1, 0xB51EFBC1, 0xB51FFBC1, 0xB520FBC1, 0xB521FBC1, 0xB522FBC1, 0xB523FBC1, 0xB524FBC1, 0xB525FBC1, 0xB526FBC1, 0xB527FBC1, 0xB528FBC1, 0xB529FBC1, 0xB52AFBC1, 0xB52BFBC1, 0xB52CFBC1, 0xB52DFBC1, 0xB52EFBC1, 0xB52FFBC1, 0xB530FBC1, 0xB531FBC1, 0xB532FBC1, 0xB533FBC1, 0xB534FBC1, 0xB535FBC1, 0xB536FBC1, 0xB537FBC1, 0xB538FBC1, 0xB539FBC1, 0xB53AFBC1, 0xB53BFBC1, 0xB53CFBC1, 0xB53DFBC1, 0xB53EFBC1, 0xB53FFBC1, 0xB540FBC1, 0xB541FBC1, 0xB542FBC1, 0xB543FBC1, 0xB544FBC1, 0xB545FBC1, 0xB546FBC1, 0xB547FBC1, 0xB548FBC1, 0xB549FBC1, 0xB54AFBC1, 0xB54BFBC1, 0xB54CFBC1, 0xB54DFBC1, 0xB54EFBC1, 0xB54FFBC1, 0xB550FBC1, 0xB551FBC1, 0xB552FBC1, 0xB553FBC1, /* B4AA */
+ 0xB554FBC1, 0xB555FBC1, 0xB556FBC1, 0xB557FBC1, 0xB558FBC1, 0xB559FBC1, 0xB55AFBC1, 0xB55BFBC1, 0xB55CFBC1, 0xB55DFBC1, 0xB55EFBC1, 0xB55FFBC1, 0xB560FBC1, 0xB561FBC1, 0xB562FBC1, 0xB563FBC1, 0xB564FBC1, 0xB565FBC1, 0xB566FBC1, 0xB567FBC1, 0xB568FBC1, 0xB569FBC1, 0xB56AFBC1, 0xB56BFBC1, 0xB56CFBC1, 0xB56DFBC1, 0xB56EFBC1, 0xB56FFBC1, 0xB570FBC1, 0xB571FBC1, 0xB572FBC1, 0xB573FBC1, 0xB574FBC1, 0xB575FBC1, 0xB576FBC1, 0xB577FBC1, 0xB578FBC1, 0xB579FBC1, 0xB57AFBC1, 0xB57BFBC1, 0xB57CFBC1, 0xB57DFBC1, 0xB57EFBC1, 0xB57FFBC1, 0xB580FBC1, 0xB581FBC1, 0xB582FBC1, 0xB583FBC1, 0xB584FBC1, 0xB585FBC1, 0xB586FBC1, 0xB587FBC1, 0xB588FBC1, 0xB589FBC1, 0xB58AFBC1, 0xB58BFBC1, 0xB58CFBC1, 0xB58DFBC1, 0xB58EFBC1, 0xB58FFBC1, 0xB590FBC1, 0xB591FBC1, 0xB592FBC1, 0xB593FBC1, 0xB594FBC1, 0xB595FBC1, 0xB596FBC1, 0xB597FBC1, 0xB598FBC1, 0xB599FBC1, 0xB59AFBC1, 0xB59BFBC1, 0xB59CFBC1, 0xB59DFBC1, 0xB59EFBC1, 0xB59FFBC1, 0xB5A0FBC1, 0xB5A1FBC1, 0xB5A2FBC1, 0xB5A3FBC1, 0xB5A4FBC1, 0xB5A5FBC1, 0xB5A6FBC1, 0xB5A7FBC1, 0xB5A8FBC1, 0xB5A9FBC1, 0xB5AAFBC1, 0xB5ABFBC1, 0xB5ACFBC1, 0xB5ADFBC1, 0xB5AEFBC1, 0xB5AFFBC1, 0xB5B0FBC1, 0xB5B1FBC1, 0xB5B2FBC1, 0xB5B3FBC1, 0xB5B4FBC1, 0xB5B5FBC1, 0xB5B6FBC1, 0xB5B7FBC1, 0xB5B8FBC1, 0xB5B9FBC1, 0xB5BAFBC1, 0xB5BBFBC1, 0xB5BCFBC1, 0xB5BDFBC1, 0xB5BEFBC1, 0xB5BFFBC1, 0xB5C0FBC1, 0xB5C1FBC1, 0xB5C2FBC1, 0xB5C3FBC1, 0xB5C4FBC1, 0xB5C5FBC1, 0xB5C6FBC1, 0xB5C7FBC1, 0xB5C8FBC1, 0xB5C9FBC1, 0xB5CAFBC1, 0xB5CBFBC1, 0xB5CCFBC1, 0xB5CDFBC1, 0xB5CEFBC1, 0xB5CFFBC1, 0xB5D0FBC1, 0xB5D1FBC1, 0xB5D2FBC1, 0xB5D3FBC1, 0xB5D4FBC1, 0xB5D5FBC1, 0xB5D6FBC1, 0xB5D7FBC1, 0xB5D8FBC1, 0xB5D9FBC1, 0xB5DAFBC1, 0xB5DBFBC1, 0xB5DCFBC1, 0xB5DDFBC1, 0xB5DEFBC1, 0xB5DFFBC1, 0xB5E0FBC1, 0xB5E1FBC1, 0xB5E2FBC1, 0xB5E3FBC1, 0xB5E4FBC1, 0xB5E5FBC1, 0xB5E6FBC1, 0xB5E7FBC1, 0xB5E8FBC1, 0xB5E9FBC1, 0xB5EAFBC1, 0xB5EBFBC1, 0xB5ECFBC1, 0xB5EDFBC1, 0xB5EEFBC1, 0xB5EFFBC1, 0xB5F0FBC1, 0xB5F1FBC1, 0xB5F2FBC1, 0xB5F3FBC1, 0xB5F4FBC1, 0xB5F5FBC1, 0xB5F6FBC1, 0xB5F7FBC1, 0xB5F8FBC1, 0xB5F9FBC1, 0xB5FAFBC1, 0xB5FBFBC1, 0xB5FCFBC1, 0xB5FDFBC1, /* B554 */
+ 0xB5FEFBC1, 0xB5FFFBC1, 0xB600FBC1, 0xB601FBC1, 0xB602FBC1, 0xB603FBC1, 0xB604FBC1, 0xB605FBC1, 0xB606FBC1, 0xB607FBC1, 0xB608FBC1, 0xB609FBC1, 0xB60AFBC1, 0xB60BFBC1, 0xB60CFBC1, 0xB60DFBC1, 0xB60EFBC1, 0xB60FFBC1, 0xB610FBC1, 0xB611FBC1, 0xB612FBC1, 0xB613FBC1, 0xB614FBC1, 0xB615FBC1, 0xB616FBC1, 0xB617FBC1, 0xB618FBC1, 0xB619FBC1, 0xB61AFBC1, 0xB61BFBC1, 0xB61CFBC1, 0xB61DFBC1, 0xB61EFBC1, 0xB61FFBC1, 0xB620FBC1, 0xB621FBC1, 0xB622FBC1, 0xB623FBC1, 0xB624FBC1, 0xB625FBC1, 0xB626FBC1, 0xB627FBC1, 0xB628FBC1, 0xB629FBC1, 0xB62AFBC1, 0xB62BFBC1, 0xB62CFBC1, 0xB62DFBC1, 0xB62EFBC1, 0xB62FFBC1, 0xB630FBC1, 0xB631FBC1, 0xB632FBC1, 0xB633FBC1, 0xB634FBC1, 0xB635FBC1, 0xB636FBC1, 0xB637FBC1, 0xB638FBC1, 0xB639FBC1, 0xB63AFBC1, 0xB63BFBC1, 0xB63CFBC1, 0xB63DFBC1, 0xB63EFBC1, 0xB63FFBC1, 0xB640FBC1, 0xB641FBC1, 0xB642FBC1, 0xB643FBC1, 0xB644FBC1, 0xB645FBC1, 0xB646FBC1, 0xB647FBC1, 0xB648FBC1, 0xB649FBC1, 0xB64AFBC1, 0xB64BFBC1, 0xB64CFBC1, 0xB64DFBC1, 0xB64EFBC1, 0xB64FFBC1, 0xB650FBC1, 0xB651FBC1, 0xB652FBC1, 0xB653FBC1, 0xB654FBC1, 0xB655FBC1, 0xB656FBC1, 0xB657FBC1, 0xB658FBC1, 0xB659FBC1, 0xB65AFBC1, 0xB65BFBC1, 0xB65CFBC1, 0xB65DFBC1, 0xB65EFBC1, 0xB65FFBC1, 0xB660FBC1, 0xB661FBC1, 0xB662FBC1, 0xB663FBC1, 0xB664FBC1, 0xB665FBC1, 0xB666FBC1, 0xB667FBC1, 0xB668FBC1, 0xB669FBC1, 0xB66AFBC1, 0xB66BFBC1, 0xB66CFBC1, 0xB66DFBC1, 0xB66EFBC1, 0xB66FFBC1, 0xB670FBC1, 0xB671FBC1, 0xB672FBC1, 0xB673FBC1, 0xB674FBC1, 0xB675FBC1, 0xB676FBC1, 0xB677FBC1, 0xB678FBC1, 0xB679FBC1, 0xB67AFBC1, 0xB67BFBC1, 0xB67CFBC1, 0xB67DFBC1, 0xB67EFBC1, 0xB67FFBC1, 0xB680FBC1, 0xB681FBC1, 0xB682FBC1, 0xB683FBC1, 0xB684FBC1, 0xB685FBC1, 0xB686FBC1, 0xB687FBC1, 0xB688FBC1, 0xB689FBC1, 0xB68AFBC1, 0xB68BFBC1, 0xB68CFBC1, 0xB68DFBC1, 0xB68EFBC1, 0xB68FFBC1, 0xB690FBC1, 0xB691FBC1, 0xB692FBC1, 0xB693FBC1, 0xB694FBC1, 0xB695FBC1, 0xB696FBC1, 0xB697FBC1, 0xB698FBC1, 0xB699FBC1, 0xB69AFBC1, 0xB69BFBC1, 0xB69CFBC1, 0xB69DFBC1, 0xB69EFBC1, 0xB69FFBC1, 0xB6A0FBC1, 0xB6A1FBC1, 0xB6A2FBC1, 0xB6A3FBC1, 0xB6A4FBC1, 0xB6A5FBC1, 0xB6A6FBC1, 0xB6A7FBC1, /* B5FE */
+ 0xB6A8FBC1, 0xB6A9FBC1, 0xB6AAFBC1, 0xB6ABFBC1, 0xB6ACFBC1, 0xB6ADFBC1, 0xB6AEFBC1, 0xB6AFFBC1, 0xB6B0FBC1, 0xB6B1FBC1, 0xB6B2FBC1, 0xB6B3FBC1, 0xB6B4FBC1, 0xB6B5FBC1, 0xB6B6FBC1, 0xB6B7FBC1, 0xB6B8FBC1, 0xB6B9FBC1, 0xB6BAFBC1, 0xB6BBFBC1, 0xB6BCFBC1, 0xB6BDFBC1, 0xB6BEFBC1, 0xB6BFFBC1, 0xB6C0FBC1, 0xB6C1FBC1, 0xB6C2FBC1, 0xB6C3FBC1, 0xB6C4FBC1, 0xB6C5FBC1, 0xB6C6FBC1, 0xB6C7FBC1, 0xB6C8FBC1, 0xB6C9FBC1, 0xB6CAFBC1, 0xB6CBFBC1, 0xB6CCFBC1, 0xB6CDFBC1, 0xB6CEFBC1, 0xB6CFFBC1, 0xB6D0FBC1, 0xB6D1FBC1, 0xB6D2FBC1, 0xB6D3FBC1, 0xB6D4FBC1, 0xB6D5FBC1, 0xB6D6FBC1, 0xB6D7FBC1, 0xB6D8FBC1, 0xB6D9FBC1, 0xB6DAFBC1, 0xB6DBFBC1, 0xB6DCFBC1, 0xB6DDFBC1, 0xB6DEFBC1, 0xB6DFFBC1, 0xB6E0FBC1, 0xB6E1FBC1, 0xB6E2FBC1, 0xB6E3FBC1, 0xB6E4FBC1, 0xB6E5FBC1, 0xB6E6FBC1, 0xB6E7FBC1, 0xB6E8FBC1, 0xB6E9FBC1, 0xB6EAFBC1, 0xB6EBFBC1, 0xB6ECFBC1, 0xB6EDFBC1, 0xB6EEFBC1, 0xB6EFFBC1, 0xB6F0FBC1, 0xB6F1FBC1, 0xB6F2FBC1, 0xB6F3FBC1, 0xB6F4FBC1, 0xB6F5FBC1, 0xB6F6FBC1, 0xB6F7FBC1, 0xB6F8FBC1, 0xB6F9FBC1, 0xB6FAFBC1, 0xB6FBFBC1, 0xB6FCFBC1, 0xB6FDFBC1, 0xB6FEFBC1, 0xB6FFFBC1, 0xB700FBC1, 0xB701FBC1, 0xB702FBC1, 0xB703FBC1, 0xB704FBC1, 0xB705FBC1, 0xB706FBC1, 0xB707FBC1, 0xB708FBC1, 0xB709FBC1, 0xB70AFBC1, 0xB70BFBC1, 0xB70CFBC1, 0xB70DFBC1, 0xB70EFBC1, 0xB70FFBC1, 0xB710FBC1, 0xB711FBC1, 0xB712FBC1, 0xB713FBC1, 0xB714FBC1, 0xB715FBC1, 0xB716FBC1, 0xB717FBC1, 0xB718FBC1, 0xB719FBC1, 0xB71AFBC1, 0xB71BFBC1, 0xB71CFBC1, 0xB71DFBC1, 0xB71EFBC1, 0xB71FFBC1, 0xB720FBC1, 0xB721FBC1, 0xB722FBC1, 0xB723FBC1, 0xB724FBC1, 0xB725FBC1, 0xB726FBC1, 0xB727FBC1, 0xB728FBC1, 0xB729FBC1, 0xB72AFBC1, 0xB72BFBC1, 0xB72CFBC1, 0xB72DFBC1, 0xB72EFBC1, 0xB72FFBC1, 0xB730FBC1, 0xB731FBC1, 0xB732FBC1, 0xB733FBC1, 0xB734FBC1, 0xB735FBC1, 0xB736FBC1, 0xB737FBC1, 0xB738FBC1, 0xB739FBC1, 0xB73AFBC1, 0xB73BFBC1, 0xB73CFBC1, 0xB73DFBC1, 0xB73EFBC1, 0xB73FFBC1, 0xB740FBC1, 0xB741FBC1, 0xB742FBC1, 0xB743FBC1, 0xB744FBC1, 0xB745FBC1, 0xB746FBC1, 0xB747FBC1, 0xB748FBC1, 0xB749FBC1, 0xB74AFBC1, 0xB74BFBC1, 0xB74CFBC1, 0xB74DFBC1, 0xB74EFBC1, 0xB74FFBC1, 0xB750FBC1, 0xB751FBC1, /* B6A8 */
+ 0xB752FBC1, 0xB753FBC1, 0xB754FBC1, 0xB755FBC1, 0xB756FBC1, 0xB757FBC1, 0xB758FBC1, 0xB759FBC1, 0xB75AFBC1, 0xB75BFBC1, 0xB75CFBC1, 0xB75DFBC1, 0xB75EFBC1, 0xB75FFBC1, 0xB760FBC1, 0xB761FBC1, 0xB762FBC1, 0xB763FBC1, 0xB764FBC1, 0xB765FBC1, 0xB766FBC1, 0xB767FBC1, 0xB768FBC1, 0xB769FBC1, 0xB76AFBC1, 0xB76BFBC1, 0xB76CFBC1, 0xB76DFBC1, 0xB76EFBC1, 0xB76FFBC1, 0xB770FBC1, 0xB771FBC1, 0xB772FBC1, 0xB773FBC1, 0xB774FBC1, 0xB775FBC1, 0xB776FBC1, 0xB777FBC1, 0xB778FBC1, 0xB779FBC1, 0xB77AFBC1, 0xB77BFBC1, 0xB77CFBC1, 0xB77DFBC1, 0xB77EFBC1, 0xB77FFBC1, 0xB780FBC1, 0xB781FBC1, 0xB782FBC1, 0xB783FBC1, 0xB784FBC1, 0xB785FBC1, 0xB786FBC1, 0xB787FBC1, 0xB788FBC1, 0xB789FBC1, 0xB78AFBC1, 0xB78BFBC1, 0xB78CFBC1, 0xB78DFBC1, 0xB78EFBC1, 0xB78FFBC1, 0xB790FBC1, 0xB791FBC1, 0xB792FBC1, 0xB793FBC1, 0xB794FBC1, 0xB795FBC1, 0xB796FBC1, 0xB797FBC1, 0xB798FBC1, 0xB799FBC1, 0xB79AFBC1, 0xB79BFBC1, 0xB79CFBC1, 0xB79DFBC1, 0xB79EFBC1, 0xB79FFBC1, 0xB7A0FBC1, 0xB7A1FBC1, 0xB7A2FBC1, 0xB7A3FBC1, 0xB7A4FBC1, 0xB7A5FBC1, 0xB7A6FBC1, 0xB7A7FBC1, 0xB7A8FBC1, 0xB7A9FBC1, 0xB7AAFBC1, 0xB7ABFBC1, 0xB7ACFBC1, 0xB7ADFBC1, 0xB7AEFBC1, 0xB7AFFBC1, 0xB7B0FBC1, 0xB7B1FBC1, 0xB7B2FBC1, 0xB7B3FBC1, 0xB7B4FBC1, 0xB7B5FBC1, 0xB7B6FBC1, 0xB7B7FBC1, 0xB7B8FBC1, 0xB7B9FBC1, 0xB7BAFBC1, 0xB7BBFBC1, 0xB7BCFBC1, 0xB7BDFBC1, 0xB7BEFBC1, 0xB7BFFBC1, 0xB7C0FBC1, 0xB7C1FBC1, 0xB7C2FBC1, 0xB7C3FBC1, 0xB7C4FBC1, 0xB7C5FBC1, 0xB7C6FBC1, 0xB7C7FBC1, 0xB7C8FBC1, 0xB7C9FBC1, 0xB7CAFBC1, 0xB7CBFBC1, 0xB7CCFBC1, 0xB7CDFBC1, 0xB7CEFBC1, 0xB7CFFBC1, 0xB7D0FBC1, 0xB7D1FBC1, 0xB7D2FBC1, 0xB7D3FBC1, 0xB7D4FBC1, 0xB7D5FBC1, 0xB7D6FBC1, 0xB7D7FBC1, 0xB7D8FBC1, 0xB7D9FBC1, 0xB7DAFBC1, 0xB7DBFBC1, 0xB7DCFBC1, 0xB7DDFBC1, 0xB7DEFBC1, 0xB7DFFBC1, 0xB7E0FBC1, 0xB7E1FBC1, 0xB7E2FBC1, 0xB7E3FBC1, 0xB7E4FBC1, 0xB7E5FBC1, 0xB7E6FBC1, 0xB7E7FBC1, 0xB7E8FBC1, 0xB7E9FBC1, 0xB7EAFBC1, 0xB7EBFBC1, 0xB7ECFBC1, 0xB7EDFBC1, 0xB7EEFBC1, 0xB7EFFBC1, 0xB7F0FBC1, 0xB7F1FBC1, 0xB7F2FBC1, 0xB7F3FBC1, 0xB7F4FBC1, 0xB7F5FBC1, 0xB7F6FBC1, 0xB7F7FBC1, 0xB7F8FBC1, 0xB7F9FBC1, 0xB7FAFBC1, 0xB7FBFBC1, /* B752 */
+ 0xB7FCFBC1, 0xB7FDFBC1, 0xB7FEFBC1, 0xB7FFFBC1, 0xB800FBC1, 0xB801FBC1, 0xB802FBC1, 0xB803FBC1, 0xB804FBC1, 0xB805FBC1, 0xB806FBC1, 0xB807FBC1, 0xB808FBC1, 0xB809FBC1, 0xB80AFBC1, 0xB80BFBC1, 0xB80CFBC1, 0xB80DFBC1, 0xB80EFBC1, 0xB80FFBC1, 0xB810FBC1, 0xB811FBC1, 0xB812FBC1, 0xB813FBC1, 0xB814FBC1, 0xB815FBC1, 0xB816FBC1, 0xB817FBC1, 0xB818FBC1, 0xB819FBC1, 0xB81AFBC1, 0xB81BFBC1, 0xB81CFBC1, 0xB81DFBC1, 0xB81EFBC1, 0xB81FFBC1, 0xB820FBC1, 0xB821FBC1, 0xB822FBC1, 0xB823FBC1, 0xB824FBC1, 0xB825FBC1, 0xB826FBC1, 0xB827FBC1, 0xB828FBC1, 0xB829FBC1, 0xB82AFBC1, 0xB82BFBC1, 0xB82CFBC1, 0xB82DFBC1, 0xB82EFBC1, 0xB82FFBC1, 0xB830FBC1, 0xB831FBC1, 0xB832FBC1, 0xB833FBC1, 0xB834FBC1, 0xB835FBC1, 0xB836FBC1, 0xB837FBC1, 0xB838FBC1, 0xB839FBC1, 0xB83AFBC1, 0xB83BFBC1, 0xB83CFBC1, 0xB83DFBC1, 0xB83EFBC1, 0xB83FFBC1, 0xB840FBC1, 0xB841FBC1, 0xB842FBC1, 0xB843FBC1, 0xB844FBC1, 0xB845FBC1, 0xB846FBC1, 0xB847FBC1, 0xB848FBC1, 0xB849FBC1, 0xB84AFBC1, 0xB84BFBC1, 0xB84CFBC1, 0xB84DFBC1, 0xB84EFBC1, 0xB84FFBC1, 0xB850FBC1, 0xB851FBC1, 0xB852FBC1, 0xB853FBC1, 0xB854FBC1, 0xB855FBC1, 0xB856FBC1, 0xB857FBC1, 0xB858FBC1, 0xB859FBC1, 0xB85AFBC1, 0xB85BFBC1, 0xB85CFBC1, 0xB85DFBC1, 0xB85EFBC1, 0xB85FFBC1, 0xB860FBC1, 0xB861FBC1, 0xB862FBC1, 0xB863FBC1, 0xB864FBC1, 0xB865FBC1, 0xB866FBC1, 0xB867FBC1, 0xB868FBC1, 0xB869FBC1, 0xB86AFBC1, 0xB86BFBC1, 0xB86CFBC1, 0xB86DFBC1, 0xB86EFBC1, 0xB86FFBC1, 0xB870FBC1, 0xB871FBC1, 0xB872FBC1, 0xB873FBC1, 0xB874FBC1, 0xB875FBC1, 0xB876FBC1, 0xB877FBC1, 0xB878FBC1, 0xB879FBC1, 0xB87AFBC1, 0xB87BFBC1, 0xB87CFBC1, 0xB87DFBC1, 0xB87EFBC1, 0xB87FFBC1, 0xB880FBC1, 0xB881FBC1, 0xB882FBC1, 0xB883FBC1, 0xB884FBC1, 0xB885FBC1, 0xB886FBC1, 0xB887FBC1, 0xB888FBC1, 0xB889FBC1, 0xB88AFBC1, 0xB88BFBC1, 0xB88CFBC1, 0xB88DFBC1, 0xB88EFBC1, 0xB88FFBC1, 0xB890FBC1, 0xB891FBC1, 0xB892FBC1, 0xB893FBC1, 0xB894FBC1, 0xB895FBC1, 0xB896FBC1, 0xB897FBC1, 0xB898FBC1, 0xB899FBC1, 0xB89AFBC1, 0xB89BFBC1, 0xB89CFBC1, 0xB89DFBC1, 0xB89EFBC1, 0xB89FFBC1, 0xB8A0FBC1, 0xB8A1FBC1, 0xB8A2FBC1, 0xB8A3FBC1, 0xB8A4FBC1, 0xB8A5FBC1, /* B7FC */
+ 0xB8A6FBC1, 0xB8A7FBC1, 0xB8A8FBC1, 0xB8A9FBC1, 0xB8AAFBC1, 0xB8ABFBC1, 0xB8ACFBC1, 0xB8ADFBC1, 0xB8AEFBC1, 0xB8AFFBC1, 0xB8B0FBC1, 0xB8B1FBC1, 0xB8B2FBC1, 0xB8B3FBC1, 0xB8B4FBC1, 0xB8B5FBC1, 0xB8B6FBC1, 0xB8B7FBC1, 0xB8B8FBC1, 0xB8B9FBC1, 0xB8BAFBC1, 0xB8BBFBC1, 0xB8BCFBC1, 0xB8BDFBC1, 0xB8BEFBC1, 0xB8BFFBC1, 0xB8C0FBC1, 0xB8C1FBC1, 0xB8C2FBC1, 0xB8C3FBC1, 0xB8C4FBC1, 0xB8C5FBC1, 0xB8C6FBC1, 0xB8C7FBC1, 0xB8C8FBC1, 0xB8C9FBC1, 0xB8CAFBC1, 0xB8CBFBC1, 0xB8CCFBC1, 0xB8CDFBC1, 0xB8CEFBC1, 0xB8CFFBC1, 0xB8D0FBC1, 0xB8D1FBC1, 0xB8D2FBC1, 0xB8D3FBC1, 0xB8D4FBC1, 0xB8D5FBC1, 0xB8D6FBC1, 0xB8D7FBC1, 0xB8D8FBC1, 0xB8D9FBC1, 0xB8DAFBC1, 0xB8DBFBC1, 0xB8DCFBC1, 0xB8DDFBC1, 0xB8DEFBC1, 0xB8DFFBC1, 0xB8E0FBC1, 0xB8E1FBC1, 0xB8E2FBC1, 0xB8E3FBC1, 0xB8E4FBC1, 0xB8E5FBC1, 0xB8E6FBC1, 0xB8E7FBC1, 0xB8E8FBC1, 0xB8E9FBC1, 0xB8EAFBC1, 0xB8EBFBC1, 0xB8ECFBC1, 0xB8EDFBC1, 0xB8EEFBC1, 0xB8EFFBC1, 0xB8F0FBC1, 0xB8F1FBC1, 0xB8F2FBC1, 0xB8F3FBC1, 0xB8F4FBC1, 0xB8F5FBC1, 0xB8F6FBC1, 0xB8F7FBC1, 0xB8F8FBC1, 0xB8F9FBC1, 0xB8FAFBC1, 0xB8FBFBC1, 0xB8FCFBC1, 0xB8FDFBC1, 0xB8FEFBC1, 0xB8FFFBC1, 0xB900FBC1, 0xB901FBC1, 0xB902FBC1, 0xB903FBC1, 0xB904FBC1, 0xB905FBC1, 0xB906FBC1, 0xB907FBC1, 0xB908FBC1, 0xB909FBC1, 0xB90AFBC1, 0xB90BFBC1, 0xB90CFBC1, 0xB90DFBC1, 0xB90EFBC1, 0xB90FFBC1, 0xB910FBC1, 0xB911FBC1, 0xB912FBC1, 0xB913FBC1, 0xB914FBC1, 0xB915FBC1, 0xB916FBC1, 0xB917FBC1, 0xB918FBC1, 0xB919FBC1, 0xB91AFBC1, 0xB91BFBC1, 0xB91CFBC1, 0xB91DFBC1, 0xB91EFBC1, 0xB91FFBC1, 0xB920FBC1, 0xB921FBC1, 0xB922FBC1, 0xB923FBC1, 0xB924FBC1, 0xB925FBC1, 0xB926FBC1, 0xB927FBC1, 0xB928FBC1, 0xB929FBC1, 0xB92AFBC1, 0xB92BFBC1, 0xB92CFBC1, 0xB92DFBC1, 0xB92EFBC1, 0xB92FFBC1, 0xB930FBC1, 0xB931FBC1, 0xB932FBC1, 0xB933FBC1, 0xB934FBC1, 0xB935FBC1, 0xB936FBC1, 0xB937FBC1, 0xB938FBC1, 0xB939FBC1, 0xB93AFBC1, 0xB93BFBC1, 0xB93CFBC1, 0xB93DFBC1, 0xB93EFBC1, 0xB93FFBC1, 0xB940FBC1, 0xB941FBC1, 0xB942FBC1, 0xB943FBC1, 0xB944FBC1, 0xB945FBC1, 0xB946FBC1, 0xB947FBC1, 0xB948FBC1, 0xB949FBC1, 0xB94AFBC1, 0xB94BFBC1, 0xB94CFBC1, 0xB94DFBC1, 0xB94EFBC1, 0xB94FFBC1, /* B8A6 */
+ 0xB950FBC1, 0xB951FBC1, 0xB952FBC1, 0xB953FBC1, 0xB954FBC1, 0xB955FBC1, 0xB956FBC1, 0xB957FBC1, 0xB958FBC1, 0xB959FBC1, 0xB95AFBC1, 0xB95BFBC1, 0xB95CFBC1, 0xB95DFBC1, 0xB95EFBC1, 0xB95FFBC1, 0xB960FBC1, 0xB961FBC1, 0xB962FBC1, 0xB963FBC1, 0xB964FBC1, 0xB965FBC1, 0xB966FBC1, 0xB967FBC1, 0xB968FBC1, 0xB969FBC1, 0xB96AFBC1, 0xB96BFBC1, 0xB96CFBC1, 0xB96DFBC1, 0xB96EFBC1, 0xB96FFBC1, 0xB970FBC1, 0xB971FBC1, 0xB972FBC1, 0xB973FBC1, 0xB974FBC1, 0xB975FBC1, 0xB976FBC1, 0xB977FBC1, 0xB978FBC1, 0xB979FBC1, 0xB97AFBC1, 0xB97BFBC1, 0xB97CFBC1, 0xB97DFBC1, 0xB97EFBC1, 0xB97FFBC1, 0xB980FBC1, 0xB981FBC1, 0xB982FBC1, 0xB983FBC1, 0xB984FBC1, 0xB985FBC1, 0xB986FBC1, 0xB987FBC1, 0xB988FBC1, 0xB989FBC1, 0xB98AFBC1, 0xB98BFBC1, 0xB98CFBC1, 0xB98DFBC1, 0xB98EFBC1, 0xB98FFBC1, 0xB990FBC1, 0xB991FBC1, 0xB992FBC1, 0xB993FBC1, 0xB994FBC1, 0xB995FBC1, 0xB996FBC1, 0xB997FBC1, 0xB998FBC1, 0xB999FBC1, 0xB99AFBC1, 0xB99BFBC1, 0xB99CFBC1, 0xB99DFBC1, 0xB99EFBC1, 0xB99FFBC1, 0xB9A0FBC1, 0xB9A1FBC1, 0xB9A2FBC1, 0xB9A3FBC1, 0xB9A4FBC1, 0xB9A5FBC1, 0xB9A6FBC1, 0xB9A7FBC1, 0xB9A8FBC1, 0xB9A9FBC1, 0xB9AAFBC1, 0xB9ABFBC1, 0xB9ACFBC1, 0xB9ADFBC1, 0xB9AEFBC1, 0xB9AFFBC1, 0xB9B0FBC1, 0xB9B1FBC1, 0xB9B2FBC1, 0xB9B3FBC1, 0xB9B4FBC1, 0xB9B5FBC1, 0xB9B6FBC1, 0xB9B7FBC1, 0xB9B8FBC1, 0xB9B9FBC1, 0xB9BAFBC1, 0xB9BBFBC1, 0xB9BCFBC1, 0xB9BDFBC1, 0xB9BEFBC1, 0xB9BFFBC1, 0xB9C0FBC1, 0xB9C1FBC1, 0xB9C2FBC1, 0xB9C3FBC1, 0xB9C4FBC1, 0xB9C5FBC1, 0xB9C6FBC1, 0xB9C7FBC1, 0xB9C8FBC1, 0xB9C9FBC1, 0xB9CAFBC1, 0xB9CBFBC1, 0xB9CCFBC1, 0xB9CDFBC1, 0xB9CEFBC1, 0xB9CFFBC1, 0xB9D0FBC1, 0xB9D1FBC1, 0xB9D2FBC1, 0xB9D3FBC1, 0xB9D4FBC1, 0xB9D5FBC1, 0xB9D6FBC1, 0xB9D7FBC1, 0xB9D8FBC1, 0xB9D9FBC1, 0xB9DAFBC1, 0xB9DBFBC1, 0xB9DCFBC1, 0xB9DDFBC1, 0xB9DEFBC1, 0xB9DFFBC1, 0xB9E0FBC1, 0xB9E1FBC1, 0xB9E2FBC1, 0xB9E3FBC1, 0xB9E4FBC1, 0xB9E5FBC1, 0xB9E6FBC1, 0xB9E7FBC1, 0xB9E8FBC1, 0xB9E9FBC1, 0xB9EAFBC1, 0xB9EBFBC1, 0xB9ECFBC1, 0xB9EDFBC1, 0xB9EEFBC1, 0xB9EFFBC1, 0xB9F0FBC1, 0xB9F1FBC1, 0xB9F2FBC1, 0xB9F3FBC1, 0xB9F4FBC1, 0xB9F5FBC1, 0xB9F6FBC1, 0xB9F7FBC1, 0xB9F8FBC1, 0xB9F9FBC1, /* B950 */
+ 0xB9FAFBC1, 0xB9FBFBC1, 0xB9FCFBC1, 0xB9FDFBC1, 0xB9FEFBC1, 0xB9FFFBC1, 0xBA00FBC1, 0xBA01FBC1, 0xBA02FBC1, 0xBA03FBC1, 0xBA04FBC1, 0xBA05FBC1, 0xBA06FBC1, 0xBA07FBC1, 0xBA08FBC1, 0xBA09FBC1, 0xBA0AFBC1, 0xBA0BFBC1, 0xBA0CFBC1, 0xBA0DFBC1, 0xBA0EFBC1, 0xBA0FFBC1, 0xBA10FBC1, 0xBA11FBC1, 0xBA12FBC1, 0xBA13FBC1, 0xBA14FBC1, 0xBA15FBC1, 0xBA16FBC1, 0xBA17FBC1, 0xBA18FBC1, 0xBA19FBC1, 0xBA1AFBC1, 0xBA1BFBC1, 0xBA1CFBC1, 0xBA1DFBC1, 0xBA1EFBC1, 0xBA1FFBC1, 0xBA20FBC1, 0xBA21FBC1, 0xBA22FBC1, 0xBA23FBC1, 0xBA24FBC1, 0xBA25FBC1, 0xBA26FBC1, 0xBA27FBC1, 0xBA28FBC1, 0xBA29FBC1, 0xBA2AFBC1, 0xBA2BFBC1, 0xBA2CFBC1, 0xBA2DFBC1, 0xBA2EFBC1, 0xBA2FFBC1, 0xBA30FBC1, 0xBA31FBC1, 0xBA32FBC1, 0xBA33FBC1, 0xBA34FBC1, 0xBA35FBC1, 0xBA36FBC1, 0xBA37FBC1, 0xBA38FBC1, 0xBA39FBC1, 0xBA3AFBC1, 0xBA3BFBC1, 0xBA3CFBC1, 0xBA3DFBC1, 0xBA3EFBC1, 0xBA3FFBC1, 0xBA40FBC1, 0xBA41FBC1, 0xBA42FBC1, 0xBA43FBC1, 0xBA44FBC1, 0xBA45FBC1, 0xBA46FBC1, 0xBA47FBC1, 0xBA48FBC1, 0xBA49FBC1, 0xBA4AFBC1, 0xBA4BFBC1, 0xBA4CFBC1, 0xBA4DFBC1, 0xBA4EFBC1, 0xBA4FFBC1, 0xBA50FBC1, 0xBA51FBC1, 0xBA52FBC1, 0xBA53FBC1, 0xBA54FBC1, 0xBA55FBC1, 0xBA56FBC1, 0xBA57FBC1, 0xBA58FBC1, 0xBA59FBC1, 0xBA5AFBC1, 0xBA5BFBC1, 0xBA5CFBC1, 0xBA5DFBC1, 0xBA5EFBC1, 0xBA5FFBC1, 0xBA60FBC1, 0xBA61FBC1, 0xBA62FBC1, 0xBA63FBC1, 0xBA64FBC1, 0xBA65FBC1, 0xBA66FBC1, 0xBA67FBC1, 0xBA68FBC1, 0xBA69FBC1, 0xBA6AFBC1, 0xBA6BFBC1, 0xBA6CFBC1, 0xBA6DFBC1, 0xBA6EFBC1, 0xBA6FFBC1, 0xBA70FBC1, 0xBA71FBC1, 0xBA72FBC1, 0xBA73FBC1, 0xBA74FBC1, 0xBA75FBC1, 0xBA76FBC1, 0xBA77FBC1, 0xBA78FBC1, 0xBA79FBC1, 0xBA7AFBC1, 0xBA7BFBC1, 0xBA7CFBC1, 0xBA7DFBC1, 0xBA7EFBC1, 0xBA7FFBC1, 0xBA80FBC1, 0xBA81FBC1, 0xBA82FBC1, 0xBA83FBC1, 0xBA84FBC1, 0xBA85FBC1, 0xBA86FBC1, 0xBA87FBC1, 0xBA88FBC1, 0xBA89FBC1, 0xBA8AFBC1, 0xBA8BFBC1, 0xBA8CFBC1, 0xBA8DFBC1, 0xBA8EFBC1, 0xBA8FFBC1, 0xBA90FBC1, 0xBA91FBC1, 0xBA92FBC1, 0xBA93FBC1, 0xBA94FBC1, 0xBA95FBC1, 0xBA96FBC1, 0xBA97FBC1, 0xBA98FBC1, 0xBA99FBC1, 0xBA9AFBC1, 0xBA9BFBC1, 0xBA9CFBC1, 0xBA9DFBC1, 0xBA9EFBC1, 0xBA9FFBC1, 0xBAA0FBC1, 0xBAA1FBC1, 0xBAA2FBC1, 0xBAA3FBC1, /* B9FA */
+ 0xBAA4FBC1, 0xBAA5FBC1, 0xBAA6FBC1, 0xBAA7FBC1, 0xBAA8FBC1, 0xBAA9FBC1, 0xBAAAFBC1, 0xBAABFBC1, 0xBAACFBC1, 0xBAADFBC1, 0xBAAEFBC1, 0xBAAFFBC1, 0xBAB0FBC1, 0xBAB1FBC1, 0xBAB2FBC1, 0xBAB3FBC1, 0xBAB4FBC1, 0xBAB5FBC1, 0xBAB6FBC1, 0xBAB7FBC1, 0xBAB8FBC1, 0xBAB9FBC1, 0xBABAFBC1, 0xBABBFBC1, 0xBABCFBC1, 0xBABDFBC1, 0xBABEFBC1, 0xBABFFBC1, 0xBAC0FBC1, 0xBAC1FBC1, 0xBAC2FBC1, 0xBAC3FBC1, 0xBAC4FBC1, 0xBAC5FBC1, 0xBAC6FBC1, 0xBAC7FBC1, 0xBAC8FBC1, 0xBAC9FBC1, 0xBACAFBC1, 0xBACBFBC1, 0xBACCFBC1, 0xBACDFBC1, 0xBACEFBC1, 0xBACFFBC1, 0xBAD0FBC1, 0xBAD1FBC1, 0xBAD2FBC1, 0xBAD3FBC1, 0xBAD4FBC1, 0xBAD5FBC1, 0xBAD6FBC1, 0xBAD7FBC1, 0xBAD8FBC1, 0xBAD9FBC1, 0xBADAFBC1, 0xBADBFBC1, 0xBADCFBC1, 0xBADDFBC1, 0xBADEFBC1, 0xBADFFBC1, 0xBAE0FBC1, 0xBAE1FBC1, 0xBAE2FBC1, 0xBAE3FBC1, 0xBAE4FBC1, 0xBAE5FBC1, 0xBAE6FBC1, 0xBAE7FBC1, 0xBAE8FBC1, 0xBAE9FBC1, 0xBAEAFBC1, 0xBAEBFBC1, 0xBAECFBC1, 0xBAEDFBC1, 0xBAEEFBC1, 0xBAEFFBC1, 0xBAF0FBC1, 0xBAF1FBC1, 0xBAF2FBC1, 0xBAF3FBC1, 0xBAF4FBC1, 0xBAF5FBC1, 0xBAF6FBC1, 0xBAF7FBC1, 0xBAF8FBC1, 0xBAF9FBC1, 0xBAFAFBC1, 0xBAFBFBC1, 0xBAFCFBC1, 0xBAFDFBC1, 0xBAFEFBC1, 0xBAFFFBC1, 0xBB00FBC1, 0xBB01FBC1, 0xBB02FBC1, 0xBB03FBC1, 0xBB04FBC1, 0xBB05FBC1, 0xBB06FBC1, 0xBB07FBC1, 0xBB08FBC1, 0xBB09FBC1, 0xBB0AFBC1, 0xBB0BFBC1, 0xBB0CFBC1, 0xBB0DFBC1, 0xBB0EFBC1, 0xBB0FFBC1, 0xBB10FBC1, 0xBB11FBC1, 0xBB12FBC1, 0xBB13FBC1, 0xBB14FBC1, 0xBB15FBC1, 0xBB16FBC1, 0xBB17FBC1, 0xBB18FBC1, 0xBB19FBC1, 0xBB1AFBC1, 0xBB1BFBC1, 0xBB1CFBC1, 0xBB1DFBC1, 0xBB1EFBC1, 0xBB1FFBC1, 0xBB20FBC1, 0xBB21FBC1, 0xBB22FBC1, 0xBB23FBC1, 0xBB24FBC1, 0xBB25FBC1, 0xBB26FBC1, 0xBB27FBC1, 0xBB28FBC1, 0xBB29FBC1, 0xBB2AFBC1, 0xBB2BFBC1, 0xBB2CFBC1, 0xBB2DFBC1, 0xBB2EFBC1, 0xBB2FFBC1, 0xBB30FBC1, 0xBB31FBC1, 0xBB32FBC1, 0xBB33FBC1, 0xBB34FBC1, 0xBB35FBC1, 0xBB36FBC1, 0xBB37FBC1, 0xBB38FBC1, 0xBB39FBC1, 0xBB3AFBC1, 0xBB3BFBC1, 0xBB3CFBC1, 0xBB3DFBC1, 0xBB3EFBC1, 0xBB3FFBC1, 0xBB40FBC1, 0xBB41FBC1, 0xBB42FBC1, 0xBB43FBC1, 0xBB44FBC1, 0xBB45FBC1, 0xBB46FBC1, 0xBB47FBC1, 0xBB48FBC1, 0xBB49FBC1, 0xBB4AFBC1, 0xBB4BFBC1, 0xBB4CFBC1, 0xBB4DFBC1, /* BAA4 */
+ 0xBB4EFBC1, 0xBB4FFBC1, 0xBB50FBC1, 0xBB51FBC1, 0xBB52FBC1, 0xBB53FBC1, 0xBB54FBC1, 0xBB55FBC1, 0xBB56FBC1, 0xBB57FBC1, 0xBB58FBC1, 0xBB59FBC1, 0xBB5AFBC1, 0xBB5BFBC1, 0xBB5CFBC1, 0xBB5DFBC1, 0xBB5EFBC1, 0xBB5FFBC1, 0xBB60FBC1, 0xBB61FBC1, 0xBB62FBC1, 0xBB63FBC1, 0xBB64FBC1, 0xBB65FBC1, 0xBB66FBC1, 0xBB67FBC1, 0xBB68FBC1, 0xBB69FBC1, 0xBB6AFBC1, 0xBB6BFBC1, 0xBB6CFBC1, 0xBB6DFBC1, 0xBB6EFBC1, 0xBB6FFBC1, 0xBB70FBC1, 0xBB71FBC1, 0xBB72FBC1, 0xBB73FBC1, 0xBB74FBC1, 0xBB75FBC1, 0xBB76FBC1, 0xBB77FBC1, 0xBB78FBC1, 0xBB79FBC1, 0xBB7AFBC1, 0xBB7BFBC1, 0xBB7CFBC1, 0xBB7DFBC1, 0xBB7EFBC1, 0xBB7FFBC1, 0xBB80FBC1, 0xBB81FBC1, 0xBB82FBC1, 0xBB83FBC1, 0xBB84FBC1, 0xBB85FBC1, 0xBB86FBC1, 0xBB87FBC1, 0xBB88FBC1, 0xBB89FBC1, 0xBB8AFBC1, 0xBB8BFBC1, 0xBB8CFBC1, 0xBB8DFBC1, 0xBB8EFBC1, 0xBB8FFBC1, 0xBB90FBC1, 0xBB91FBC1, 0xBB92FBC1, 0xBB93FBC1, 0xBB94FBC1, 0xBB95FBC1, 0xBB96FBC1, 0xBB97FBC1, 0xBB98FBC1, 0xBB99FBC1, 0xBB9AFBC1, 0xBB9BFBC1, 0xBB9CFBC1, 0xBB9DFBC1, 0xBB9EFBC1, 0xBB9FFBC1, 0xBBA0FBC1, 0xBBA1FBC1, 0xBBA2FBC1, 0xBBA3FBC1, 0xBBA4FBC1, 0xBBA5FBC1, 0xBBA6FBC1, 0xBBA7FBC1, 0xBBA8FBC1, 0xBBA9FBC1, 0xBBAAFBC1, 0xBBABFBC1, 0xBBACFBC1, 0xBBADFBC1, 0xBBAEFBC1, 0xBBAFFBC1, 0xBBB0FBC1, 0xBBB1FBC1, 0xBBB2FBC1, 0xBBB3FBC1, 0xBBB4FBC1, 0xBBB5FBC1, 0xBBB6FBC1, 0xBBB7FBC1, 0xBBB8FBC1, 0xBBB9FBC1, 0xBBBAFBC1, 0xBBBBFBC1, 0xBBBCFBC1, 0xBBBDFBC1, 0xBBBEFBC1, 0xBBBFFBC1, 0xBBC0FBC1, 0xBBC1FBC1, 0xBBC2FBC1, 0xBBC3FBC1, 0xBBC4FBC1, 0xBBC5FBC1, 0xBBC6FBC1, 0xBBC7FBC1, 0xBBC8FBC1, 0xBBC9FBC1, 0xBBCAFBC1, 0xBBCBFBC1, 0xBBCCFBC1, 0xBBCDFBC1, 0xBBCEFBC1, 0xBBCFFBC1, 0xBBD0FBC1, 0xBBD1FBC1, 0xBBD2FBC1, 0xBBD3FBC1, 0xBBD4FBC1, 0xBBD5FBC1, 0xBBD6FBC1, 0xBBD7FBC1, 0xBBD8FBC1, 0xBBD9FBC1, 0xBBDAFBC1, 0xBBDBFBC1, 0xBBDCFBC1, 0xBBDDFBC1, 0xBBDEFBC1, 0xBBDFFBC1, 0xBBE0FBC1, 0xBBE1FBC1, 0xBBE2FBC1, 0xBBE3FBC1, 0xBBE4FBC1, 0xBBE5FBC1, 0xBBE6FBC1, 0xBBE7FBC1, 0xBBE8FBC1, 0xBBE9FBC1, 0xBBEAFBC1, 0xBBEBFBC1, 0xBBECFBC1, 0xBBEDFBC1, 0xBBEEFBC1, 0xBBEFFBC1, 0xBBF0FBC1, 0xBBF1FBC1, 0xBBF2FBC1, 0xBBF3FBC1, 0xBBF4FBC1, 0xBBF5FBC1, 0xBBF6FBC1, 0xBBF7FBC1, /* BB4E */
+ 0xBBF8FBC1, 0xBBF9FBC1, 0xBBFAFBC1, 0xBBFBFBC1, 0xBBFCFBC1, 0xBBFDFBC1, 0xBBFEFBC1, 0xBBFFFBC1, 0xBC00FBC1, 0xBC01FBC1, 0xBC02FBC1, 0xBC03FBC1, 0xBC04FBC1, 0xBC05FBC1, 0xBC06FBC1, 0xBC07FBC1, 0xBC08FBC1, 0xBC09FBC1, 0xBC0AFBC1, 0xBC0BFBC1, 0xBC0CFBC1, 0xBC0DFBC1, 0xBC0EFBC1, 0xBC0FFBC1, 0xBC10FBC1, 0xBC11FBC1, 0xBC12FBC1, 0xBC13FBC1, 0xBC14FBC1, 0xBC15FBC1, 0xBC16FBC1, 0xBC17FBC1, 0xBC18FBC1, 0xBC19FBC1, 0xBC1AFBC1, 0xBC1BFBC1, 0xBC1CFBC1, 0xBC1DFBC1, 0xBC1EFBC1, 0xBC1FFBC1, 0xBC20FBC1, 0xBC21FBC1, 0xBC22FBC1, 0xBC23FBC1, 0xBC24FBC1, 0xBC25FBC1, 0xBC26FBC1, 0xBC27FBC1, 0xBC28FBC1, 0xBC29FBC1, 0xBC2AFBC1, 0xBC2BFBC1, 0xBC2CFBC1, 0xBC2DFBC1, 0xBC2EFBC1, 0xBC2FFBC1, 0xBC30FBC1, 0xBC31FBC1, 0xBC32FBC1, 0xBC33FBC1, 0xBC34FBC1, 0xBC35FBC1, 0xBC36FBC1, 0xBC37FBC1, 0xBC38FBC1, 0xBC39FBC1, 0xBC3AFBC1, 0xBC3BFBC1, 0xBC3CFBC1, 0xBC3DFBC1, 0xBC3EFBC1, 0xBC3FFBC1, 0xBC40FBC1, 0xBC41FBC1, 0xBC42FBC1, 0xBC43FBC1, 0xBC44FBC1, 0xBC45FBC1, 0xBC46FBC1, 0xBC47FBC1, 0xBC48FBC1, 0xBC49FBC1, 0xBC4AFBC1, 0xBC4BFBC1, 0xBC4CFBC1, 0xBC4DFBC1, 0xBC4EFBC1, 0xBC4FFBC1, 0xBC50FBC1, 0xBC51FBC1, 0xBC52FBC1, 0xBC53FBC1, 0xBC54FBC1, 0xBC55FBC1, 0xBC56FBC1, 0xBC57FBC1, 0xBC58FBC1, 0xBC59FBC1, 0xBC5AFBC1, 0xBC5BFBC1, 0xBC5CFBC1, 0xBC5DFBC1, 0xBC5EFBC1, 0xBC5FFBC1, 0xBC60FBC1, 0xBC61FBC1, 0xBC62FBC1, 0xBC63FBC1, 0xBC64FBC1, 0xBC65FBC1, 0xBC66FBC1, 0xBC67FBC1, 0xBC68FBC1, 0xBC69FBC1, 0xBC6AFBC1, 0xBC6BFBC1, 0xBC6CFBC1, 0xBC6DFBC1, 0xBC6EFBC1, 0xBC6FFBC1, 0xBC70FBC1, 0xBC71FBC1, 0xBC72FBC1, 0xBC73FBC1, 0xBC74FBC1, 0xBC75FBC1, 0xBC76FBC1, 0xBC77FBC1, 0xBC78FBC1, 0xBC79FBC1, 0xBC7AFBC1, 0xBC7BFBC1, 0xBC7CFBC1, 0xBC7DFBC1, 0xBC7EFBC1, 0xBC7FFBC1, 0xBC80FBC1, 0xBC81FBC1, 0xBC82FBC1, 0xBC83FBC1, 0xBC84FBC1, 0xBC85FBC1, 0xBC86FBC1, 0xBC87FBC1, 0xBC88FBC1, 0xBC89FBC1, 0xBC8AFBC1, 0xBC8BFBC1, 0xBC8CFBC1, 0xBC8DFBC1, 0xBC8EFBC1, 0xBC8FFBC1, 0xBC90FBC1, 0xBC91FBC1, 0xBC92FBC1, 0xBC93FBC1, 0xBC94FBC1, 0xBC95FBC1, 0xBC96FBC1, 0xBC97FBC1, 0xBC98FBC1, 0xBC99FBC1, 0xBC9AFBC1, 0xBC9BFBC1, 0xBC9CFBC1, 0xBC9DFBC1, 0xBC9EFBC1, 0xBC9FFBC1, 0xBCA0FBC1, 0xBCA1FBC1, /* BBF8 */
+ 0xBCA2FBC1, 0xBCA3FBC1, 0xBCA4FBC1, 0xBCA5FBC1, 0xBCA6FBC1, 0xBCA7FBC1, 0xBCA8FBC1, 0xBCA9FBC1, 0xBCAAFBC1, 0xBCABFBC1, 0xBCACFBC1, 0xBCADFBC1, 0xBCAEFBC1, 0xBCAFFBC1, 0xBCB0FBC1, 0xBCB1FBC1, 0xBCB2FBC1, 0xBCB3FBC1, 0xBCB4FBC1, 0xBCB5FBC1, 0xBCB6FBC1, 0xBCB7FBC1, 0xBCB8FBC1, 0xBCB9FBC1, 0xBCBAFBC1, 0xBCBBFBC1, 0xBCBCFBC1, 0xBCBDFBC1, 0xBCBEFBC1, 0xBCBFFBC1, 0xBCC0FBC1, 0xBCC1FBC1, 0xBCC2FBC1, 0xBCC3FBC1, 0xBCC4FBC1, 0xBCC5FBC1, 0xBCC6FBC1, 0xBCC7FBC1, 0xBCC8FBC1, 0xBCC9FBC1, 0xBCCAFBC1, 0xBCCBFBC1, 0xBCCCFBC1, 0xBCCDFBC1, 0xBCCEFBC1, 0xBCCFFBC1, 0xBCD0FBC1, 0xBCD1FBC1, 0xBCD2FBC1, 0xBCD3FBC1, 0xBCD4FBC1, 0xBCD5FBC1, 0xBCD6FBC1, 0xBCD7FBC1, 0xBCD8FBC1, 0xBCD9FBC1, 0xBCDAFBC1, 0xBCDBFBC1, 0xBCDCFBC1, 0xBCDDFBC1, 0xBCDEFBC1, 0xBCDFFBC1, 0xBCE0FBC1, 0xBCE1FBC1, 0xBCE2FBC1, 0xBCE3FBC1, 0xBCE4FBC1, 0xBCE5FBC1, 0xBCE6FBC1, 0xBCE7FBC1, 0xBCE8FBC1, 0xBCE9FBC1, 0xBCEAFBC1, 0xBCEBFBC1, 0xBCECFBC1, 0xBCEDFBC1, 0xBCEEFBC1, 0xBCEFFBC1, 0xBCF0FBC1, 0xBCF1FBC1, 0xBCF2FBC1, 0xBCF3FBC1, 0xBCF4FBC1, 0xBCF5FBC1, 0xBCF6FBC1, 0xBCF7FBC1, 0xBCF8FBC1, 0xBCF9FBC1, 0xBCFAFBC1, 0xBCFBFBC1, 0xBCFCFBC1, 0xBCFDFBC1, 0xBCFEFBC1, 0xBCFFFBC1, 0xBD00FBC1, 0xBD01FBC1, 0xBD02FBC1, 0xBD03FBC1, 0xBD04FBC1, 0xBD05FBC1, 0xBD06FBC1, 0xBD07FBC1, 0xBD08FBC1, 0xBD09FBC1, 0xBD0AFBC1, 0xBD0BFBC1, 0xBD0CFBC1, 0xBD0DFBC1, 0xBD0EFBC1, 0xBD0FFBC1, 0xBD10FBC1, 0xBD11FBC1, 0xBD12FBC1, 0xBD13FBC1, 0xBD14FBC1, 0xBD15FBC1, 0xBD16FBC1, 0xBD17FBC1, 0xBD18FBC1, 0xBD19FBC1, 0xBD1AFBC1, 0xBD1BFBC1, 0xBD1CFBC1, 0xBD1DFBC1, 0xBD1EFBC1, 0xBD1FFBC1, 0xBD20FBC1, 0xBD21FBC1, 0xBD22FBC1, 0xBD23FBC1, 0xBD24FBC1, 0xBD25FBC1, 0xBD26FBC1, 0xBD27FBC1, 0xBD28FBC1, 0xBD29FBC1, 0xBD2AFBC1, 0xBD2BFBC1, 0xBD2CFBC1, 0xBD2DFBC1, 0xBD2EFBC1, 0xBD2FFBC1, 0xBD30FBC1, 0xBD31FBC1, 0xBD32FBC1, 0xBD33FBC1, 0xBD34FBC1, 0xBD35FBC1, 0xBD36FBC1, 0xBD37FBC1, 0xBD38FBC1, 0xBD39FBC1, 0xBD3AFBC1, 0xBD3BFBC1, 0xBD3CFBC1, 0xBD3DFBC1, 0xBD3EFBC1, 0xBD3FFBC1, 0xBD40FBC1, 0xBD41FBC1, 0xBD42FBC1, 0xBD43FBC1, 0xBD44FBC1, 0xBD45FBC1, 0xBD46FBC1, 0xBD47FBC1, 0xBD48FBC1, 0xBD49FBC1, 0xBD4AFBC1, 0xBD4BFBC1, /* BCA2 */
+ 0xBD4CFBC1, 0xBD4DFBC1, 0xBD4EFBC1, 0xBD4FFBC1, 0xBD50FBC1, 0xBD51FBC1, 0xBD52FBC1, 0xBD53FBC1, 0xBD54FBC1, 0xBD55FBC1, 0xBD56FBC1, 0xBD57FBC1, 0xBD58FBC1, 0xBD59FBC1, 0xBD5AFBC1, 0xBD5BFBC1, 0xBD5CFBC1, 0xBD5DFBC1, 0xBD5EFBC1, 0xBD5FFBC1, 0xBD60FBC1, 0xBD61FBC1, 0xBD62FBC1, 0xBD63FBC1, 0xBD64FBC1, 0xBD65FBC1, 0xBD66FBC1, 0xBD67FBC1, 0xBD68FBC1, 0xBD69FBC1, 0xBD6AFBC1, 0xBD6BFBC1, 0xBD6CFBC1, 0xBD6DFBC1, 0xBD6EFBC1, 0xBD6FFBC1, 0xBD70FBC1, 0xBD71FBC1, 0xBD72FBC1, 0xBD73FBC1, 0xBD74FBC1, 0xBD75FBC1, 0xBD76FBC1, 0xBD77FBC1, 0xBD78FBC1, 0xBD79FBC1, 0xBD7AFBC1, 0xBD7BFBC1, 0xBD7CFBC1, 0xBD7DFBC1, 0xBD7EFBC1, 0xBD7FFBC1, 0xBD80FBC1, 0xBD81FBC1, 0xBD82FBC1, 0xBD83FBC1, 0xBD84FBC1, 0xBD85FBC1, 0xBD86FBC1, 0xBD87FBC1, 0xBD88FBC1, 0xBD89FBC1, 0xBD8AFBC1, 0xBD8BFBC1, 0xBD8CFBC1, 0xBD8DFBC1, 0xBD8EFBC1, 0xBD8FFBC1, 0xBD90FBC1, 0xBD91FBC1, 0xBD92FBC1, 0xBD93FBC1, 0xBD94FBC1, 0xBD95FBC1, 0xBD96FBC1, 0xBD97FBC1, 0xBD98FBC1, 0xBD99FBC1, 0xBD9AFBC1, 0xBD9BFBC1, 0xBD9CFBC1, 0xBD9DFBC1, 0xBD9EFBC1, 0xBD9FFBC1, 0xBDA0FBC1, 0xBDA1FBC1, 0xBDA2FBC1, 0xBDA3FBC1, 0xBDA4FBC1, 0xBDA5FBC1, 0xBDA6FBC1, 0xBDA7FBC1, 0xBDA8FBC1, 0xBDA9FBC1, 0xBDAAFBC1, 0xBDABFBC1, 0xBDACFBC1, 0xBDADFBC1, 0xBDAEFBC1, 0xBDAFFBC1, 0xBDB0FBC1, 0xBDB1FBC1, 0xBDB2FBC1, 0xBDB3FBC1, 0xBDB4FBC1, 0xBDB5FBC1, 0xBDB6FBC1, 0xBDB7FBC1, 0xBDB8FBC1, 0xBDB9FBC1, 0xBDBAFBC1, 0xBDBBFBC1, 0xBDBCFBC1, 0xBDBDFBC1, 0xBDBEFBC1, 0xBDBFFBC1, 0xBDC0FBC1, 0xBDC1FBC1, 0xBDC2FBC1, 0xBDC3FBC1, 0xBDC4FBC1, 0xBDC5FBC1, 0xBDC6FBC1, 0xBDC7FBC1, 0xBDC8FBC1, 0xBDC9FBC1, 0xBDCAFBC1, 0xBDCBFBC1, 0xBDCCFBC1, 0xBDCDFBC1, 0xBDCEFBC1, 0xBDCFFBC1, 0xBDD0FBC1, 0xBDD1FBC1, 0xBDD2FBC1, 0xBDD3FBC1, 0xBDD4FBC1, 0xBDD5FBC1, 0xBDD6FBC1, 0xBDD7FBC1, 0xBDD8FBC1, 0xBDD9FBC1, 0xBDDAFBC1, 0xBDDBFBC1, 0xBDDCFBC1, 0xBDDDFBC1, 0xBDDEFBC1, 0xBDDFFBC1, 0xBDE0FBC1, 0xBDE1FBC1, 0xBDE2FBC1, 0xBDE3FBC1, 0xBDE4FBC1, 0xBDE5FBC1, 0xBDE6FBC1, 0xBDE7FBC1, 0xBDE8FBC1, 0xBDE9FBC1, 0xBDEAFBC1, 0xBDEBFBC1, 0xBDECFBC1, 0xBDEDFBC1, 0xBDEEFBC1, 0xBDEFFBC1, 0xBDF0FBC1, 0xBDF1FBC1, 0xBDF2FBC1, 0xBDF3FBC1, 0xBDF4FBC1, 0xBDF5FBC1, /* BD4C */
+ 0xBDF6FBC1, 0xBDF7FBC1, 0xBDF8FBC1, 0xBDF9FBC1, 0xBDFAFBC1, 0xBDFBFBC1, 0xBDFCFBC1, 0xBDFDFBC1, 0xBDFEFBC1, 0xBDFFFBC1, 0xBE00FBC1, 0xBE01FBC1, 0xBE02FBC1, 0xBE03FBC1, 0xBE04FBC1, 0xBE05FBC1, 0xBE06FBC1, 0xBE07FBC1, 0xBE08FBC1, 0xBE09FBC1, 0xBE0AFBC1, 0xBE0BFBC1, 0xBE0CFBC1, 0xBE0DFBC1, 0xBE0EFBC1, 0xBE0FFBC1, 0xBE10FBC1, 0xBE11FBC1, 0xBE12FBC1, 0xBE13FBC1, 0xBE14FBC1, 0xBE15FBC1, 0xBE16FBC1, 0xBE17FBC1, 0xBE18FBC1, 0xBE19FBC1, 0xBE1AFBC1, 0xBE1BFBC1, 0xBE1CFBC1, 0xBE1DFBC1, 0xBE1EFBC1, 0xBE1FFBC1, 0xBE20FBC1, 0xBE21FBC1, 0xBE22FBC1, 0xBE23FBC1, 0xBE24FBC1, 0xBE25FBC1, 0xBE26FBC1, 0xBE27FBC1, 0xBE28FBC1, 0xBE29FBC1, 0xBE2AFBC1, 0xBE2BFBC1, 0xBE2CFBC1, 0xBE2DFBC1, 0xBE2EFBC1, 0xBE2FFBC1, 0xBE30FBC1, 0xBE31FBC1, 0xBE32FBC1, 0xBE33FBC1, 0xBE34FBC1, 0xBE35FBC1, 0xBE36FBC1, 0xBE37FBC1, 0xBE38FBC1, 0xBE39FBC1, 0xBE3AFBC1, 0xBE3BFBC1, 0xBE3CFBC1, 0xBE3DFBC1, 0xBE3EFBC1, 0xBE3FFBC1, 0xBE40FBC1, 0xBE41FBC1, 0xBE42FBC1, 0xBE43FBC1, 0xBE44FBC1, 0xBE45FBC1, 0xBE46FBC1, 0xBE47FBC1, 0xBE48FBC1, 0xBE49FBC1, 0xBE4AFBC1, 0xBE4BFBC1, 0xBE4CFBC1, 0xBE4DFBC1, 0xBE4EFBC1, 0xBE4FFBC1, 0xBE50FBC1, 0xBE51FBC1, 0xBE52FBC1, 0xBE53FBC1, 0xBE54FBC1, 0xBE55FBC1, 0xBE56FBC1, 0xBE57FBC1, 0xBE58FBC1, 0xBE59FBC1, 0xBE5AFBC1, 0xBE5BFBC1, 0xBE5CFBC1, 0xBE5DFBC1, 0xBE5EFBC1, 0xBE5FFBC1, 0xBE60FBC1, 0xBE61FBC1, 0xBE62FBC1, 0xBE63FBC1, 0xBE64FBC1, 0xBE65FBC1, 0xBE66FBC1, 0xBE67FBC1, 0xBE68FBC1, 0xBE69FBC1, 0xBE6AFBC1, 0xBE6BFBC1, 0xBE6CFBC1, 0xBE6DFBC1, 0xBE6EFBC1, 0xBE6FFBC1, 0xBE70FBC1, 0xBE71FBC1, 0xBE72FBC1, 0xBE73FBC1, 0xBE74FBC1, 0xBE75FBC1, 0xBE76FBC1, 0xBE77FBC1, 0xBE78FBC1, 0xBE79FBC1, 0xBE7AFBC1, 0xBE7BFBC1, 0xBE7CFBC1, 0xBE7DFBC1, 0xBE7EFBC1, 0xBE7FFBC1, 0xBE80FBC1, 0xBE81FBC1, 0xBE82FBC1, 0xBE83FBC1, 0xBE84FBC1, 0xBE85FBC1, 0xBE86FBC1, 0xBE87FBC1, 0xBE88FBC1, 0xBE89FBC1, 0xBE8AFBC1, 0xBE8BFBC1, 0xBE8CFBC1, 0xBE8DFBC1, 0xBE8EFBC1, 0xBE8FFBC1, 0xBE90FBC1, 0xBE91FBC1, 0xBE92FBC1, 0xBE93FBC1, 0xBE94FBC1, 0xBE95FBC1, 0xBE96FBC1, 0xBE97FBC1, 0xBE98FBC1, 0xBE99FBC1, 0xBE9AFBC1, 0xBE9BFBC1, 0xBE9CFBC1, 0xBE9DFBC1, 0xBE9EFBC1, 0xBE9FFBC1, /* BDF6 */
+ 0xBEA0FBC1, 0xBEA1FBC1, 0xBEA2FBC1, 0xBEA3FBC1, 0xBEA4FBC1, 0xBEA5FBC1, 0xBEA6FBC1, 0xBEA7FBC1, 0xBEA8FBC1, 0xBEA9FBC1, 0xBEAAFBC1, 0xBEABFBC1, 0xBEACFBC1, 0xBEADFBC1, 0xBEAEFBC1, 0xBEAFFBC1, 0xBEB0FBC1, 0xBEB1FBC1, 0xBEB2FBC1, 0xBEB3FBC1, 0xBEB4FBC1, 0xBEB5FBC1, 0xBEB6FBC1, 0xBEB7FBC1, 0xBEB8FBC1, 0xBEB9FBC1, 0xBEBAFBC1, 0xBEBBFBC1, 0xBEBCFBC1, 0xBEBDFBC1, 0xBEBEFBC1, 0xBEBFFBC1, 0xBEC0FBC1, 0xBEC1FBC1, 0xBEC2FBC1, 0xBEC3FBC1, 0xBEC4FBC1, 0xBEC5FBC1, 0xBEC6FBC1, 0xBEC7FBC1, 0xBEC8FBC1, 0xBEC9FBC1, 0xBECAFBC1, 0xBECBFBC1, 0xBECCFBC1, 0xBECDFBC1, 0xBECEFBC1, 0xBECFFBC1, 0xBED0FBC1, 0xBED1FBC1, 0xBED2FBC1, 0xBED3FBC1, 0xBED4FBC1, 0xBED5FBC1, 0xBED6FBC1, 0xBED7FBC1, 0xBED8FBC1, 0xBED9FBC1, 0xBEDAFBC1, 0xBEDBFBC1, 0xBEDCFBC1, 0xBEDDFBC1, 0xBEDEFBC1, 0xBEDFFBC1, 0xBEE0FBC1, 0xBEE1FBC1, 0xBEE2FBC1, 0xBEE3FBC1, 0xBEE4FBC1, 0xBEE5FBC1, 0xBEE6FBC1, 0xBEE7FBC1, 0xBEE8FBC1, 0xBEE9FBC1, 0xBEEAFBC1, 0xBEEBFBC1, 0xBEECFBC1, 0xBEEDFBC1, 0xBEEEFBC1, 0xBEEFFBC1, 0xBEF0FBC1, 0xBEF1FBC1, 0xBEF2FBC1, 0xBEF3FBC1, 0xBEF4FBC1, 0xBEF5FBC1, 0xBEF6FBC1, 0xBEF7FBC1, 0xBEF8FBC1, 0xBEF9FBC1, 0xBEFAFBC1, 0xBEFBFBC1, 0xBEFCFBC1, 0xBEFDFBC1, 0xBEFEFBC1, 0xBEFFFBC1, 0xBF00FBC1, 0xBF01FBC1, 0xBF02FBC1, 0xBF03FBC1, 0xBF04FBC1, 0xBF05FBC1, 0xBF06FBC1, 0xBF07FBC1, 0xBF08FBC1, 0xBF09FBC1, 0xBF0AFBC1, 0xBF0BFBC1, 0xBF0CFBC1, 0xBF0DFBC1, 0xBF0EFBC1, 0xBF0FFBC1, 0xBF10FBC1, 0xBF11FBC1, 0xBF12FBC1, 0xBF13FBC1, 0xBF14FBC1, 0xBF15FBC1, 0xBF16FBC1, 0xBF17FBC1, 0xBF18FBC1, 0xBF19FBC1, 0xBF1AFBC1, 0xBF1BFBC1, 0xBF1CFBC1, 0xBF1DFBC1, 0xBF1EFBC1, 0xBF1FFBC1, 0xBF20FBC1, 0xBF21FBC1, 0xBF22FBC1, 0xBF23FBC1, 0xBF24FBC1, 0xBF25FBC1, 0xBF26FBC1, 0xBF27FBC1, 0xBF28FBC1, 0xBF29FBC1, 0xBF2AFBC1, 0xBF2BFBC1, 0xBF2CFBC1, 0xBF2DFBC1, 0xBF2EFBC1, 0xBF2FFBC1, 0xBF30FBC1, 0xBF31FBC1, 0xBF32FBC1, 0xBF33FBC1, 0xBF34FBC1, 0xBF35FBC1, 0xBF36FBC1, 0xBF37FBC1, 0xBF38FBC1, 0xBF39FBC1, 0xBF3AFBC1, 0xBF3BFBC1, 0xBF3CFBC1, 0xBF3DFBC1, 0xBF3EFBC1, 0xBF3FFBC1, 0xBF40FBC1, 0xBF41FBC1, 0xBF42FBC1, 0xBF43FBC1, 0xBF44FBC1, 0xBF45FBC1, 0xBF46FBC1, 0xBF47FBC1, 0xBF48FBC1, 0xBF49FBC1, /* BEA0 */
+ 0xBF4AFBC1, 0xBF4BFBC1, 0xBF4CFBC1, 0xBF4DFBC1, 0xBF4EFBC1, 0xBF4FFBC1, 0xBF50FBC1, 0xBF51FBC1, 0xBF52FBC1, 0xBF53FBC1, 0xBF54FBC1, 0xBF55FBC1, 0xBF56FBC1, 0xBF57FBC1, 0xBF58FBC1, 0xBF59FBC1, 0xBF5AFBC1, 0xBF5BFBC1, 0xBF5CFBC1, 0xBF5DFBC1, 0xBF5EFBC1, 0xBF5FFBC1, 0xBF60FBC1, 0xBF61FBC1, 0xBF62FBC1, 0xBF63FBC1, 0xBF64FBC1, 0xBF65FBC1, 0xBF66FBC1, 0xBF67FBC1, 0xBF68FBC1, 0xBF69FBC1, 0xBF6AFBC1, 0xBF6BFBC1, 0xBF6CFBC1, 0xBF6DFBC1, 0xBF6EFBC1, 0xBF6FFBC1, 0xBF70FBC1, 0xBF71FBC1, 0xBF72FBC1, 0xBF73FBC1, 0xBF74FBC1, 0xBF75FBC1, 0xBF76FBC1, 0xBF77FBC1, 0xBF78FBC1, 0xBF79FBC1, 0xBF7AFBC1, 0xBF7BFBC1, 0xBF7CFBC1, 0xBF7DFBC1, 0xBF7EFBC1, 0xBF7FFBC1, 0xBF80FBC1, 0xBF81FBC1, 0xBF82FBC1, 0xBF83FBC1, 0xBF84FBC1, 0xBF85FBC1, 0xBF86FBC1, 0xBF87FBC1, 0xBF88FBC1, 0xBF89FBC1, 0xBF8AFBC1, 0xBF8BFBC1, 0xBF8CFBC1, 0xBF8DFBC1, 0xBF8EFBC1, 0xBF8FFBC1, 0xBF90FBC1, 0xBF91FBC1, 0xBF92FBC1, 0xBF93FBC1, 0xBF94FBC1, 0xBF95FBC1, 0xBF96FBC1, 0xBF97FBC1, 0xBF98FBC1, 0xBF99FBC1, 0xBF9AFBC1, 0xBF9BFBC1, 0xBF9CFBC1, 0xBF9DFBC1, 0xBF9EFBC1, 0xBF9FFBC1, 0xBFA0FBC1, 0xBFA1FBC1, 0xBFA2FBC1, 0xBFA3FBC1, 0xBFA4FBC1, 0xBFA5FBC1, 0xBFA6FBC1, 0xBFA7FBC1, 0xBFA8FBC1, 0xBFA9FBC1, 0xBFAAFBC1, 0xBFABFBC1, 0xBFACFBC1, 0xBFADFBC1, 0xBFAEFBC1, 0xBFAFFBC1, 0xBFB0FBC1, 0xBFB1FBC1, 0xBFB2FBC1, 0xBFB3FBC1, 0xBFB4FBC1, 0xBFB5FBC1, 0xBFB6FBC1, 0xBFB7FBC1, 0xBFB8FBC1, 0xBFB9FBC1, 0xBFBAFBC1, 0xBFBBFBC1, 0xBFBCFBC1, 0xBFBDFBC1, 0xBFBEFBC1, 0xBFBFFBC1, 0xBFC0FBC1, 0xBFC1FBC1, 0xBFC2FBC1, 0xBFC3FBC1, 0xBFC4FBC1, 0xBFC5FBC1, 0xBFC6FBC1, 0xBFC7FBC1, 0xBFC8FBC1, 0xBFC9FBC1, 0xBFCAFBC1, 0xBFCBFBC1, 0xBFCCFBC1, 0xBFCDFBC1, 0xBFCEFBC1, 0xBFCFFBC1, 0xBFD0FBC1, 0xBFD1FBC1, 0xBFD2FBC1, 0xBFD3FBC1, 0xBFD4FBC1, 0xBFD5FBC1, 0xBFD6FBC1, 0xBFD7FBC1, 0xBFD8FBC1, 0xBFD9FBC1, 0xBFDAFBC1, 0xBFDBFBC1, 0xBFDCFBC1, 0xBFDDFBC1, 0xBFDEFBC1, 0xBFDFFBC1, 0xBFE0FBC1, 0xBFE1FBC1, 0xBFE2FBC1, 0xBFE3FBC1, 0xBFE4FBC1, 0xBFE5FBC1, 0xBFE6FBC1, 0xBFE7FBC1, 0xBFE8FBC1, 0xBFE9FBC1, 0xBFEAFBC1, 0xBFEBFBC1, 0xBFECFBC1, 0xBFEDFBC1, 0xBFEEFBC1, 0xBFEFFBC1, 0xBFF0FBC1, 0xBFF1FBC1, 0xBFF2FBC1, 0xBFF3FBC1, /* BF4A */
+ 0xBFF4FBC1, 0xBFF5FBC1, 0xBFF6FBC1, 0xBFF7FBC1, 0xBFF8FBC1, 0xBFF9FBC1, 0xBFFAFBC1, 0xBFFBFBC1, 0xBFFCFBC1, 0xBFFDFBC1, 0xBFFEFBC1, 0xBFFFFBC1, 0xC000FBC1, 0xC001FBC1, 0xC002FBC1, 0xC003FBC1, 0xC004FBC1, 0xC005FBC1, 0xC006FBC1, 0xC007FBC1, 0xC008FBC1, 0xC009FBC1, 0xC00AFBC1, 0xC00BFBC1, 0xC00CFBC1, 0xC00DFBC1, 0xC00EFBC1, 0xC00FFBC1, 0xC010FBC1, 0xC011FBC1, 0xC012FBC1, 0xC013FBC1, 0xC014FBC1, 0xC015FBC1, 0xC016FBC1, 0xC017FBC1, 0xC018FBC1, 0xC019FBC1, 0xC01AFBC1, 0xC01BFBC1, 0xC01CFBC1, 0xC01DFBC1, 0xC01EFBC1, 0xC01FFBC1, 0xC020FBC1, 0xC021FBC1, 0xC022FBC1, 0xC023FBC1, 0xC024FBC1, 0xC025FBC1, 0xC026FBC1, 0xC027FBC1, 0xC028FBC1, 0xC029FBC1, 0xC02AFBC1, 0xC02BFBC1, 0xC02CFBC1, 0xC02DFBC1, 0xC02EFBC1, 0xC02FFBC1, 0xC030FBC1, 0xC031FBC1, 0xC032FBC1, 0xC033FBC1, 0xC034FBC1, 0xC035FBC1, 0xC036FBC1, 0xC037FBC1, 0xC038FBC1, 0xC039FBC1, 0xC03AFBC1, 0xC03BFBC1, 0xC03CFBC1, 0xC03DFBC1, 0xC03EFBC1, 0xC03FFBC1, 0xC040FBC1, 0xC041FBC1, 0xC042FBC1, 0xC043FBC1, 0xC044FBC1, 0xC045FBC1, 0xC046FBC1, 0xC047FBC1, 0xC048FBC1, 0xC049FBC1, 0xC04AFBC1, 0xC04BFBC1, 0xC04CFBC1, 0xC04DFBC1, 0xC04EFBC1, 0xC04FFBC1, 0xC050FBC1, 0xC051FBC1, 0xC052FBC1, 0xC053FBC1, 0xC054FBC1, 0xC055FBC1, 0xC056FBC1, 0xC057FBC1, 0xC058FBC1, 0xC059FBC1, 0xC05AFBC1, 0xC05BFBC1, 0xC05CFBC1, 0xC05DFBC1, 0xC05EFBC1, 0xC05FFBC1, 0xC060FBC1, 0xC061FBC1, 0xC062FBC1, 0xC063FBC1, 0xC064FBC1, 0xC065FBC1, 0xC066FBC1, 0xC067FBC1, 0xC068FBC1, 0xC069FBC1, 0xC06AFBC1, 0xC06BFBC1, 0xC06CFBC1, 0xC06DFBC1, 0xC06EFBC1, 0xC06FFBC1, 0xC070FBC1, 0xC071FBC1, 0xC072FBC1, 0xC073FBC1, 0xC074FBC1, 0xC075FBC1, 0xC076FBC1, 0xC077FBC1, 0xC078FBC1, 0xC079FBC1, 0xC07AFBC1, 0xC07BFBC1, 0xC07CFBC1, 0xC07DFBC1, 0xC07EFBC1, 0xC07FFBC1, 0xC080FBC1, 0xC081FBC1, 0xC082FBC1, 0xC083FBC1, 0xC084FBC1, 0xC085FBC1, 0xC086FBC1, 0xC087FBC1, 0xC088FBC1, 0xC089FBC1, 0xC08AFBC1, 0xC08BFBC1, 0xC08CFBC1, 0xC08DFBC1, 0xC08EFBC1, 0xC08FFBC1, 0xC090FBC1, 0xC091FBC1, 0xC092FBC1, 0xC093FBC1, 0xC094FBC1, 0xC095FBC1, 0xC096FBC1, 0xC097FBC1, 0xC098FBC1, 0xC099FBC1, 0xC09AFBC1, 0xC09BFBC1, 0xC09CFBC1, 0xC09DFBC1, /* BFF4 */
+ 0xC09EFBC1, 0xC09FFBC1, 0xC0A0FBC1, 0xC0A1FBC1, 0xC0A2FBC1, 0xC0A3FBC1, 0xC0A4FBC1, 0xC0A5FBC1, 0xC0A6FBC1, 0xC0A7FBC1, 0xC0A8FBC1, 0xC0A9FBC1, 0xC0AAFBC1, 0xC0ABFBC1, 0xC0ACFBC1, 0xC0ADFBC1, 0xC0AEFBC1, 0xC0AFFBC1, 0xC0B0FBC1, 0xC0B1FBC1, 0xC0B2FBC1, 0xC0B3FBC1, 0xC0B4FBC1, 0xC0B5FBC1, 0xC0B6FBC1, 0xC0B7FBC1, 0xC0B8FBC1, 0xC0B9FBC1, 0xC0BAFBC1, 0xC0BBFBC1, 0xC0BCFBC1, 0xC0BDFBC1, 0xC0BEFBC1, 0xC0BFFBC1, 0xC0C0FBC1, 0xC0C1FBC1, 0xC0C2FBC1, 0xC0C3FBC1, 0xC0C4FBC1, 0xC0C5FBC1, 0xC0C6FBC1, 0xC0C7FBC1, 0xC0C8FBC1, 0xC0C9FBC1, 0xC0CAFBC1, 0xC0CBFBC1, 0xC0CCFBC1, 0xC0CDFBC1, 0xC0CEFBC1, 0xC0CFFBC1, 0xC0D0FBC1, 0xC0D1FBC1, 0xC0D2FBC1, 0xC0D3FBC1, 0xC0D4FBC1, 0xC0D5FBC1, 0xC0D6FBC1, 0xC0D7FBC1, 0xC0D8FBC1, 0xC0D9FBC1, 0xC0DAFBC1, 0xC0DBFBC1, 0xC0DCFBC1, 0xC0DDFBC1, 0xC0DEFBC1, 0xC0DFFBC1, 0xC0E0FBC1, 0xC0E1FBC1, 0xC0E2FBC1, 0xC0E3FBC1, 0xC0E4FBC1, 0xC0E5FBC1, 0xC0E6FBC1, 0xC0E7FBC1, 0xC0E8FBC1, 0xC0E9FBC1, 0xC0EAFBC1, 0xC0EBFBC1, 0xC0ECFBC1, 0xC0EDFBC1, 0xC0EEFBC1, 0xC0EFFBC1, 0xC0F0FBC1, 0xC0F1FBC1, 0xC0F2FBC1, 0xC0F3FBC1, 0xC0F4FBC1, 0xC0F5FBC1, 0xC0F6FBC1, 0xC0F7FBC1, 0xC0F8FBC1, 0xC0F9FBC1, 0xC0FAFBC1, 0xC0FBFBC1, 0xC0FCFBC1, 0xC0FDFBC1, 0xC0FEFBC1, 0xC0FFFBC1, 0xC100FBC1, 0xC101FBC1, 0xC102FBC1, 0xC103FBC1, 0xC104FBC1, 0xC105FBC1, 0xC106FBC1, 0xC107FBC1, 0xC108FBC1, 0xC109FBC1, 0xC10AFBC1, 0xC10BFBC1, 0xC10CFBC1, 0xC10DFBC1, 0xC10EFBC1, 0xC10FFBC1, 0xC110FBC1, 0xC111FBC1, 0xC112FBC1, 0xC113FBC1, 0xC114FBC1, 0xC115FBC1, 0xC116FBC1, 0xC117FBC1, 0xC118FBC1, 0xC119FBC1, 0xC11AFBC1, 0xC11BFBC1, 0xC11CFBC1, 0xC11DFBC1, 0xC11EFBC1, 0xC11FFBC1, 0xC120FBC1, 0xC121FBC1, 0xC122FBC1, 0xC123FBC1, 0xC124FBC1, 0xC125FBC1, 0xC126FBC1, 0xC127FBC1, 0xC128FBC1, 0xC129FBC1, 0xC12AFBC1, 0xC12BFBC1, 0xC12CFBC1, 0xC12DFBC1, 0xC12EFBC1, 0xC12FFBC1, 0xC130FBC1, 0xC131FBC1, 0xC132FBC1, 0xC133FBC1, 0xC134FBC1, 0xC135FBC1, 0xC136FBC1, 0xC137FBC1, 0xC138FBC1, 0xC139FBC1, 0xC13AFBC1, 0xC13BFBC1, 0xC13CFBC1, 0xC13DFBC1, 0xC13EFBC1, 0xC13FFBC1, 0xC140FBC1, 0xC141FBC1, 0xC142FBC1, 0xC143FBC1, 0xC144FBC1, 0xC145FBC1, 0xC146FBC1, 0xC147FBC1, /* C09E */
+ 0xC148FBC1, 0xC149FBC1, 0xC14AFBC1, 0xC14BFBC1, 0xC14CFBC1, 0xC14DFBC1, 0xC14EFBC1, 0xC14FFBC1, 0xC150FBC1, 0xC151FBC1, 0xC152FBC1, 0xC153FBC1, 0xC154FBC1, 0xC155FBC1, 0xC156FBC1, 0xC157FBC1, 0xC158FBC1, 0xC159FBC1, 0xC15AFBC1, 0xC15BFBC1, 0xC15CFBC1, 0xC15DFBC1, 0xC15EFBC1, 0xC15FFBC1, 0xC160FBC1, 0xC161FBC1, 0xC162FBC1, 0xC163FBC1, 0xC164FBC1, 0xC165FBC1, 0xC166FBC1, 0xC167FBC1, 0xC168FBC1, 0xC169FBC1, 0xC16AFBC1, 0xC16BFBC1, 0xC16CFBC1, 0xC16DFBC1, 0xC16EFBC1, 0xC16FFBC1, 0xC170FBC1, 0xC171FBC1, 0xC172FBC1, 0xC173FBC1, 0xC174FBC1, 0xC175FBC1, 0xC176FBC1, 0xC177FBC1, 0xC178FBC1, 0xC179FBC1, 0xC17AFBC1, 0xC17BFBC1, 0xC17CFBC1, 0xC17DFBC1, 0xC17EFBC1, 0xC17FFBC1, 0xC180FBC1, 0xC181FBC1, 0xC182FBC1, 0xC183FBC1, 0xC184FBC1, 0xC185FBC1, 0xC186FBC1, 0xC187FBC1, 0xC188FBC1, 0xC189FBC1, 0xC18AFBC1, 0xC18BFBC1, 0xC18CFBC1, 0xC18DFBC1, 0xC18EFBC1, 0xC18FFBC1, 0xC190FBC1, 0xC191FBC1, 0xC192FBC1, 0xC193FBC1, 0xC194FBC1, 0xC195FBC1, 0xC196FBC1, 0xC197FBC1, 0xC198FBC1, 0xC199FBC1, 0xC19AFBC1, 0xC19BFBC1, 0xC19CFBC1, 0xC19DFBC1, 0xC19EFBC1, 0xC19FFBC1, 0xC1A0FBC1, 0xC1A1FBC1, 0xC1A2FBC1, 0xC1A3FBC1, 0xC1A4FBC1, 0xC1A5FBC1, 0xC1A6FBC1, 0xC1A7FBC1, 0xC1A8FBC1, 0xC1A9FBC1, 0xC1AAFBC1, 0xC1ABFBC1, 0xC1ACFBC1, 0xC1ADFBC1, 0xC1AEFBC1, 0xC1AFFBC1, 0xC1B0FBC1, 0xC1B1FBC1, 0xC1B2FBC1, 0xC1B3FBC1, 0xC1B4FBC1, 0xC1B5FBC1, 0xC1B6FBC1, 0xC1B7FBC1, 0xC1B8FBC1, 0xC1B9FBC1, 0xC1BAFBC1, 0xC1BBFBC1, 0xC1BCFBC1, 0xC1BDFBC1, 0xC1BEFBC1, 0xC1BFFBC1, 0xC1C0FBC1, 0xC1C1FBC1, 0xC1C2FBC1, 0xC1C3FBC1, 0xC1C4FBC1, 0xC1C5FBC1, 0xC1C6FBC1, 0xC1C7FBC1, 0xC1C8FBC1, 0xC1C9FBC1, 0xC1CAFBC1, 0xC1CBFBC1, 0xC1CCFBC1, 0xC1CDFBC1, 0xC1CEFBC1, 0xC1CFFBC1, 0xC1D0FBC1, 0xC1D1FBC1, 0xC1D2FBC1, 0xC1D3FBC1, 0xC1D4FBC1, 0xC1D5FBC1, 0xC1D6FBC1, 0xC1D7FBC1, 0xC1D8FBC1, 0xC1D9FBC1, 0xC1DAFBC1, 0xC1DBFBC1, 0xC1DCFBC1, 0xC1DDFBC1, 0xC1DEFBC1, 0xC1DFFBC1, 0xC1E0FBC1, 0xC1E1FBC1, 0xC1E2FBC1, 0xC1E3FBC1, 0xC1E4FBC1, 0xC1E5FBC1, 0xC1E6FBC1, 0xC1E7FBC1, 0xC1E8FBC1, 0xC1E9FBC1, 0xC1EAFBC1, 0xC1EBFBC1, 0xC1ECFBC1, 0xC1EDFBC1, 0xC1EEFBC1, 0xC1EFFBC1, 0xC1F0FBC1, 0xC1F1FBC1, /* C148 */
+ 0xC1F2FBC1, 0xC1F3FBC1, 0xC1F4FBC1, 0xC1F5FBC1, 0xC1F6FBC1, 0xC1F7FBC1, 0xC1F8FBC1, 0xC1F9FBC1, 0xC1FAFBC1, 0xC1FBFBC1, 0xC1FCFBC1, 0xC1FDFBC1, 0xC1FEFBC1, 0xC1FFFBC1, 0xC200FBC1, 0xC201FBC1, 0xC202FBC1, 0xC203FBC1, 0xC204FBC1, 0xC205FBC1, 0xC206FBC1, 0xC207FBC1, 0xC208FBC1, 0xC209FBC1, 0xC20AFBC1, 0xC20BFBC1, 0xC20CFBC1, 0xC20DFBC1, 0xC20EFBC1, 0xC20FFBC1, 0xC210FBC1, 0xC211FBC1, 0xC212FBC1, 0xC213FBC1, 0xC214FBC1, 0xC215FBC1, 0xC216FBC1, 0xC217FBC1, 0xC218FBC1, 0xC219FBC1, 0xC21AFBC1, 0xC21BFBC1, 0xC21CFBC1, 0xC21DFBC1, 0xC21EFBC1, 0xC21FFBC1, 0xC220FBC1, 0xC221FBC1, 0xC222FBC1, 0xC223FBC1, 0xC224FBC1, 0xC225FBC1, 0xC226FBC1, 0xC227FBC1, 0xC228FBC1, 0xC229FBC1, 0xC22AFBC1, 0xC22BFBC1, 0xC22CFBC1, 0xC22DFBC1, 0xC22EFBC1, 0xC22FFBC1, 0xC230FBC1, 0xC231FBC1, 0xC232FBC1, 0xC233FBC1, 0xC234FBC1, 0xC235FBC1, 0xC236FBC1, 0xC237FBC1, 0xC238FBC1, 0xC239FBC1, 0xC23AFBC1, 0xC23BFBC1, 0xC23CFBC1, 0xC23DFBC1, 0xC23EFBC1, 0xC23FFBC1, 0xC240FBC1, 0xC241FBC1, 0xC242FBC1, 0xC243FBC1, 0xC244FBC1, 0xC245FBC1, 0xC246FBC1, 0xC247FBC1, 0xC248FBC1, 0xC249FBC1, 0xC24AFBC1, 0xC24BFBC1, 0xC24CFBC1, 0xC24DFBC1, 0xC24EFBC1, 0xC24FFBC1, 0xC250FBC1, 0xC251FBC1, 0xC252FBC1, 0xC253FBC1, 0xC254FBC1, 0xC255FBC1, 0xC256FBC1, 0xC257FBC1, 0xC258FBC1, 0xC259FBC1, 0xC25AFBC1, 0xC25BFBC1, 0xC25CFBC1, 0xC25DFBC1, 0xC25EFBC1, 0xC25FFBC1, 0xC260FBC1, 0xC261FBC1, 0xC262FBC1, 0xC263FBC1, 0xC264FBC1, 0xC265FBC1, 0xC266FBC1, 0xC267FBC1, 0xC268FBC1, 0xC269FBC1, 0xC26AFBC1, 0xC26BFBC1, 0xC26CFBC1, 0xC26DFBC1, 0xC26EFBC1, 0xC26FFBC1, 0xC270FBC1, 0xC271FBC1, 0xC272FBC1, 0xC273FBC1, 0xC274FBC1, 0xC275FBC1, 0xC276FBC1, 0xC277FBC1, 0xC278FBC1, 0xC279FBC1, 0xC27AFBC1, 0xC27BFBC1, 0xC27CFBC1, 0xC27DFBC1, 0xC27EFBC1, 0xC27FFBC1, 0xC280FBC1, 0xC281FBC1, 0xC282FBC1, 0xC283FBC1, 0xC284FBC1, 0xC285FBC1, 0xC286FBC1, 0xC287FBC1, 0xC288FBC1, 0xC289FBC1, 0xC28AFBC1, 0xC28BFBC1, 0xC28CFBC1, 0xC28DFBC1, 0xC28EFBC1, 0xC28FFBC1, 0xC290FBC1, 0xC291FBC1, 0xC292FBC1, 0xC293FBC1, 0xC294FBC1, 0xC295FBC1, 0xC296FBC1, 0xC297FBC1, 0xC298FBC1, 0xC299FBC1, 0xC29AFBC1, 0xC29BFBC1, /* C1F2 */
+ 0xC29CFBC1, 0xC29DFBC1, 0xC29EFBC1, 0xC29FFBC1, 0xC2A0FBC1, 0xC2A1FBC1, 0xC2A2FBC1, 0xC2A3FBC1, 0xC2A4FBC1, 0xC2A5FBC1, 0xC2A6FBC1, 0xC2A7FBC1, 0xC2A8FBC1, 0xC2A9FBC1, 0xC2AAFBC1, 0xC2ABFBC1, 0xC2ACFBC1, 0xC2ADFBC1, 0xC2AEFBC1, 0xC2AFFBC1, 0xC2B0FBC1, 0xC2B1FBC1, 0xC2B2FBC1, 0xC2B3FBC1, 0xC2B4FBC1, 0xC2B5FBC1, 0xC2B6FBC1, 0xC2B7FBC1, 0xC2B8FBC1, 0xC2B9FBC1, 0xC2BAFBC1, 0xC2BBFBC1, 0xC2BCFBC1, 0xC2BDFBC1, 0xC2BEFBC1, 0xC2BFFBC1, 0xC2C0FBC1, 0xC2C1FBC1, 0xC2C2FBC1, 0xC2C3FBC1, 0xC2C4FBC1, 0xC2C5FBC1, 0xC2C6FBC1, 0xC2C7FBC1, 0xC2C8FBC1, 0xC2C9FBC1, 0xC2CAFBC1, 0xC2CBFBC1, 0xC2CCFBC1, 0xC2CDFBC1, 0xC2CEFBC1, 0xC2CFFBC1, 0xC2D0FBC1, 0xC2D1FBC1, 0xC2D2FBC1, 0xC2D3FBC1, 0xC2D4FBC1, 0xC2D5FBC1, 0xC2D6FBC1, 0xC2D7FBC1, 0xC2D8FBC1, 0xC2D9FBC1, 0xC2DAFBC1, 0xC2DBFBC1, 0xC2DCFBC1, 0xC2DDFBC1, 0xC2DEFBC1, 0xC2DFFBC1, 0xC2E0FBC1, 0xC2E1FBC1, 0xC2E2FBC1, 0xC2E3FBC1, 0xC2E4FBC1, 0xC2E5FBC1, 0xC2E6FBC1, 0xC2E7FBC1, 0xC2E8FBC1, 0xC2E9FBC1, 0xC2EAFBC1, 0xC2EBFBC1, 0xC2ECFBC1, 0xC2EDFBC1, 0xC2EEFBC1, 0xC2EFFBC1, 0xC2F0FBC1, 0xC2F1FBC1, 0xC2F2FBC1, 0xC2F3FBC1, 0xC2F4FBC1, 0xC2F5FBC1, 0xC2F6FBC1, 0xC2F7FBC1, 0xC2F8FBC1, 0xC2F9FBC1, 0xC2FAFBC1, 0xC2FBFBC1, 0xC2FCFBC1, 0xC2FDFBC1, 0xC2FEFBC1, 0xC2FFFBC1, 0xC300FBC1, 0xC301FBC1, 0xC302FBC1, 0xC303FBC1, 0xC304FBC1, 0xC305FBC1, 0xC306FBC1, 0xC307FBC1, 0xC308FBC1, 0xC309FBC1, 0xC30AFBC1, 0xC30BFBC1, 0xC30CFBC1, 0xC30DFBC1, 0xC30EFBC1, 0xC30FFBC1, 0xC310FBC1, 0xC311FBC1, 0xC312FBC1, 0xC313FBC1, 0xC314FBC1, 0xC315FBC1, 0xC316FBC1, 0xC317FBC1, 0xC318FBC1, 0xC319FBC1, 0xC31AFBC1, 0xC31BFBC1, 0xC31CFBC1, 0xC31DFBC1, 0xC31EFBC1, 0xC31FFBC1, 0xC320FBC1, 0xC321FBC1, 0xC322FBC1, 0xC323FBC1, 0xC324FBC1, 0xC325FBC1, 0xC326FBC1, 0xC327FBC1, 0xC328FBC1, 0xC329FBC1, 0xC32AFBC1, 0xC32BFBC1, 0xC32CFBC1, 0xC32DFBC1, 0xC32EFBC1, 0xC32FFBC1, 0xC330FBC1, 0xC331FBC1, 0xC332FBC1, 0xC333FBC1, 0xC334FBC1, 0xC335FBC1, 0xC336FBC1, 0xC337FBC1, 0xC338FBC1, 0xC339FBC1, 0xC33AFBC1, 0xC33BFBC1, 0xC33CFBC1, 0xC33DFBC1, 0xC33EFBC1, 0xC33FFBC1, 0xC340FBC1, 0xC341FBC1, 0xC342FBC1, 0xC343FBC1, 0xC344FBC1, 0xC345FBC1, /* C29C */
+ 0xC346FBC1, 0xC347FBC1, 0xC348FBC1, 0xC349FBC1, 0xC34AFBC1, 0xC34BFBC1, 0xC34CFBC1, 0xC34DFBC1, 0xC34EFBC1, 0xC34FFBC1, 0xC350FBC1, 0xC351FBC1, 0xC352FBC1, 0xC353FBC1, 0xC354FBC1, 0xC355FBC1, 0xC356FBC1, 0xC357FBC1, 0xC358FBC1, 0xC359FBC1, 0xC35AFBC1, 0xC35BFBC1, 0xC35CFBC1, 0xC35DFBC1, 0xC35EFBC1, 0xC35FFBC1, 0xC360FBC1, 0xC361FBC1, 0xC362FBC1, 0xC363FBC1, 0xC364FBC1, 0xC365FBC1, 0xC366FBC1, 0xC367FBC1, 0xC368FBC1, 0xC369FBC1, 0xC36AFBC1, 0xC36BFBC1, 0xC36CFBC1, 0xC36DFBC1, 0xC36EFBC1, 0xC36FFBC1, 0xC370FBC1, 0xC371FBC1, 0xC372FBC1, 0xC373FBC1, 0xC374FBC1, 0xC375FBC1, 0xC376FBC1, 0xC377FBC1, 0xC378FBC1, 0xC379FBC1, 0xC37AFBC1, 0xC37BFBC1, 0xC37CFBC1, 0xC37DFBC1, 0xC37EFBC1, 0xC37FFBC1, 0xC380FBC1, 0xC381FBC1, 0xC382FBC1, 0xC383FBC1, 0xC384FBC1, 0xC385FBC1, 0xC386FBC1, 0xC387FBC1, 0xC388FBC1, 0xC389FBC1, 0xC38AFBC1, 0xC38BFBC1, 0xC38CFBC1, 0xC38DFBC1, 0xC38EFBC1, 0xC38FFBC1, 0xC390FBC1, 0xC391FBC1, 0xC392FBC1, 0xC393FBC1, 0xC394FBC1, 0xC395FBC1, 0xC396FBC1, 0xC397FBC1, 0xC398FBC1, 0xC399FBC1, 0xC39AFBC1, 0xC39BFBC1, 0xC39CFBC1, 0xC39DFBC1, 0xC39EFBC1, 0xC39FFBC1, 0xC3A0FBC1, 0xC3A1FBC1, 0xC3A2FBC1, 0xC3A3FBC1, 0xC3A4FBC1, 0xC3A5FBC1, 0xC3A6FBC1, 0xC3A7FBC1, 0xC3A8FBC1, 0xC3A9FBC1, 0xC3AAFBC1, 0xC3ABFBC1, 0xC3ACFBC1, 0xC3ADFBC1, 0xC3AEFBC1, 0xC3AFFBC1, 0xC3B0FBC1, 0xC3B1FBC1, 0xC3B2FBC1, 0xC3B3FBC1, 0xC3B4FBC1, 0xC3B5FBC1, 0xC3B6FBC1, 0xC3B7FBC1, 0xC3B8FBC1, 0xC3B9FBC1, 0xC3BAFBC1, 0xC3BBFBC1, 0xC3BCFBC1, 0xC3BDFBC1, 0xC3BEFBC1, 0xC3BFFBC1, 0xC3C0FBC1, 0xC3C1FBC1, 0xC3C2FBC1, 0xC3C3FBC1, 0xC3C4FBC1, 0xC3C5FBC1, 0xC3C6FBC1, 0xC3C7FBC1, 0xC3C8FBC1, 0xC3C9FBC1, 0xC3CAFBC1, 0xC3CBFBC1, 0xC3CCFBC1, 0xC3CDFBC1, 0xC3CEFBC1, 0xC3CFFBC1, 0xC3D0FBC1, 0xC3D1FBC1, 0xC3D2FBC1, 0xC3D3FBC1, 0xC3D4FBC1, 0xC3D5FBC1, 0xC3D6FBC1, 0xC3D7FBC1, 0xC3D8FBC1, 0xC3D9FBC1, 0xC3DAFBC1, 0xC3DBFBC1, 0xC3DCFBC1, 0xC3DDFBC1, 0xC3DEFBC1, 0xC3DFFBC1, 0xC3E0FBC1, 0xC3E1FBC1, 0xC3E2FBC1, 0xC3E3FBC1, 0xC3E4FBC1, 0xC3E5FBC1, 0xC3E6FBC1, 0xC3E7FBC1, 0xC3E8FBC1, 0xC3E9FBC1, 0xC3EAFBC1, 0xC3EBFBC1, 0xC3ECFBC1, 0xC3EDFBC1, 0xC3EEFBC1, 0xC3EFFBC1, /* C346 */
+ 0xC3F0FBC1, 0xC3F1FBC1, 0xC3F2FBC1, 0xC3F3FBC1, 0xC3F4FBC1, 0xC3F5FBC1, 0xC3F6FBC1, 0xC3F7FBC1, 0xC3F8FBC1, 0xC3F9FBC1, 0xC3FAFBC1, 0xC3FBFBC1, 0xC3FCFBC1, 0xC3FDFBC1, 0xC3FEFBC1, 0xC3FFFBC1, 0xC400FBC1, 0xC401FBC1, 0xC402FBC1, 0xC403FBC1, 0xC404FBC1, 0xC405FBC1, 0xC406FBC1, 0xC407FBC1, 0xC408FBC1, 0xC409FBC1, 0xC40AFBC1, 0xC40BFBC1, 0xC40CFBC1, 0xC40DFBC1, 0xC40EFBC1, 0xC40FFBC1, 0xC410FBC1, 0xC411FBC1, 0xC412FBC1, 0xC413FBC1, 0xC414FBC1, 0xC415FBC1, 0xC416FBC1, 0xC417FBC1, 0xC418FBC1, 0xC419FBC1, 0xC41AFBC1, 0xC41BFBC1, 0xC41CFBC1, 0xC41DFBC1, 0xC41EFBC1, 0xC41FFBC1, 0xC420FBC1, 0xC421FBC1, 0xC422FBC1, 0xC423FBC1, 0xC424FBC1, 0xC425FBC1, 0xC426FBC1, 0xC427FBC1, 0xC428FBC1, 0xC429FBC1, 0xC42AFBC1, 0xC42BFBC1, 0xC42CFBC1, 0xC42DFBC1, 0xC42EFBC1, 0xC42FFBC1, 0xC430FBC1, 0xC431FBC1, 0xC432FBC1, 0xC433FBC1, 0xC434FBC1, 0xC435FBC1, 0xC436FBC1, 0xC437FBC1, 0xC438FBC1, 0xC439FBC1, 0xC43AFBC1, 0xC43BFBC1, 0xC43CFBC1, 0xC43DFBC1, 0xC43EFBC1, 0xC43FFBC1, 0xC440FBC1, 0xC441FBC1, 0xC442FBC1, 0xC443FBC1, 0xC444FBC1, 0xC445FBC1, 0xC446FBC1, 0xC447FBC1, 0xC448FBC1, 0xC449FBC1, 0xC44AFBC1, 0xC44BFBC1, 0xC44CFBC1, 0xC44DFBC1, 0xC44EFBC1, 0xC44FFBC1, 0xC450FBC1, 0xC451FBC1, 0xC452FBC1, 0xC453FBC1, 0xC454FBC1, 0xC455FBC1, 0xC456FBC1, 0xC457FBC1, 0xC458FBC1, 0xC459FBC1, 0xC45AFBC1, 0xC45BFBC1, 0xC45CFBC1, 0xC45DFBC1, 0xC45EFBC1, 0xC45FFBC1, 0xC460FBC1, 0xC461FBC1, 0xC462FBC1, 0xC463FBC1, 0xC464FBC1, 0xC465FBC1, 0xC466FBC1, 0xC467FBC1, 0xC468FBC1, 0xC469FBC1, 0xC46AFBC1, 0xC46BFBC1, 0xC46CFBC1, 0xC46DFBC1, 0xC46EFBC1, 0xC46FFBC1, 0xC470FBC1, 0xC471FBC1, 0xC472FBC1, 0xC473FBC1, 0xC474FBC1, 0xC475FBC1, 0xC476FBC1, 0xC477FBC1, 0xC478FBC1, 0xC479FBC1, 0xC47AFBC1, 0xC47BFBC1, 0xC47CFBC1, 0xC47DFBC1, 0xC47EFBC1, 0xC47FFBC1, 0xC480FBC1, 0xC481FBC1, 0xC482FBC1, 0xC483FBC1, 0xC484FBC1, 0xC485FBC1, 0xC486FBC1, 0xC487FBC1, 0xC488FBC1, 0xC489FBC1, 0xC48AFBC1, 0xC48BFBC1, 0xC48CFBC1, 0xC48DFBC1, 0xC48EFBC1, 0xC48FFBC1, 0xC490FBC1, 0xC491FBC1, 0xC492FBC1, 0xC493FBC1, 0xC494FBC1, 0xC495FBC1, 0xC496FBC1, 0xC497FBC1, 0xC498FBC1, 0xC499FBC1, /* C3F0 */
+ 0xC49AFBC1, 0xC49BFBC1, 0xC49CFBC1, 0xC49DFBC1, 0xC49EFBC1, 0xC49FFBC1, 0xC4A0FBC1, 0xC4A1FBC1, 0xC4A2FBC1, 0xC4A3FBC1, 0xC4A4FBC1, 0xC4A5FBC1, 0xC4A6FBC1, 0xC4A7FBC1, 0xC4A8FBC1, 0xC4A9FBC1, 0xC4AAFBC1, 0xC4ABFBC1, 0xC4ACFBC1, 0xC4ADFBC1, 0xC4AEFBC1, 0xC4AFFBC1, 0xC4B0FBC1, 0xC4B1FBC1, 0xC4B2FBC1, 0xC4B3FBC1, 0xC4B4FBC1, 0xC4B5FBC1, 0xC4B6FBC1, 0xC4B7FBC1, 0xC4B8FBC1, 0xC4B9FBC1, 0xC4BAFBC1, 0xC4BBFBC1, 0xC4BCFBC1, 0xC4BDFBC1, 0xC4BEFBC1, 0xC4BFFBC1, 0xC4C0FBC1, 0xC4C1FBC1, 0xC4C2FBC1, 0xC4C3FBC1, 0xC4C4FBC1, 0xC4C5FBC1, 0xC4C6FBC1, 0xC4C7FBC1, 0xC4C8FBC1, 0xC4C9FBC1, 0xC4CAFBC1, 0xC4CBFBC1, 0xC4CCFBC1, 0xC4CDFBC1, 0xC4CEFBC1, 0xC4CFFBC1, 0xC4D0FBC1, 0xC4D1FBC1, 0xC4D2FBC1, 0xC4D3FBC1, 0xC4D4FBC1, 0xC4D5FBC1, 0xC4D6FBC1, 0xC4D7FBC1, 0xC4D8FBC1, 0xC4D9FBC1, 0xC4DAFBC1, 0xC4DBFBC1, 0xC4DCFBC1, 0xC4DDFBC1, 0xC4DEFBC1, 0xC4DFFBC1, 0xC4E0FBC1, 0xC4E1FBC1, 0xC4E2FBC1, 0xC4E3FBC1, 0xC4E4FBC1, 0xC4E5FBC1, 0xC4E6FBC1, 0xC4E7FBC1, 0xC4E8FBC1, 0xC4E9FBC1, 0xC4EAFBC1, 0xC4EBFBC1, 0xC4ECFBC1, 0xC4EDFBC1, 0xC4EEFBC1, 0xC4EFFBC1, 0xC4F0FBC1, 0xC4F1FBC1, 0xC4F2FBC1, 0xC4F3FBC1, 0xC4F4FBC1, 0xC4F5FBC1, 0xC4F6FBC1, 0xC4F7FBC1, 0xC4F8FBC1, 0xC4F9FBC1, 0xC4FAFBC1, 0xC4FBFBC1, 0xC4FCFBC1, 0xC4FDFBC1, 0xC4FEFBC1, 0xC4FFFBC1, 0xC500FBC1, 0xC501FBC1, 0xC502FBC1, 0xC503FBC1, 0xC504FBC1, 0xC505FBC1, 0xC506FBC1, 0xC507FBC1, 0xC508FBC1, 0xC509FBC1, 0xC50AFBC1, 0xC50BFBC1, 0xC50CFBC1, 0xC50DFBC1, 0xC50EFBC1, 0xC50FFBC1, 0xC510FBC1, 0xC511FBC1, 0xC512FBC1, 0xC513FBC1, 0xC514FBC1, 0xC515FBC1, 0xC516FBC1, 0xC517FBC1, 0xC518FBC1, 0xC519FBC1, 0xC51AFBC1, 0xC51BFBC1, 0xC51CFBC1, 0xC51DFBC1, 0xC51EFBC1, 0xC51FFBC1, 0xC520FBC1, 0xC521FBC1, 0xC522FBC1, 0xC523FBC1, 0xC524FBC1, 0xC525FBC1, 0xC526FBC1, 0xC527FBC1, 0xC528FBC1, 0xC529FBC1, 0xC52AFBC1, 0xC52BFBC1, 0xC52CFBC1, 0xC52DFBC1, 0xC52EFBC1, 0xC52FFBC1, 0xC530FBC1, 0xC531FBC1, 0xC532FBC1, 0xC533FBC1, 0xC534FBC1, 0xC535FBC1, 0xC536FBC1, 0xC537FBC1, 0xC538FBC1, 0xC539FBC1, 0xC53AFBC1, 0xC53BFBC1, 0xC53CFBC1, 0xC53DFBC1, 0xC53EFBC1, 0xC53FFBC1, 0xC540FBC1, 0xC541FBC1, 0xC542FBC1, 0xC543FBC1, /* C49A */
+ 0xC544FBC1, 0xC545FBC1, 0xC546FBC1, 0xC547FBC1, 0xC548FBC1, 0xC549FBC1, 0xC54AFBC1, 0xC54BFBC1, 0xC54CFBC1, 0xC54DFBC1, 0xC54EFBC1, 0xC54FFBC1, 0xC550FBC1, 0xC551FBC1, 0xC552FBC1, 0xC553FBC1, 0xC554FBC1, 0xC555FBC1, 0xC556FBC1, 0xC557FBC1, 0xC558FBC1, 0xC559FBC1, 0xC55AFBC1, 0xC55BFBC1, 0xC55CFBC1, 0xC55DFBC1, 0xC55EFBC1, 0xC55FFBC1, 0xC560FBC1, 0xC561FBC1, 0xC562FBC1, 0xC563FBC1, 0xC564FBC1, 0xC565FBC1, 0xC566FBC1, 0xC567FBC1, 0xC568FBC1, 0xC569FBC1, 0xC56AFBC1, 0xC56BFBC1, 0xC56CFBC1, 0xC56DFBC1, 0xC56EFBC1, 0xC56FFBC1, 0xC570FBC1, 0xC571FBC1, 0xC572FBC1, 0xC573FBC1, 0xC574FBC1, 0xC575FBC1, 0xC576FBC1, 0xC577FBC1, 0xC578FBC1, 0xC579FBC1, 0xC57AFBC1, 0xC57BFBC1, 0xC57CFBC1, 0xC57DFBC1, 0xC57EFBC1, 0xC57FFBC1, 0xC580FBC1, 0xC581FBC1, 0xC582FBC1, 0xC583FBC1, 0xC584FBC1, 0xC585FBC1, 0xC586FBC1, 0xC587FBC1, 0xC588FBC1, 0xC589FBC1, 0xC58AFBC1, 0xC58BFBC1, 0xC58CFBC1, 0xC58DFBC1, 0xC58EFBC1, 0xC58FFBC1, 0xC590FBC1, 0xC591FBC1, 0xC592FBC1, 0xC593FBC1, 0xC594FBC1, 0xC595FBC1, 0xC596FBC1, 0xC597FBC1, 0xC598FBC1, 0xC599FBC1, 0xC59AFBC1, 0xC59BFBC1, 0xC59CFBC1, 0xC59DFBC1, 0xC59EFBC1, 0xC59FFBC1, 0xC5A0FBC1, 0xC5A1FBC1, 0xC5A2FBC1, 0xC5A3FBC1, 0xC5A4FBC1, 0xC5A5FBC1, 0xC5A6FBC1, 0xC5A7FBC1, 0xC5A8FBC1, 0xC5A9FBC1, 0xC5AAFBC1, 0xC5ABFBC1, 0xC5ACFBC1, 0xC5ADFBC1, 0xC5AEFBC1, 0xC5AFFBC1, 0xC5B0FBC1, 0xC5B1FBC1, 0xC5B2FBC1, 0xC5B3FBC1, 0xC5B4FBC1, 0xC5B5FBC1, 0xC5B6FBC1, 0xC5B7FBC1, 0xC5B8FBC1, 0xC5B9FBC1, 0xC5BAFBC1, 0xC5BBFBC1, 0xC5BCFBC1, 0xC5BDFBC1, 0xC5BEFBC1, 0xC5BFFBC1, 0xC5C0FBC1, 0xC5C1FBC1, 0xC5C2FBC1, 0xC5C3FBC1, 0xC5C4FBC1, 0xC5C5FBC1, 0xC5C6FBC1, 0xC5C7FBC1, 0xC5C8FBC1, 0xC5C9FBC1, 0xC5CAFBC1, 0xC5CBFBC1, 0xC5CCFBC1, 0xC5CDFBC1, 0xC5CEFBC1, 0xC5CFFBC1, 0xC5D0FBC1, 0xC5D1FBC1, 0xC5D2FBC1, 0xC5D3FBC1, 0xC5D4FBC1, 0xC5D5FBC1, 0xC5D6FBC1, 0xC5D7FBC1, 0xC5D8FBC1, 0xC5D9FBC1, 0xC5DAFBC1, 0xC5DBFBC1, 0xC5DCFBC1, 0xC5DDFBC1, 0xC5DEFBC1, 0xC5DFFBC1, 0xC5E0FBC1, 0xC5E1FBC1, 0xC5E2FBC1, 0xC5E3FBC1, 0xC5E4FBC1, 0xC5E5FBC1, 0xC5E6FBC1, 0xC5E7FBC1, 0xC5E8FBC1, 0xC5E9FBC1, 0xC5EAFBC1, 0xC5EBFBC1, 0xC5ECFBC1, 0xC5EDFBC1, /* C544 */
+ 0xC5EEFBC1, 0xC5EFFBC1, 0xC5F0FBC1, 0xC5F1FBC1, 0xC5F2FBC1, 0xC5F3FBC1, 0xC5F4FBC1, 0xC5F5FBC1, 0xC5F6FBC1, 0xC5F7FBC1, 0xC5F8FBC1, 0xC5F9FBC1, 0xC5FAFBC1, 0xC5FBFBC1, 0xC5FCFBC1, 0xC5FDFBC1, 0xC5FEFBC1, 0xC5FFFBC1, 0xC600FBC1, 0xC601FBC1, 0xC602FBC1, 0xC603FBC1, 0xC604FBC1, 0xC605FBC1, 0xC606FBC1, 0xC607FBC1, 0xC608FBC1, 0xC609FBC1, 0xC60AFBC1, 0xC60BFBC1, 0xC60CFBC1, 0xC60DFBC1, 0xC60EFBC1, 0xC60FFBC1, 0xC610FBC1, 0xC611FBC1, 0xC612FBC1, 0xC613FBC1, 0xC614FBC1, 0xC615FBC1, 0xC616FBC1, 0xC617FBC1, 0xC618FBC1, 0xC619FBC1, 0xC61AFBC1, 0xC61BFBC1, 0xC61CFBC1, 0xC61DFBC1, 0xC61EFBC1, 0xC61FFBC1, 0xC620FBC1, 0xC621FBC1, 0xC622FBC1, 0xC623FBC1, 0xC624FBC1, 0xC625FBC1, 0xC626FBC1, 0xC627FBC1, 0xC628FBC1, 0xC629FBC1, 0xC62AFBC1, 0xC62BFBC1, 0xC62CFBC1, 0xC62DFBC1, 0xC62EFBC1, 0xC62FFBC1, 0xC630FBC1, 0xC631FBC1, 0xC632FBC1, 0xC633FBC1, 0xC634FBC1, 0xC635FBC1, 0xC636FBC1, 0xC637FBC1, 0xC638FBC1, 0xC639FBC1, 0xC63AFBC1, 0xC63BFBC1, 0xC63CFBC1, 0xC63DFBC1, 0xC63EFBC1, 0xC63FFBC1, 0xC640FBC1, 0xC641FBC1, 0xC642FBC1, 0xC643FBC1, 0xC644FBC1, 0xC645FBC1, 0xC646FBC1, 0xC647FBC1, 0xC648FBC1, 0xC649FBC1, 0xC64AFBC1, 0xC64BFBC1, 0xC64CFBC1, 0xC64DFBC1, 0xC64EFBC1, 0xC64FFBC1, 0xC650FBC1, 0xC651FBC1, 0xC652FBC1, 0xC653FBC1, 0xC654FBC1, 0xC655FBC1, 0xC656FBC1, 0xC657FBC1, 0xC658FBC1, 0xC659FBC1, 0xC65AFBC1, 0xC65BFBC1, 0xC65CFBC1, 0xC65DFBC1, 0xC65EFBC1, 0xC65FFBC1, 0xC660FBC1, 0xC661FBC1, 0xC662FBC1, 0xC663FBC1, 0xC664FBC1, 0xC665FBC1, 0xC666FBC1, 0xC667FBC1, 0xC668FBC1, 0xC669FBC1, 0xC66AFBC1, 0xC66BFBC1, 0xC66CFBC1, 0xC66DFBC1, 0xC66EFBC1, 0xC66FFBC1, 0xC670FBC1, 0xC671FBC1, 0xC672FBC1, 0xC673FBC1, 0xC674FBC1, 0xC675FBC1, 0xC676FBC1, 0xC677FBC1, 0xC678FBC1, 0xC679FBC1, 0xC67AFBC1, 0xC67BFBC1, 0xC67CFBC1, 0xC67DFBC1, 0xC67EFBC1, 0xC67FFBC1, 0xC680FBC1, 0xC681FBC1, 0xC682FBC1, 0xC683FBC1, 0xC684FBC1, 0xC685FBC1, 0xC686FBC1, 0xC687FBC1, 0xC688FBC1, 0xC689FBC1, 0xC68AFBC1, 0xC68BFBC1, 0xC68CFBC1, 0xC68DFBC1, 0xC68EFBC1, 0xC68FFBC1, 0xC690FBC1, 0xC691FBC1, 0xC692FBC1, 0xC693FBC1, 0xC694FBC1, 0xC695FBC1, 0xC696FBC1, 0xC697FBC1, /* C5EE */
+ 0xC698FBC1, 0xC699FBC1, 0xC69AFBC1, 0xC69BFBC1, 0xC69CFBC1, 0xC69DFBC1, 0xC69EFBC1, 0xC69FFBC1, 0xC6A0FBC1, 0xC6A1FBC1, 0xC6A2FBC1, 0xC6A3FBC1, 0xC6A4FBC1, 0xC6A5FBC1, 0xC6A6FBC1, 0xC6A7FBC1, 0xC6A8FBC1, 0xC6A9FBC1, 0xC6AAFBC1, 0xC6ABFBC1, 0xC6ACFBC1, 0xC6ADFBC1, 0xC6AEFBC1, 0xC6AFFBC1, 0xC6B0FBC1, 0xC6B1FBC1, 0xC6B2FBC1, 0xC6B3FBC1, 0xC6B4FBC1, 0xC6B5FBC1, 0xC6B6FBC1, 0xC6B7FBC1, 0xC6B8FBC1, 0xC6B9FBC1, 0xC6BAFBC1, 0xC6BBFBC1, 0xC6BCFBC1, 0xC6BDFBC1, 0xC6BEFBC1, 0xC6BFFBC1, 0xC6C0FBC1, 0xC6C1FBC1, 0xC6C2FBC1, 0xC6C3FBC1, 0xC6C4FBC1, 0xC6C5FBC1, 0xC6C6FBC1, 0xC6C7FBC1, 0xC6C8FBC1, 0xC6C9FBC1, 0xC6CAFBC1, 0xC6CBFBC1, 0xC6CCFBC1, 0xC6CDFBC1, 0xC6CEFBC1, 0xC6CFFBC1, 0xC6D0FBC1, 0xC6D1FBC1, 0xC6D2FBC1, 0xC6D3FBC1, 0xC6D4FBC1, 0xC6D5FBC1, 0xC6D6FBC1, 0xC6D7FBC1, 0xC6D8FBC1, 0xC6D9FBC1, 0xC6DAFBC1, 0xC6DBFBC1, 0xC6DCFBC1, 0xC6DDFBC1, 0xC6DEFBC1, 0xC6DFFBC1, 0xC6E0FBC1, 0xC6E1FBC1, 0xC6E2FBC1, 0xC6E3FBC1, 0xC6E4FBC1, 0xC6E5FBC1, 0xC6E6FBC1, 0xC6E7FBC1, 0xC6E8FBC1, 0xC6E9FBC1, 0xC6EAFBC1, 0xC6EBFBC1, 0xC6ECFBC1, 0xC6EDFBC1, 0xC6EEFBC1, 0xC6EFFBC1, 0xC6F0FBC1, 0xC6F1FBC1, 0xC6F2FBC1, 0xC6F3FBC1, 0xC6F4FBC1, 0xC6F5FBC1, 0xC6F6FBC1, 0xC6F7FBC1, 0xC6F8FBC1, 0xC6F9FBC1, 0xC6FAFBC1, 0xC6FBFBC1, 0xC6FCFBC1, 0xC6FDFBC1, 0xC6FEFBC1, 0xC6FFFBC1, 0xC700FBC1, 0xC701FBC1, 0xC702FBC1, 0xC703FBC1, 0xC704FBC1, 0xC705FBC1, 0xC706FBC1, 0xC707FBC1, 0xC708FBC1, 0xC709FBC1, 0xC70AFBC1, 0xC70BFBC1, 0xC70CFBC1, 0xC70DFBC1, 0xC70EFBC1, 0xC70FFBC1, 0xC710FBC1, 0xC711FBC1, 0xC712FBC1, 0xC713FBC1, 0xC714FBC1, 0xC715FBC1, 0xC716FBC1, 0xC717FBC1, 0xC718FBC1, 0xC719FBC1, 0xC71AFBC1, 0xC71BFBC1, 0xC71CFBC1, 0xC71DFBC1, 0xC71EFBC1, 0xC71FFBC1, 0xC720FBC1, 0xC721FBC1, 0xC722FBC1, 0xC723FBC1, 0xC724FBC1, 0xC725FBC1, 0xC726FBC1, 0xC727FBC1, 0xC728FBC1, 0xC729FBC1, 0xC72AFBC1, 0xC72BFBC1, 0xC72CFBC1, 0xC72DFBC1, 0xC72EFBC1, 0xC72FFBC1, 0xC730FBC1, 0xC731FBC1, 0xC732FBC1, 0xC733FBC1, 0xC734FBC1, 0xC735FBC1, 0xC736FBC1, 0xC737FBC1, 0xC738FBC1, 0xC739FBC1, 0xC73AFBC1, 0xC73BFBC1, 0xC73CFBC1, 0xC73DFBC1, 0xC73EFBC1, 0xC73FFBC1, 0xC740FBC1, 0xC741FBC1, /* C698 */
+ 0xC742FBC1, 0xC743FBC1, 0xC744FBC1, 0xC745FBC1, 0xC746FBC1, 0xC747FBC1, 0xC748FBC1, 0xC749FBC1, 0xC74AFBC1, 0xC74BFBC1, 0xC74CFBC1, 0xC74DFBC1, 0xC74EFBC1, 0xC74FFBC1, 0xC750FBC1, 0xC751FBC1, 0xC752FBC1, 0xC753FBC1, 0xC754FBC1, 0xC755FBC1, 0xC756FBC1, 0xC757FBC1, 0xC758FBC1, 0xC759FBC1, 0xC75AFBC1, 0xC75BFBC1, 0xC75CFBC1, 0xC75DFBC1, 0xC75EFBC1, 0xC75FFBC1, 0xC760FBC1, 0xC761FBC1, 0xC762FBC1, 0xC763FBC1, 0xC764FBC1, 0xC765FBC1, 0xC766FBC1, 0xC767FBC1, 0xC768FBC1, 0xC769FBC1, 0xC76AFBC1, 0xC76BFBC1, 0xC76CFBC1, 0xC76DFBC1, 0xC76EFBC1, 0xC76FFBC1, 0xC770FBC1, 0xC771FBC1, 0xC772FBC1, 0xC773FBC1, 0xC774FBC1, 0xC775FBC1, 0xC776FBC1, 0xC777FBC1, 0xC778FBC1, 0xC779FBC1, 0xC77AFBC1, 0xC77BFBC1, 0xC77CFBC1, 0xC77DFBC1, 0xC77EFBC1, 0xC77FFBC1, 0xC780FBC1, 0xC781FBC1, 0xC782FBC1, 0xC783FBC1, 0xC784FBC1, 0xC785FBC1, 0xC786FBC1, 0xC787FBC1, 0xC788FBC1, 0xC789FBC1, 0xC78AFBC1, 0xC78BFBC1, 0xC78CFBC1, 0xC78DFBC1, 0xC78EFBC1, 0xC78FFBC1, 0xC790FBC1, 0xC791FBC1, 0xC792FBC1, 0xC793FBC1, 0xC794FBC1, 0xC795FBC1, 0xC796FBC1, 0xC797FBC1, 0xC798FBC1, 0xC799FBC1, 0xC79AFBC1, 0xC79BFBC1, 0xC79CFBC1, 0xC79DFBC1, 0xC79EFBC1, 0xC79FFBC1, 0xC7A0FBC1, 0xC7A1FBC1, 0xC7A2FBC1, 0xC7A3FBC1, 0xC7A4FBC1, 0xC7A5FBC1, 0xC7A6FBC1, 0xC7A7FBC1, 0xC7A8FBC1, 0xC7A9FBC1, 0xC7AAFBC1, 0xC7ABFBC1, 0xC7ACFBC1, 0xC7ADFBC1, 0xC7AEFBC1, 0xC7AFFBC1, 0xC7B0FBC1, 0xC7B1FBC1, 0xC7B2FBC1, 0xC7B3FBC1, 0xC7B4FBC1, 0xC7B5FBC1, 0xC7B6FBC1, 0xC7B7FBC1, 0xC7B8FBC1, 0xC7B9FBC1, 0xC7BAFBC1, 0xC7BBFBC1, 0xC7BCFBC1, 0xC7BDFBC1, 0xC7BEFBC1, 0xC7BFFBC1, 0xC7C0FBC1, 0xC7C1FBC1, 0xC7C2FBC1, 0xC7C3FBC1, 0xC7C4FBC1, 0xC7C5FBC1, 0xC7C6FBC1, 0xC7C7FBC1, 0xC7C8FBC1, 0xC7C9FBC1, 0xC7CAFBC1, 0xC7CBFBC1, 0xC7CCFBC1, 0xC7CDFBC1, 0xC7CEFBC1, 0xC7CFFBC1, 0xC7D0FBC1, 0xC7D1FBC1, 0xC7D2FBC1, 0xC7D3FBC1, 0xC7D4FBC1, 0xC7D5FBC1, 0xC7D6FBC1, 0xC7D7FBC1, 0xC7D8FBC1, 0xC7D9FBC1, 0xC7DAFBC1, 0xC7DBFBC1, 0xC7DCFBC1, 0xC7DDFBC1, 0xC7DEFBC1, 0xC7DFFBC1, 0xC7E0FBC1, 0xC7E1FBC1, 0xC7E2FBC1, 0xC7E3FBC1, 0xC7E4FBC1, 0xC7E5FBC1, 0xC7E6FBC1, 0xC7E7FBC1, 0xC7E8FBC1, 0xC7E9FBC1, 0xC7EAFBC1, 0xC7EBFBC1, /* C742 */
+ 0xC7ECFBC1, 0xC7EDFBC1, 0xC7EEFBC1, 0xC7EFFBC1, 0xC7F0FBC1, 0xC7F1FBC1, 0xC7F2FBC1, 0xC7F3FBC1, 0xC7F4FBC1, 0xC7F5FBC1, 0xC7F6FBC1, 0xC7F7FBC1, 0xC7F8FBC1, 0xC7F9FBC1, 0xC7FAFBC1, 0xC7FBFBC1, 0xC7FCFBC1, 0xC7FDFBC1, 0xC7FEFBC1, 0xC7FFFBC1, 0xC800FBC1, 0xC801FBC1, 0xC802FBC1, 0xC803FBC1, 0xC804FBC1, 0xC805FBC1, 0xC806FBC1, 0xC807FBC1, 0xC808FBC1, 0xC809FBC1, 0xC80AFBC1, 0xC80BFBC1, 0xC80CFBC1, 0xC80DFBC1, 0xC80EFBC1, 0xC80FFBC1, 0xC810FBC1, 0xC811FBC1, 0xC812FBC1, 0xC813FBC1, 0xC814FBC1, 0xC815FBC1, 0xC816FBC1, 0xC817FBC1, 0xC818FBC1, 0xC819FBC1, 0xC81AFBC1, 0xC81BFBC1, 0xC81CFBC1, 0xC81DFBC1, 0xC81EFBC1, 0xC81FFBC1, 0xC820FBC1, 0xC821FBC1, 0xC822FBC1, 0xC823FBC1, 0xC824FBC1, 0xC825FBC1, 0xC826FBC1, 0xC827FBC1, 0xC828FBC1, 0xC829FBC1, 0xC82AFBC1, 0xC82BFBC1, 0xC82CFBC1, 0xC82DFBC1, 0xC82EFBC1, 0xC82FFBC1, 0xC830FBC1, 0xC831FBC1, 0xC832FBC1, 0xC833FBC1, 0xC834FBC1, 0xC835FBC1, 0xC836FBC1, 0xC837FBC1, 0xC838FBC1, 0xC839FBC1, 0xC83AFBC1, 0xC83BFBC1, 0xC83CFBC1, 0xC83DFBC1, 0xC83EFBC1, 0xC83FFBC1, 0xC840FBC1, 0xC841FBC1, 0xC842FBC1, 0xC843FBC1, 0xC844FBC1, 0xC845FBC1, 0xC846FBC1, 0xC847FBC1, 0xC848FBC1, 0xC849FBC1, 0xC84AFBC1, 0xC84BFBC1, 0xC84CFBC1, 0xC84DFBC1, 0xC84EFBC1, 0xC84FFBC1, 0xC850FBC1, 0xC851FBC1, 0xC852FBC1, 0xC853FBC1, 0xC854FBC1, 0xC855FBC1, 0xC856FBC1, 0xC857FBC1, 0xC858FBC1, 0xC859FBC1, 0xC85AFBC1, 0xC85BFBC1, 0xC85CFBC1, 0xC85DFBC1, 0xC85EFBC1, 0xC85FFBC1, 0xC860FBC1, 0xC861FBC1, 0xC862FBC1, 0xC863FBC1, 0xC864FBC1, 0xC865FBC1, 0xC866FBC1, 0xC867FBC1, 0xC868FBC1, 0xC869FBC1, 0xC86AFBC1, 0xC86BFBC1, 0xC86CFBC1, 0xC86DFBC1, 0xC86EFBC1, 0xC86FFBC1, 0xC870FBC1, 0xC871FBC1, 0xC872FBC1, 0xC873FBC1, 0xC874FBC1, 0xC875FBC1, 0xC876FBC1, 0xC877FBC1, 0xC878FBC1, 0xC879FBC1, 0xC87AFBC1, 0xC87BFBC1, 0xC87CFBC1, 0xC87DFBC1, 0xC87EFBC1, 0xC87FFBC1, 0xC880FBC1, 0xC881FBC1, 0xC882FBC1, 0xC883FBC1, 0xC884FBC1, 0xC885FBC1, 0xC886FBC1, 0xC887FBC1, 0xC888FBC1, 0xC889FBC1, 0xC88AFBC1, 0xC88BFBC1, 0xC88CFBC1, 0xC88DFBC1, 0xC88EFBC1, 0xC88FFBC1, 0xC890FBC1, 0xC891FBC1, 0xC892FBC1, 0xC893FBC1, 0xC894FBC1, 0xC895FBC1, /* C7EC */
+ 0xC896FBC1, 0xC897FBC1, 0xC898FBC1, 0xC899FBC1, 0xC89AFBC1, 0xC89BFBC1, 0xC89CFBC1, 0xC89DFBC1, 0xC89EFBC1, 0xC89FFBC1, 0xC8A0FBC1, 0xC8A1FBC1, 0xC8A2FBC1, 0xC8A3FBC1, 0xC8A4FBC1, 0xC8A5FBC1, 0xC8A6FBC1, 0xC8A7FBC1, 0xC8A8FBC1, 0xC8A9FBC1, 0xC8AAFBC1, 0xC8ABFBC1, 0xC8ACFBC1, 0xC8ADFBC1, 0xC8AEFBC1, 0xC8AFFBC1, 0xC8B0FBC1, 0xC8B1FBC1, 0xC8B2FBC1, 0xC8B3FBC1, 0xC8B4FBC1, 0xC8B5FBC1, 0xC8B6FBC1, 0xC8B7FBC1, 0xC8B8FBC1, 0xC8B9FBC1, 0xC8BAFBC1, 0xC8BBFBC1, 0xC8BCFBC1, 0xC8BDFBC1, 0xC8BEFBC1, 0xC8BFFBC1, 0xC8C0FBC1, 0xC8C1FBC1, 0xC8C2FBC1, 0xC8C3FBC1, 0xC8C4FBC1, 0xC8C5FBC1, 0xC8C6FBC1, 0xC8C7FBC1, 0xC8C8FBC1, 0xC8C9FBC1, 0xC8CAFBC1, 0xC8CBFBC1, 0xC8CCFBC1, 0xC8CDFBC1, 0xC8CEFBC1, 0xC8CFFBC1, 0xC8D0FBC1, 0xC8D1FBC1, 0xC8D2FBC1, 0xC8D3FBC1, 0xC8D4FBC1, 0xC8D5FBC1, 0xC8D6FBC1, 0xC8D7FBC1, 0xC8D8FBC1, 0xC8D9FBC1, 0xC8DAFBC1, 0xC8DBFBC1, 0xC8DCFBC1, 0xC8DDFBC1, 0xC8DEFBC1, 0xC8DFFBC1, 0xC8E0FBC1, 0xC8E1FBC1, 0xC8E2FBC1, 0xC8E3FBC1, 0xC8E4FBC1, 0xC8E5FBC1, 0xC8E6FBC1, 0xC8E7FBC1, 0xC8E8FBC1, 0xC8E9FBC1, 0xC8EAFBC1, 0xC8EBFBC1, 0xC8ECFBC1, 0xC8EDFBC1, 0xC8EEFBC1, 0xC8EFFBC1, 0xC8F0FBC1, 0xC8F1FBC1, 0xC8F2FBC1, 0xC8F3FBC1, 0xC8F4FBC1, 0xC8F5FBC1, 0xC8F6FBC1, 0xC8F7FBC1, 0xC8F8FBC1, 0xC8F9FBC1, 0xC8FAFBC1, 0xC8FBFBC1, 0xC8FCFBC1, 0xC8FDFBC1, 0xC8FEFBC1, 0xC8FFFBC1, 0xC900FBC1, 0xC901FBC1, 0xC902FBC1, 0xC903FBC1, 0xC904FBC1, 0xC905FBC1, 0xC906FBC1, 0xC907FBC1, 0xC908FBC1, 0xC909FBC1, 0xC90AFBC1, 0xC90BFBC1, 0xC90CFBC1, 0xC90DFBC1, 0xC90EFBC1, 0xC90FFBC1, 0xC910FBC1, 0xC911FBC1, 0xC912FBC1, 0xC913FBC1, 0xC914FBC1, 0xC915FBC1, 0xC916FBC1, 0xC917FBC1, 0xC918FBC1, 0xC919FBC1, 0xC91AFBC1, 0xC91BFBC1, 0xC91CFBC1, 0xC91DFBC1, 0xC91EFBC1, 0xC91FFBC1, 0xC920FBC1, 0xC921FBC1, 0xC922FBC1, 0xC923FBC1, 0xC924FBC1, 0xC925FBC1, 0xC926FBC1, 0xC927FBC1, 0xC928FBC1, 0xC929FBC1, 0xC92AFBC1, 0xC92BFBC1, 0xC92CFBC1, 0xC92DFBC1, 0xC92EFBC1, 0xC92FFBC1, 0xC930FBC1, 0xC931FBC1, 0xC932FBC1, 0xC933FBC1, 0xC934FBC1, 0xC935FBC1, 0xC936FBC1, 0xC937FBC1, 0xC938FBC1, 0xC939FBC1, 0xC93AFBC1, 0xC93BFBC1, 0xC93CFBC1, 0xC93DFBC1, 0xC93EFBC1, 0xC93FFBC1, /* C896 */
+ 0xC940FBC1, 0xC941FBC1, 0xC942FBC1, 0xC943FBC1, 0xC944FBC1, 0xC945FBC1, 0xC946FBC1, 0xC947FBC1, 0xC948FBC1, 0xC949FBC1, 0xC94AFBC1, 0xC94BFBC1, 0xC94CFBC1, 0xC94DFBC1, 0xC94EFBC1, 0xC94FFBC1, 0xC950FBC1, 0xC951FBC1, 0xC952FBC1, 0xC953FBC1, 0xC954FBC1, 0xC955FBC1, 0xC956FBC1, 0xC957FBC1, 0xC958FBC1, 0xC959FBC1, 0xC95AFBC1, 0xC95BFBC1, 0xC95CFBC1, 0xC95DFBC1, 0xC95EFBC1, 0xC95FFBC1, 0xC960FBC1, 0xC961FBC1, 0xC962FBC1, 0xC963FBC1, 0xC964FBC1, 0xC965FBC1, 0xC966FBC1, 0xC967FBC1, 0xC968FBC1, 0xC969FBC1, 0xC96AFBC1, 0xC96BFBC1, 0xC96CFBC1, 0xC96DFBC1, 0xC96EFBC1, 0xC96FFBC1, 0xC970FBC1, 0xC971FBC1, 0xC972FBC1, 0xC973FBC1, 0xC974FBC1, 0xC975FBC1, 0xC976FBC1, 0xC977FBC1, 0xC978FBC1, 0xC979FBC1, 0xC97AFBC1, 0xC97BFBC1, 0xC97CFBC1, 0xC97DFBC1, 0xC97EFBC1, 0xC97FFBC1, 0xC980FBC1, 0xC981FBC1, 0xC982FBC1, 0xC983FBC1, 0xC984FBC1, 0xC985FBC1, 0xC986FBC1, 0xC987FBC1, 0xC988FBC1, 0xC989FBC1, 0xC98AFBC1, 0xC98BFBC1, 0xC98CFBC1, 0xC98DFBC1, 0xC98EFBC1, 0xC98FFBC1, 0xC990FBC1, 0xC991FBC1, 0xC992FBC1, 0xC993FBC1, 0xC994FBC1, 0xC995FBC1, 0xC996FBC1, 0xC997FBC1, 0xC998FBC1, 0xC999FBC1, 0xC99AFBC1, 0xC99BFBC1, 0xC99CFBC1, 0xC99DFBC1, 0xC99EFBC1, 0xC99FFBC1, 0xC9A0FBC1, 0xC9A1FBC1, 0xC9A2FBC1, 0xC9A3FBC1, 0xC9A4FBC1, 0xC9A5FBC1, 0xC9A6FBC1, 0xC9A7FBC1, 0xC9A8FBC1, 0xC9A9FBC1, 0xC9AAFBC1, 0xC9ABFBC1, 0xC9ACFBC1, 0xC9ADFBC1, 0xC9AEFBC1, 0xC9AFFBC1, 0xC9B0FBC1, 0xC9B1FBC1, 0xC9B2FBC1, 0xC9B3FBC1, 0xC9B4FBC1, 0xC9B5FBC1, 0xC9B6FBC1, 0xC9B7FBC1, 0xC9B8FBC1, 0xC9B9FBC1, 0xC9BAFBC1, 0xC9BBFBC1, 0xC9BCFBC1, 0xC9BDFBC1, 0xC9BEFBC1, 0xC9BFFBC1, 0xC9C0FBC1, 0xC9C1FBC1, 0xC9C2FBC1, 0xC9C3FBC1, 0xC9C4FBC1, 0xC9C5FBC1, 0xC9C6FBC1, 0xC9C7FBC1, 0xC9C8FBC1, 0xC9C9FBC1, 0xC9CAFBC1, 0xC9CBFBC1, 0xC9CCFBC1, 0xC9CDFBC1, 0xC9CEFBC1, 0xC9CFFBC1, 0xC9D0FBC1, 0xC9D1FBC1, 0xC9D2FBC1, 0xC9D3FBC1, 0xC9D4FBC1, 0xC9D5FBC1, 0xC9D6FBC1, 0xC9D7FBC1, 0xC9D8FBC1, 0xC9D9FBC1, 0xC9DAFBC1, 0xC9DBFBC1, 0xC9DCFBC1, 0xC9DDFBC1, 0xC9DEFBC1, 0xC9DFFBC1, 0xC9E0FBC1, 0xC9E1FBC1, 0xC9E2FBC1, 0xC9E3FBC1, 0xC9E4FBC1, 0xC9E5FBC1, 0xC9E6FBC1, 0xC9E7FBC1, 0xC9E8FBC1, 0xC9E9FBC1, /* C940 */
+ 0xC9EAFBC1, 0xC9EBFBC1, 0xC9ECFBC1, 0xC9EDFBC1, 0xC9EEFBC1, 0xC9EFFBC1, 0xC9F0FBC1, 0xC9F1FBC1, 0xC9F2FBC1, 0xC9F3FBC1, 0xC9F4FBC1, 0xC9F5FBC1, 0xC9F6FBC1, 0xC9F7FBC1, 0xC9F8FBC1, 0xC9F9FBC1, 0xC9FAFBC1, 0xC9FBFBC1, 0xC9FCFBC1, 0xC9FDFBC1, 0xC9FEFBC1, 0xC9FFFBC1, 0xCA00FBC1, 0xCA01FBC1, 0xCA02FBC1, 0xCA03FBC1, 0xCA04FBC1, 0xCA05FBC1, 0xCA06FBC1, 0xCA07FBC1, 0xCA08FBC1, 0xCA09FBC1, 0xCA0AFBC1, 0xCA0BFBC1, 0xCA0CFBC1, 0xCA0DFBC1, 0xCA0EFBC1, 0xCA0FFBC1, 0xCA10FBC1, 0xCA11FBC1, 0xCA12FBC1, 0xCA13FBC1, 0xCA14FBC1, 0xCA15FBC1, 0xCA16FBC1, 0xCA17FBC1, 0xCA18FBC1, 0xCA19FBC1, 0xCA1AFBC1, 0xCA1BFBC1, 0xCA1CFBC1, 0xCA1DFBC1, 0xCA1EFBC1, 0xCA1FFBC1, 0xCA20FBC1, 0xCA21FBC1, 0xCA22FBC1, 0xCA23FBC1, 0xCA24FBC1, 0xCA25FBC1, 0xCA26FBC1, 0xCA27FBC1, 0xCA28FBC1, 0xCA29FBC1, 0xCA2AFBC1, 0xCA2BFBC1, 0xCA2CFBC1, 0xCA2DFBC1, 0xCA2EFBC1, 0xCA2FFBC1, 0xCA30FBC1, 0xCA31FBC1, 0xCA32FBC1, 0xCA33FBC1, 0xCA34FBC1, 0xCA35FBC1, 0xCA36FBC1, 0xCA37FBC1, 0xCA38FBC1, 0xCA39FBC1, 0xCA3AFBC1, 0xCA3BFBC1, 0xCA3CFBC1, 0xCA3DFBC1, 0xCA3EFBC1, 0xCA3FFBC1, 0xCA40FBC1, 0xCA41FBC1, 0xCA42FBC1, 0xCA43FBC1, 0xCA44FBC1, 0xCA45FBC1, 0xCA46FBC1, 0xCA47FBC1, 0xCA48FBC1, 0xCA49FBC1, 0xCA4AFBC1, 0xCA4BFBC1, 0xCA4CFBC1, 0xCA4DFBC1, 0xCA4EFBC1, 0xCA4FFBC1, 0xCA50FBC1, 0xCA51FBC1, 0xCA52FBC1, 0xCA53FBC1, 0xCA54FBC1, 0xCA55FBC1, 0xCA56FBC1, 0xCA57FBC1, 0xCA58FBC1, 0xCA59FBC1, 0xCA5AFBC1, 0xCA5BFBC1, 0xCA5CFBC1, 0xCA5DFBC1, 0xCA5EFBC1, 0xCA5FFBC1, 0xCA60FBC1, 0xCA61FBC1, 0xCA62FBC1, 0xCA63FBC1, 0xCA64FBC1, 0xCA65FBC1, 0xCA66FBC1, 0xCA67FBC1, 0xCA68FBC1, 0xCA69FBC1, 0xCA6AFBC1, 0xCA6BFBC1, 0xCA6CFBC1, 0xCA6DFBC1, 0xCA6EFBC1, 0xCA6FFBC1, 0xCA70FBC1, 0xCA71FBC1, 0xCA72FBC1, 0xCA73FBC1, 0xCA74FBC1, 0xCA75FBC1, 0xCA76FBC1, 0xCA77FBC1, 0xCA78FBC1, 0xCA79FBC1, 0xCA7AFBC1, 0xCA7BFBC1, 0xCA7CFBC1, 0xCA7DFBC1, 0xCA7EFBC1, 0xCA7FFBC1, 0xCA80FBC1, 0xCA81FBC1, 0xCA82FBC1, 0xCA83FBC1, 0xCA84FBC1, 0xCA85FBC1, 0xCA86FBC1, 0xCA87FBC1, 0xCA88FBC1, 0xCA89FBC1, 0xCA8AFBC1, 0xCA8BFBC1, 0xCA8CFBC1, 0xCA8DFBC1, 0xCA8EFBC1, 0xCA8FFBC1, 0xCA90FBC1, 0xCA91FBC1, 0xCA92FBC1, 0xCA93FBC1, /* C9EA */
+ 0xCA94FBC1, 0xCA95FBC1, 0xCA96FBC1, 0xCA97FBC1, 0xCA98FBC1, 0xCA99FBC1, 0xCA9AFBC1, 0xCA9BFBC1, 0xCA9CFBC1, 0xCA9DFBC1, 0xCA9EFBC1, 0xCA9FFBC1, 0xCAA0FBC1, 0xCAA1FBC1, 0xCAA2FBC1, 0xCAA3FBC1, 0xCAA4FBC1, 0xCAA5FBC1, 0xCAA6FBC1, 0xCAA7FBC1, 0xCAA8FBC1, 0xCAA9FBC1, 0xCAAAFBC1, 0xCAABFBC1, 0xCAACFBC1, 0xCAADFBC1, 0xCAAEFBC1, 0xCAAFFBC1, 0xCAB0FBC1, 0xCAB1FBC1, 0xCAB2FBC1, 0xCAB3FBC1, 0xCAB4FBC1, 0xCAB5FBC1, 0xCAB6FBC1, 0xCAB7FBC1, 0xCAB8FBC1, 0xCAB9FBC1, 0xCABAFBC1, 0xCABBFBC1, 0xCABCFBC1, 0xCABDFBC1, 0xCABEFBC1, 0xCABFFBC1, 0xCAC0FBC1, 0xCAC1FBC1, 0xCAC2FBC1, 0xCAC3FBC1, 0xCAC4FBC1, 0xCAC5FBC1, 0xCAC6FBC1, 0xCAC7FBC1, 0xCAC8FBC1, 0xCAC9FBC1, 0xCACAFBC1, 0xCACBFBC1, 0xCACCFBC1, 0xCACDFBC1, 0xCACEFBC1, 0xCACFFBC1, 0xCAD0FBC1, 0xCAD1FBC1, 0xCAD2FBC1, 0xCAD3FBC1, 0xCAD4FBC1, 0xCAD5FBC1, 0xCAD6FBC1, 0xCAD7FBC1, 0xCAD8FBC1, 0xCAD9FBC1, 0xCADAFBC1, 0xCADBFBC1, 0xCADCFBC1, 0xCADDFBC1, 0xCADEFBC1, 0xCADFFBC1, 0xCAE0FBC1, 0xCAE1FBC1, 0xCAE2FBC1, 0xCAE3FBC1, 0xCAE4FBC1, 0xCAE5FBC1, 0xCAE6FBC1, 0xCAE7FBC1, 0xCAE8FBC1, 0xCAE9FBC1, 0xCAEAFBC1, 0xCAEBFBC1, 0xCAECFBC1, 0xCAEDFBC1, 0xCAEEFBC1, 0xCAEFFBC1, 0xCAF0FBC1, 0xCAF1FBC1, 0xCAF2FBC1, 0xCAF3FBC1, 0xCAF4FBC1, 0xCAF5FBC1, 0xCAF6FBC1, 0xCAF7FBC1, 0xCAF8FBC1, 0xCAF9FBC1, 0xCAFAFBC1, 0xCAFBFBC1, 0xCAFCFBC1, 0xCAFDFBC1, 0xCAFEFBC1, 0xCAFFFBC1, 0xCB00FBC1, 0xCB01FBC1, 0xCB02FBC1, 0xCB03FBC1, 0xCB04FBC1, 0xCB05FBC1, 0xCB06FBC1, 0xCB07FBC1, 0xCB08FBC1, 0xCB09FBC1, 0xCB0AFBC1, 0xCB0BFBC1, 0xCB0CFBC1, 0xCB0DFBC1, 0xCB0EFBC1, 0xCB0FFBC1, 0xCB10FBC1, 0xCB11FBC1, 0xCB12FBC1, 0xCB13FBC1, 0xCB14FBC1, 0xCB15FBC1, 0xCB16FBC1, 0xCB17FBC1, 0xCB18FBC1, 0xCB19FBC1, 0xCB1AFBC1, 0xCB1BFBC1, 0xCB1CFBC1, 0xCB1DFBC1, 0xCB1EFBC1, 0xCB1FFBC1, 0xCB20FBC1, 0xCB21FBC1, 0xCB22FBC1, 0xCB23FBC1, 0xCB24FBC1, 0xCB25FBC1, 0xCB26FBC1, 0xCB27FBC1, 0xCB28FBC1, 0xCB29FBC1, 0xCB2AFBC1, 0xCB2BFBC1, 0xCB2CFBC1, 0xCB2DFBC1, 0xCB2EFBC1, 0xCB2FFBC1, 0xCB30FBC1, 0xCB31FBC1, 0xCB32FBC1, 0xCB33FBC1, 0xCB34FBC1, 0xCB35FBC1, 0xCB36FBC1, 0xCB37FBC1, 0xCB38FBC1, 0xCB39FBC1, 0xCB3AFBC1, 0xCB3BFBC1, 0xCB3CFBC1, 0xCB3DFBC1, /* CA94 */
+ 0xCB3EFBC1, 0xCB3FFBC1, 0xCB40FBC1, 0xCB41FBC1, 0xCB42FBC1, 0xCB43FBC1, 0xCB44FBC1, 0xCB45FBC1, 0xCB46FBC1, 0xCB47FBC1, 0xCB48FBC1, 0xCB49FBC1, 0xCB4AFBC1, 0xCB4BFBC1, 0xCB4CFBC1, 0xCB4DFBC1, 0xCB4EFBC1, 0xCB4FFBC1, 0xCB50FBC1, 0xCB51FBC1, 0xCB52FBC1, 0xCB53FBC1, 0xCB54FBC1, 0xCB55FBC1, 0xCB56FBC1, 0xCB57FBC1, 0xCB58FBC1, 0xCB59FBC1, 0xCB5AFBC1, 0xCB5BFBC1, 0xCB5CFBC1, 0xCB5DFBC1, 0xCB5EFBC1, 0xCB5FFBC1, 0xCB60FBC1, 0xCB61FBC1, 0xCB62FBC1, 0xCB63FBC1, 0xCB64FBC1, 0xCB65FBC1, 0xCB66FBC1, 0xCB67FBC1, 0xCB68FBC1, 0xCB69FBC1, 0xCB6AFBC1, 0xCB6BFBC1, 0xCB6CFBC1, 0xCB6DFBC1, 0xCB6EFBC1, 0xCB6FFBC1, 0xCB70FBC1, 0xCB71FBC1, 0xCB72FBC1, 0xCB73FBC1, 0xCB74FBC1, 0xCB75FBC1, 0xCB76FBC1, 0xCB77FBC1, 0xCB78FBC1, 0xCB79FBC1, 0xCB7AFBC1, 0xCB7BFBC1, 0xCB7CFBC1, 0xCB7DFBC1, 0xCB7EFBC1, 0xCB7FFBC1, 0xCB80FBC1, 0xCB81FBC1, 0xCB82FBC1, 0xCB83FBC1, 0xCB84FBC1, 0xCB85FBC1, 0xCB86FBC1, 0xCB87FBC1, 0xCB88FBC1, 0xCB89FBC1, 0xCB8AFBC1, 0xCB8BFBC1, 0xCB8CFBC1, 0xCB8DFBC1, 0xCB8EFBC1, 0xCB8FFBC1, 0xCB90FBC1, 0xCB91FBC1, 0xCB92FBC1, 0xCB93FBC1, 0xCB94FBC1, 0xCB95FBC1, 0xCB96FBC1, 0xCB97FBC1, 0xCB98FBC1, 0xCB99FBC1, 0xCB9AFBC1, 0xCB9BFBC1, 0xCB9CFBC1, 0xCB9DFBC1, 0xCB9EFBC1, 0xCB9FFBC1, 0xCBA0FBC1, 0xCBA1FBC1, 0xCBA2FBC1, 0xCBA3FBC1, 0xCBA4FBC1, 0xCBA5FBC1, 0xCBA6FBC1, 0xCBA7FBC1, 0xCBA8FBC1, 0xCBA9FBC1, 0xCBAAFBC1, 0xCBABFBC1, 0xCBACFBC1, 0xCBADFBC1, 0xCBAEFBC1, 0xCBAFFBC1, 0xCBB0FBC1, 0xCBB1FBC1, 0xCBB2FBC1, 0xCBB3FBC1, 0xCBB4FBC1, 0xCBB5FBC1, 0xCBB6FBC1, 0xCBB7FBC1, 0xCBB8FBC1, 0xCBB9FBC1, 0xCBBAFBC1, 0xCBBBFBC1, 0xCBBCFBC1, 0xCBBDFBC1, 0xCBBEFBC1, 0xCBBFFBC1, 0xCBC0FBC1, 0xCBC1FBC1, 0xCBC2FBC1, 0xCBC3FBC1, 0xCBC4FBC1, 0xCBC5FBC1, 0xCBC6FBC1, 0xCBC7FBC1, 0xCBC8FBC1, 0xCBC9FBC1, 0xCBCAFBC1, 0xCBCBFBC1, 0xCBCCFBC1, 0xCBCDFBC1, 0xCBCEFBC1, 0xCBCFFBC1, 0xCBD0FBC1, 0xCBD1FBC1, 0xCBD2FBC1, 0xCBD3FBC1, 0xCBD4FBC1, 0xCBD5FBC1, 0xCBD6FBC1, 0xCBD7FBC1, 0xCBD8FBC1, 0xCBD9FBC1, 0xCBDAFBC1, 0xCBDBFBC1, 0xCBDCFBC1, 0xCBDDFBC1, 0xCBDEFBC1, 0xCBDFFBC1, 0xCBE0FBC1, 0xCBE1FBC1, 0xCBE2FBC1, 0xCBE3FBC1, 0xCBE4FBC1, 0xCBE5FBC1, 0xCBE6FBC1, 0xCBE7FBC1, /* CB3E */
+ 0xCBE8FBC1, 0xCBE9FBC1, 0xCBEAFBC1, 0xCBEBFBC1, 0xCBECFBC1, 0xCBEDFBC1, 0xCBEEFBC1, 0xCBEFFBC1, 0xCBF0FBC1, 0xCBF1FBC1, 0xCBF2FBC1, 0xCBF3FBC1, 0xCBF4FBC1, 0xCBF5FBC1, 0xCBF6FBC1, 0xCBF7FBC1, 0xCBF8FBC1, 0xCBF9FBC1, 0xCBFAFBC1, 0xCBFBFBC1, 0xCBFCFBC1, 0xCBFDFBC1, 0xCBFEFBC1, 0xCBFFFBC1, 0xCC00FBC1, 0xCC01FBC1, 0xCC02FBC1, 0xCC03FBC1, 0xCC04FBC1, 0xCC05FBC1, 0xCC06FBC1, 0xCC07FBC1, 0xCC08FBC1, 0xCC09FBC1, 0xCC0AFBC1, 0xCC0BFBC1, 0xCC0CFBC1, 0xCC0DFBC1, 0xCC0EFBC1, 0xCC0FFBC1, 0xCC10FBC1, 0xCC11FBC1, 0xCC12FBC1, 0xCC13FBC1, 0xCC14FBC1, 0xCC15FBC1, 0xCC16FBC1, 0xCC17FBC1, 0xCC18FBC1, 0xCC19FBC1, 0xCC1AFBC1, 0xCC1BFBC1, 0xCC1CFBC1, 0xCC1DFBC1, 0xCC1EFBC1, 0xCC1FFBC1, 0xCC20FBC1, 0xCC21FBC1, 0xCC22FBC1, 0xCC23FBC1, 0xCC24FBC1, 0xCC25FBC1, 0xCC26FBC1, 0xCC27FBC1, 0xCC28FBC1, 0xCC29FBC1, 0xCC2AFBC1, 0xCC2BFBC1, 0xCC2CFBC1, 0xCC2DFBC1, 0xCC2EFBC1, 0xCC2FFBC1, 0xCC30FBC1, 0xCC31FBC1, 0xCC32FBC1, 0xCC33FBC1, 0xCC34FBC1, 0xCC35FBC1, 0xCC36FBC1, 0xCC37FBC1, 0xCC38FBC1, 0xCC39FBC1, 0xCC3AFBC1, 0xCC3BFBC1, 0xCC3CFBC1, 0xCC3DFBC1, 0xCC3EFBC1, 0xCC3FFBC1, 0xCC40FBC1, 0xCC41FBC1, 0xCC42FBC1, 0xCC43FBC1, 0xCC44FBC1, 0xCC45FBC1, 0xCC46FBC1, 0xCC47FBC1, 0xCC48FBC1, 0xCC49FBC1, 0xCC4AFBC1, 0xCC4BFBC1, 0xCC4CFBC1, 0xCC4DFBC1, 0xCC4EFBC1, 0xCC4FFBC1, 0xCC50FBC1, 0xCC51FBC1, 0xCC52FBC1, 0xCC53FBC1, 0xCC54FBC1, 0xCC55FBC1, 0xCC56FBC1, 0xCC57FBC1, 0xCC58FBC1, 0xCC59FBC1, 0xCC5AFBC1, 0xCC5BFBC1, 0xCC5CFBC1, 0xCC5DFBC1, 0xCC5EFBC1, 0xCC5FFBC1, 0xCC60FBC1, 0xCC61FBC1, 0xCC62FBC1, 0xCC63FBC1, 0xCC64FBC1, 0xCC65FBC1, 0xCC66FBC1, 0xCC67FBC1, 0xCC68FBC1, 0xCC69FBC1, 0xCC6AFBC1, 0xCC6BFBC1, 0xCC6CFBC1, 0xCC6DFBC1, 0xCC6EFBC1, 0xCC6FFBC1, 0xCC70FBC1, 0xCC71FBC1, 0xCC72FBC1, 0xCC73FBC1, 0xCC74FBC1, 0xCC75FBC1, 0xCC76FBC1, 0xCC77FBC1, 0xCC78FBC1, 0xCC79FBC1, 0xCC7AFBC1, 0xCC7BFBC1, 0xCC7CFBC1, 0xCC7DFBC1, 0xCC7EFBC1, 0xCC7FFBC1, 0xCC80FBC1, 0xCC81FBC1, 0xCC82FBC1, 0xCC83FBC1, 0xCC84FBC1, 0xCC85FBC1, 0xCC86FBC1, 0xCC87FBC1, 0xCC88FBC1, 0xCC89FBC1, 0xCC8AFBC1, 0xCC8BFBC1, 0xCC8CFBC1, 0xCC8DFBC1, 0xCC8EFBC1, 0xCC8FFBC1, 0xCC90FBC1, 0xCC91FBC1, /* CBE8 */
+ 0xCC92FBC1, 0xCC93FBC1, 0xCC94FBC1, 0xCC95FBC1, 0xCC96FBC1, 0xCC97FBC1, 0xCC98FBC1, 0xCC99FBC1, 0xCC9AFBC1, 0xCC9BFBC1, 0xCC9CFBC1, 0xCC9DFBC1, 0xCC9EFBC1, 0xCC9FFBC1, 0xCCA0FBC1, 0xCCA1FBC1, 0xCCA2FBC1, 0xCCA3FBC1, 0xCCA4FBC1, 0xCCA5FBC1, 0xCCA6FBC1, 0xCCA7FBC1, 0xCCA8FBC1, 0xCCA9FBC1, 0xCCAAFBC1, 0xCCABFBC1, 0xCCACFBC1, 0xCCADFBC1, 0xCCAEFBC1, 0xCCAFFBC1, 0xCCB0FBC1, 0xCCB1FBC1, 0xCCB2FBC1, 0xCCB3FBC1, 0xCCB4FBC1, 0xCCB5FBC1, 0xCCB6FBC1, 0xCCB7FBC1, 0xCCB8FBC1, 0xCCB9FBC1, 0xCCBAFBC1, 0xCCBBFBC1, 0xCCBCFBC1, 0xCCBDFBC1, 0xCCBEFBC1, 0xCCBFFBC1, 0xCCC0FBC1, 0xCCC1FBC1, 0xCCC2FBC1, 0xCCC3FBC1, 0xCCC4FBC1, 0xCCC5FBC1, 0xCCC6FBC1, 0xCCC7FBC1, 0xCCC8FBC1, 0xCCC9FBC1, 0xCCCAFBC1, 0xCCCBFBC1, 0xCCCCFBC1, 0xCCCDFBC1, 0xCCCEFBC1, 0xCCCFFBC1, 0xCCD0FBC1, 0xCCD1FBC1, 0xCCD2FBC1, 0xCCD3FBC1, 0xCCD4FBC1, 0xCCD5FBC1, 0xCCD6FBC1, 0xCCD7FBC1, 0xCCD8FBC1, 0xCCD9FBC1, 0xCCDAFBC1, 0xCCDBFBC1, 0xCCDCFBC1, 0xCCDDFBC1, 0xCCDEFBC1, 0xCCDFFBC1, 0xCCE0FBC1, 0xCCE1FBC1, 0xCCE2FBC1, 0xCCE3FBC1, 0xCCE4FBC1, 0xCCE5FBC1, 0xCCE6FBC1, 0xCCE7FBC1, 0xCCE8FBC1, 0xCCE9FBC1, 0xCCEAFBC1, 0xCCEBFBC1, 0xCCECFBC1, 0xCCEDFBC1, 0xCCEEFBC1, 0xCCEFFBC1, 0xCCF0FBC1, 0xCCF1FBC1, 0xCCF2FBC1, 0xCCF3FBC1, 0xCCF4FBC1, 0xCCF5FBC1, 0xCCF6FBC1, 0xCCF7FBC1, 0xCCF8FBC1, 0xCCF9FBC1, 0xCCFAFBC1, 0xCCFBFBC1, 0xCCFCFBC1, 0xCCFDFBC1, 0xCCFEFBC1, 0xCCFFFBC1, 0xCD00FBC1, 0xCD01FBC1, 0xCD02FBC1, 0xCD03FBC1, 0xCD04FBC1, 0xCD05FBC1, 0xCD06FBC1, 0xCD07FBC1, 0xCD08FBC1, 0xCD09FBC1, 0xCD0AFBC1, 0xCD0BFBC1, 0xCD0CFBC1, 0xCD0DFBC1, 0xCD0EFBC1, 0xCD0FFBC1, 0xCD10FBC1, 0xCD11FBC1, 0xCD12FBC1, 0xCD13FBC1, 0xCD14FBC1, 0xCD15FBC1, 0xCD16FBC1, 0xCD17FBC1, 0xCD18FBC1, 0xCD19FBC1, 0xCD1AFBC1, 0xCD1BFBC1, 0xCD1CFBC1, 0xCD1DFBC1, 0xCD1EFBC1, 0xCD1FFBC1, 0xCD20FBC1, 0xCD21FBC1, 0xCD22FBC1, 0xCD23FBC1, 0xCD24FBC1, 0xCD25FBC1, 0xCD26FBC1, 0xCD27FBC1, 0xCD28FBC1, 0xCD29FBC1, 0xCD2AFBC1, 0xCD2BFBC1, 0xCD2CFBC1, 0xCD2DFBC1, 0xCD2EFBC1, 0xCD2FFBC1, 0xCD30FBC1, 0xCD31FBC1, 0xCD32FBC1, 0xCD33FBC1, 0xCD34FBC1, 0xCD35FBC1, 0xCD36FBC1, 0xCD37FBC1, 0xCD38FBC1, 0xCD39FBC1, 0xCD3AFBC1, 0xCD3BFBC1, /* CC92 */
+ 0xCD3CFBC1, 0xCD3DFBC1, 0xCD3EFBC1, 0xCD3FFBC1, 0xCD40FBC1, 0xCD41FBC1, 0xCD42FBC1, 0xCD43FBC1, 0xCD44FBC1, 0xCD45FBC1, 0xCD46FBC1, 0xCD47FBC1, 0xCD48FBC1, 0xCD49FBC1, 0xCD4AFBC1, 0xCD4BFBC1, 0xCD4CFBC1, 0xCD4DFBC1, 0xCD4EFBC1, 0xCD4FFBC1, 0xCD50FBC1, 0xCD51FBC1, 0xCD52FBC1, 0xCD53FBC1, 0xCD54FBC1, 0xCD55FBC1, 0xCD56FBC1, 0xCD57FBC1, 0xCD58FBC1, 0xCD59FBC1, 0xCD5AFBC1, 0xCD5BFBC1, 0xCD5CFBC1, 0xCD5DFBC1, 0xCD5EFBC1, 0xCD5FFBC1, 0xCD60FBC1, 0xCD61FBC1, 0xCD62FBC1, 0xCD63FBC1, 0xCD64FBC1, 0xCD65FBC1, 0xCD66FBC1, 0xCD67FBC1, 0xCD68FBC1, 0xCD69FBC1, 0xCD6AFBC1, 0xCD6BFBC1, 0xCD6CFBC1, 0xCD6DFBC1, 0xCD6EFBC1, 0xCD6FFBC1, 0xCD70FBC1, 0xCD71FBC1, 0xCD72FBC1, 0xCD73FBC1, 0xCD74FBC1, 0xCD75FBC1, 0xCD76FBC1, 0xCD77FBC1, 0xCD78FBC1, 0xCD79FBC1, 0xCD7AFBC1, 0xCD7BFBC1, 0xCD7CFBC1, 0xCD7DFBC1, 0xCD7EFBC1, 0xCD7FFBC1, 0xCD80FBC1, 0xCD81FBC1, 0xCD82FBC1, 0xCD83FBC1, 0xCD84FBC1, 0xCD85FBC1, 0xCD86FBC1, 0xCD87FBC1, 0xCD88FBC1, 0xCD89FBC1, 0xCD8AFBC1, 0xCD8BFBC1, 0xCD8CFBC1, 0xCD8DFBC1, 0xCD8EFBC1, 0xCD8FFBC1, 0xCD90FBC1, 0xCD91FBC1, 0xCD92FBC1, 0xCD93FBC1, 0xCD94FBC1, 0xCD95FBC1, 0xCD96FBC1, 0xCD97FBC1, 0xCD98FBC1, 0xCD99FBC1, 0xCD9AFBC1, 0xCD9BFBC1, 0xCD9CFBC1, 0xCD9DFBC1, 0xCD9EFBC1, 0xCD9FFBC1, 0xCDA0FBC1, 0xCDA1FBC1, 0xCDA2FBC1, 0xCDA3FBC1, 0xCDA4FBC1, 0xCDA5FBC1, 0xCDA6FBC1, 0xCDA7FBC1, 0xCDA8FBC1, 0xCDA9FBC1, 0xCDAAFBC1, 0xCDABFBC1, 0xCDACFBC1, 0xCDADFBC1, 0xCDAEFBC1, 0xCDAFFBC1, 0xCDB0FBC1, 0xCDB1FBC1, 0xCDB2FBC1, 0xCDB3FBC1, 0xCDB4FBC1, 0xCDB5FBC1, 0xCDB6FBC1, 0xCDB7FBC1, 0xCDB8FBC1, 0xCDB9FBC1, 0xCDBAFBC1, 0xCDBBFBC1, 0xCDBCFBC1, 0xCDBDFBC1, 0xCDBEFBC1, 0xCDBFFBC1, 0xCDC0FBC1, 0xCDC1FBC1, 0xCDC2FBC1, 0xCDC3FBC1, 0xCDC4FBC1, 0xCDC5FBC1, 0xCDC6FBC1, 0xCDC7FBC1, 0xCDC8FBC1, 0xCDC9FBC1, 0xCDCAFBC1, 0xCDCBFBC1, 0xCDCCFBC1, 0xCDCDFBC1, 0xCDCEFBC1, 0xCDCFFBC1, 0xCDD0FBC1, 0xCDD1FBC1, 0xCDD2FBC1, 0xCDD3FBC1, 0xCDD4FBC1, 0xCDD5FBC1, 0xCDD6FBC1, 0xCDD7FBC1, 0xCDD8FBC1, 0xCDD9FBC1, 0xCDDAFBC1, 0xCDDBFBC1, 0xCDDCFBC1, 0xCDDDFBC1, 0xCDDEFBC1, 0xCDDFFBC1, 0xCDE0FBC1, 0xCDE1FBC1, 0xCDE2FBC1, 0xCDE3FBC1, 0xCDE4FBC1, 0xCDE5FBC1, /* CD3C */
+ 0xCDE6FBC1, 0xCDE7FBC1, 0xCDE8FBC1, 0xCDE9FBC1, 0xCDEAFBC1, 0xCDEBFBC1, 0xCDECFBC1, 0xCDEDFBC1, 0xCDEEFBC1, 0xCDEFFBC1, 0xCDF0FBC1, 0xCDF1FBC1, 0xCDF2FBC1, 0xCDF3FBC1, 0xCDF4FBC1, 0xCDF5FBC1, 0xCDF6FBC1, 0xCDF7FBC1, 0xCDF8FBC1, 0xCDF9FBC1, 0xCDFAFBC1, 0xCDFBFBC1, 0xCDFCFBC1, 0xCDFDFBC1, 0xCDFEFBC1, 0xCDFFFBC1, 0xCE00FBC1, 0xCE01FBC1, 0xCE02FBC1, 0xCE03FBC1, 0xCE04FBC1, 0xCE05FBC1, 0xCE06FBC1, 0xCE07FBC1, 0xCE08FBC1, 0xCE09FBC1, 0xCE0AFBC1, 0xCE0BFBC1, 0xCE0CFBC1, 0xCE0DFBC1, 0xCE0EFBC1, 0xCE0FFBC1, 0xCE10FBC1, 0xCE11FBC1, 0xCE12FBC1, 0xCE13FBC1, 0xCE14FBC1, 0xCE15FBC1, 0xCE16FBC1, 0xCE17FBC1, 0xCE18FBC1, 0xCE19FBC1, 0xCE1AFBC1, 0xCE1BFBC1, 0xCE1CFBC1, 0xCE1DFBC1, 0xCE1EFBC1, 0xCE1FFBC1, 0xCE20FBC1, 0xCE21FBC1, 0xCE22FBC1, 0xCE23FBC1, 0xCE24FBC1, 0xCE25FBC1, 0xCE26FBC1, 0xCE27FBC1, 0xCE28FBC1, 0xCE29FBC1, 0xCE2AFBC1, 0xCE2BFBC1, 0xCE2CFBC1, 0xCE2DFBC1, 0xCE2EFBC1, 0xCE2FFBC1, 0xCE30FBC1, 0xCE31FBC1, 0xCE32FBC1, 0xCE33FBC1, 0xCE34FBC1, 0xCE35FBC1, 0xCE36FBC1, 0xCE37FBC1, 0xCE38FBC1, 0xCE39FBC1, 0xCE3AFBC1, 0xCE3BFBC1, 0xCE3CFBC1, 0xCE3DFBC1, 0xCE3EFBC1, 0xCE3FFBC1, 0xCE40FBC1, 0xCE41FBC1, 0xCE42FBC1, 0xCE43FBC1, 0xCE44FBC1, 0xCE45FBC1, 0xCE46FBC1, 0xCE47FBC1, 0xCE48FBC1, 0xCE49FBC1, 0xCE4AFBC1, 0xCE4BFBC1, 0xCE4CFBC1, 0xCE4DFBC1, 0xCE4EFBC1, 0xCE4FFBC1, 0xCE50FBC1, 0xCE51FBC1, 0xCE52FBC1, 0xCE53FBC1, 0xCE54FBC1, 0xCE55FBC1, 0xCE56FBC1, 0xCE57FBC1, 0xCE58FBC1, 0xCE59FBC1, 0xCE5AFBC1, 0xCE5BFBC1, 0xCE5CFBC1, 0xCE5DFBC1, 0xCE5EFBC1, 0xCE5FFBC1, 0xCE60FBC1, 0xCE61FBC1, 0xCE62FBC1, 0xCE63FBC1, 0xCE64FBC1, 0xCE65FBC1, 0xCE66FBC1, 0xCE67FBC1, 0xCE68FBC1, 0xCE69FBC1, 0xCE6AFBC1, 0xCE6BFBC1, 0xCE6CFBC1, 0xCE6DFBC1, 0xCE6EFBC1, 0xCE6FFBC1, 0xCE70FBC1, 0xCE71FBC1, 0xCE72FBC1, 0xCE73FBC1, 0xCE74FBC1, 0xCE75FBC1, 0xCE76FBC1, 0xCE77FBC1, 0xCE78FBC1, 0xCE79FBC1, 0xCE7AFBC1, 0xCE7BFBC1, 0xCE7CFBC1, 0xCE7DFBC1, 0xCE7EFBC1, 0xCE7FFBC1, 0xCE80FBC1, 0xCE81FBC1, 0xCE82FBC1, 0xCE83FBC1, 0xCE84FBC1, 0xCE85FBC1, 0xCE86FBC1, 0xCE87FBC1, 0xCE88FBC1, 0xCE89FBC1, 0xCE8AFBC1, 0xCE8BFBC1, 0xCE8CFBC1, 0xCE8DFBC1, 0xCE8EFBC1, 0xCE8FFBC1, /* CDE6 */
+ 0xCE90FBC1, 0xCE91FBC1, 0xCE92FBC1, 0xCE93FBC1, 0xCE94FBC1, 0xCE95FBC1, 0xCE96FBC1, 0xCE97FBC1, 0xCE98FBC1, 0xCE99FBC1, 0xCE9AFBC1, 0xCE9BFBC1, 0xCE9CFBC1, 0xCE9DFBC1, 0xCE9EFBC1, 0xCE9FFBC1, 0xCEA0FBC1, 0xCEA1FBC1, 0xCEA2FBC1, 0xCEA3FBC1, 0xCEA4FBC1, 0xCEA5FBC1, 0xCEA6FBC1, 0xCEA7FBC1, 0xCEA8FBC1, 0xCEA9FBC1, 0xCEAAFBC1, 0xCEABFBC1, 0xCEACFBC1, 0xCEADFBC1, 0xCEAEFBC1, 0xCEAFFBC1, 0xCEB0FBC1, 0xCEB1FBC1, 0xCEB2FBC1, 0xCEB3FBC1, 0xCEB4FBC1, 0xCEB5FBC1, 0xCEB6FBC1, 0xCEB7FBC1, 0xCEB8FBC1, 0xCEB9FBC1, 0xCEBAFBC1, 0xCEBBFBC1, 0xCEBCFBC1, 0xCEBDFBC1, 0xCEBEFBC1, 0xCEBFFBC1, 0xCEC0FBC1, 0xCEC1FBC1, 0xCEC2FBC1, 0xCEC3FBC1, 0xCEC4FBC1, 0xCEC5FBC1, 0xCEC6FBC1, 0xCEC7FBC1, 0xCEC8FBC1, 0xCEC9FBC1, 0xCECAFBC1, 0xCECBFBC1, 0xCECCFBC1, 0xCECDFBC1, 0xCECEFBC1, 0xCECFFBC1, 0xCED0FBC1, 0xCED1FBC1, 0xCED2FBC1, 0xCED3FBC1, 0xCED4FBC1, 0xCED5FBC1, 0xCED6FBC1, 0xCED7FBC1, 0xCED8FBC1, 0xCED9FBC1, 0xCEDAFBC1, 0xCEDBFBC1, 0xCEDCFBC1, 0xCEDDFBC1, 0xCEDEFBC1, 0xCEDFFBC1, 0xCEE0FBC1, 0xCEE1FBC1, 0xCEE2FBC1, 0xCEE3FBC1, 0xCEE4FBC1, 0xCEE5FBC1, 0xCEE6FBC1, 0xCEE7FBC1, 0xCEE8FBC1, 0xCEE9FBC1, 0xCEEAFBC1, 0xCEEBFBC1, 0xCEECFBC1, 0xCEEDFBC1, 0xCEEEFBC1, 0xCEEFFBC1, 0xCEF0FBC1, 0xCEF1FBC1, 0xCEF2FBC1, 0xCEF3FBC1, 0xCEF4FBC1, 0xCEF5FBC1, 0xCEF6FBC1, 0xCEF7FBC1, 0xCEF8FBC1, 0xCEF9FBC1, 0xCEFAFBC1, 0xCEFBFBC1, 0xCEFCFBC1, 0xCEFDFBC1, 0xCEFEFBC1, 0xCEFFFBC1, 0xCF00FBC1, 0xCF01FBC1, 0xCF02FBC1, 0xCF03FBC1, 0xCF04FBC1, 0xCF05FBC1, 0xCF06FBC1, 0xCF07FBC1, 0xCF08FBC1, 0xCF09FBC1, 0xCF0AFBC1, 0xCF0BFBC1, 0xCF0CFBC1, 0xCF0DFBC1, 0xCF0EFBC1, 0xCF0FFBC1, 0xCF10FBC1, 0xCF11FBC1, 0xCF12FBC1, 0xCF13FBC1, 0xCF14FBC1, 0xCF15FBC1, 0xCF16FBC1, 0xCF17FBC1, 0xCF18FBC1, 0xCF19FBC1, 0xCF1AFBC1, 0xCF1BFBC1, 0xCF1CFBC1, 0xCF1DFBC1, 0xCF1EFBC1, 0xCF1FFBC1, 0xCF20FBC1, 0xCF21FBC1, 0xCF22FBC1, 0xCF23FBC1, 0xCF24FBC1, 0xCF25FBC1, 0xCF26FBC1, 0xCF27FBC1, 0xCF28FBC1, 0xCF29FBC1, 0xCF2AFBC1, 0xCF2BFBC1, 0xCF2CFBC1, 0xCF2DFBC1, 0xCF2EFBC1, 0xCF2FFBC1, 0xCF30FBC1, 0xCF31FBC1, 0xCF32FBC1, 0xCF33FBC1, 0xCF34FBC1, 0xCF35FBC1, 0xCF36FBC1, 0xCF37FBC1, 0xCF38FBC1, 0xCF39FBC1, /* CE90 */
+ 0xCF3AFBC1, 0xCF3BFBC1, 0xCF3CFBC1, 0xCF3DFBC1, 0xCF3EFBC1, 0xCF3FFBC1, 0xCF40FBC1, 0xCF41FBC1, 0xCF42FBC1, 0xCF43FBC1, 0xCF44FBC1, 0xCF45FBC1, 0xCF46FBC1, 0xCF47FBC1, 0xCF48FBC1, 0xCF49FBC1, 0xCF4AFBC1, 0xCF4BFBC1, 0xCF4CFBC1, 0xCF4DFBC1, 0xCF4EFBC1, 0xCF4FFBC1, 0xCF50FBC1, 0xCF51FBC1, 0xCF52FBC1, 0xCF53FBC1, 0xCF54FBC1, 0xCF55FBC1, 0xCF56FBC1, 0xCF57FBC1, 0xCF58FBC1, 0xCF59FBC1, 0xCF5AFBC1, 0xCF5BFBC1, 0xCF5CFBC1, 0xCF5DFBC1, 0xCF5EFBC1, 0xCF5FFBC1, 0xCF60FBC1, 0xCF61FBC1, 0xCF62FBC1, 0xCF63FBC1, 0xCF64FBC1, 0xCF65FBC1, 0xCF66FBC1, 0xCF67FBC1, 0xCF68FBC1, 0xCF69FBC1, 0xCF6AFBC1, 0xCF6BFBC1, 0xCF6CFBC1, 0xCF6DFBC1, 0xCF6EFBC1, 0xCF6FFBC1, 0xCF70FBC1, 0xCF71FBC1, 0xCF72FBC1, 0xCF73FBC1, 0xCF74FBC1, 0xCF75FBC1, 0xCF76FBC1, 0xCF77FBC1, 0xCF78FBC1, 0xCF79FBC1, 0xCF7AFBC1, 0xCF7BFBC1, 0xCF7CFBC1, 0xCF7DFBC1, 0xCF7EFBC1, 0xCF7FFBC1, 0xCF80FBC1, 0xCF81FBC1, 0xCF82FBC1, 0xCF83FBC1, 0xCF84FBC1, 0xCF85FBC1, 0xCF86FBC1, 0xCF87FBC1, 0xCF88FBC1, 0xCF89FBC1, 0xCF8AFBC1, 0xCF8BFBC1, 0xCF8CFBC1, 0xCF8DFBC1, 0xCF8EFBC1, 0xCF8FFBC1, 0xCF90FBC1, 0xCF91FBC1, 0xCF92FBC1, 0xCF93FBC1, 0xCF94FBC1, 0xCF95FBC1, 0xCF96FBC1, 0xCF97FBC1, 0xCF98FBC1, 0xCF99FBC1, 0xCF9AFBC1, 0xCF9BFBC1, 0xCF9CFBC1, 0xCF9DFBC1, 0xCF9EFBC1, 0xCF9FFBC1, 0xCFA0FBC1, 0xCFA1FBC1, 0xCFA2FBC1, 0xCFA3FBC1, 0xCFA4FBC1, 0xCFA5FBC1, 0xCFA6FBC1, 0xCFA7FBC1, 0xCFA8FBC1, 0xCFA9FBC1, 0xCFAAFBC1, 0xCFABFBC1, 0xCFACFBC1, 0xCFADFBC1, 0xCFAEFBC1, 0xCFAFFBC1, 0xCFB0FBC1, 0xCFB1FBC1, 0xCFB2FBC1, 0xCFB3FBC1, 0xCFB4FBC1, 0xCFB5FBC1, 0xCFB6FBC1, 0xCFB7FBC1, 0xCFB8FBC1, 0xCFB9FBC1, 0xCFBAFBC1, 0xCFBBFBC1, 0xCFBCFBC1, 0xCFBDFBC1, 0xCFBEFBC1, 0xCFBFFBC1, 0xCFC0FBC1, 0xCFC1FBC1, 0xCFC2FBC1, 0xCFC3FBC1, 0xCFC4FBC1, 0xCFC5FBC1, 0xCFC6FBC1, 0xCFC7FBC1, 0xCFC8FBC1, 0xCFC9FBC1, 0xCFCAFBC1, 0xCFCBFBC1, 0xCFCCFBC1, 0xCFCDFBC1, 0xCFCEFBC1, 0xCFCFFBC1, 0xCFD0FBC1, 0xCFD1FBC1, 0xCFD2FBC1, 0xCFD3FBC1, 0xCFD4FBC1, 0xCFD5FBC1, 0xCFD6FBC1, 0xCFD7FBC1, 0xCFD8FBC1, 0xCFD9FBC1, 0xCFDAFBC1, 0xCFDBFBC1, 0xCFDCFBC1, 0xCFDDFBC1, 0xCFDEFBC1, 0xCFDFFBC1, 0xCFE0FBC1, 0xCFE1FBC1, 0xCFE2FBC1, 0xCFE3FBC1, /* CF3A */
+ 0xCFE4FBC1, 0xCFE5FBC1, 0xCFE6FBC1, 0xCFE7FBC1, 0xCFE8FBC1, 0xCFE9FBC1, 0xCFEAFBC1, 0xCFEBFBC1, 0xCFECFBC1, 0xCFEDFBC1, 0xCFEEFBC1, 0xCFEFFBC1, 0xCFF0FBC1, 0xCFF1FBC1, 0xCFF2FBC1, 0xCFF3FBC1, 0xCFF4FBC1, 0xCFF5FBC1, 0xCFF6FBC1, 0xCFF7FBC1, 0xCFF8FBC1, 0xCFF9FBC1, 0xCFFAFBC1, 0xCFFBFBC1, 0xCFFCFBC1, 0xCFFDFBC1, 0xCFFEFBC1, 0xCFFFFBC1, 0xD000FBC1, 0xD001FBC1, 0xD002FBC1, 0xD003FBC1, 0xD004FBC1, 0xD005FBC1, 0xD006FBC1, 0xD007FBC1, 0xD008FBC1, 0xD009FBC1, 0xD00AFBC1, 0xD00BFBC1, 0xD00CFBC1, 0xD00DFBC1, 0xD00EFBC1, 0xD00FFBC1, 0xD010FBC1, 0xD011FBC1, 0xD012FBC1, 0xD013FBC1, 0xD014FBC1, 0xD015FBC1, 0xD016FBC1, 0xD017FBC1, 0xD018FBC1, 0xD019FBC1, 0xD01AFBC1, 0xD01BFBC1, 0xD01CFBC1, 0xD01DFBC1, 0xD01EFBC1, 0xD01FFBC1, 0xD020FBC1, 0xD021FBC1, 0xD022FBC1, 0xD023FBC1, 0xD024FBC1, 0xD025FBC1, 0xD026FBC1, 0xD027FBC1, 0xD028FBC1, 0xD029FBC1, 0xD02AFBC1, 0xD02BFBC1, 0xD02CFBC1, 0xD02DFBC1, 0xD02EFBC1, 0xD02FFBC1, 0xD030FBC1, 0xD031FBC1, 0xD032FBC1, 0xD033FBC1, 0xD034FBC1, 0xD035FBC1, 0xD036FBC1, 0xD037FBC1, 0xD038FBC1, 0xD039FBC1, 0xD03AFBC1, 0xD03BFBC1, 0xD03CFBC1, 0xD03DFBC1, 0xD03EFBC1, 0xD03FFBC1, 0xD040FBC1, 0xD041FBC1, 0xD042FBC1, 0xD043FBC1, 0xD044FBC1, 0xD045FBC1, 0xD046FBC1, 0xD047FBC1, 0xD048FBC1, 0xD049FBC1, 0xD04AFBC1, 0xD04BFBC1, 0xD04CFBC1, 0xD04DFBC1, 0xD04EFBC1, 0xD04FFBC1, 0xD050FBC1, 0xD051FBC1, 0xD052FBC1, 0xD053FBC1, 0xD054FBC1, 0xD055FBC1, 0xD056FBC1, 0xD057FBC1, 0xD058FBC1, 0xD059FBC1, 0xD05AFBC1, 0xD05BFBC1, 0xD05CFBC1, 0xD05DFBC1, 0xD05EFBC1, 0xD05FFBC1, 0xD060FBC1, 0xD061FBC1, 0xD062FBC1, 0xD063FBC1, 0xD064FBC1, 0xD065FBC1, 0xD066FBC1, 0xD067FBC1, 0xD068FBC1, 0xD069FBC1, 0xD06AFBC1, 0xD06BFBC1, 0xD06CFBC1, 0xD06DFBC1, 0xD06EFBC1, 0xD06FFBC1, 0xD070FBC1, 0xD071FBC1, 0xD072FBC1, 0xD073FBC1, 0xD074FBC1, 0xD075FBC1, 0xD076FBC1, 0xD077FBC1, 0xD078FBC1, 0xD079FBC1, 0xD07AFBC1, 0xD07BFBC1, 0xD07CFBC1, 0xD07DFBC1, 0xD07EFBC1, 0xD07FFBC1, 0xD080FBC1, 0xD081FBC1, 0xD082FBC1, 0xD083FBC1, 0xD084FBC1, 0xD085FBC1, 0xD086FBC1, 0xD087FBC1, 0xD088FBC1, 0xD089FBC1, 0xD08AFBC1, 0xD08BFBC1, 0xD08CFBC1, 0xD08DFBC1, /* CFE4 */
+ 0xD08EFBC1, 0xD08FFBC1, 0xD090FBC1, 0xD091FBC1, 0xD092FBC1, 0xD093FBC1, 0xD094FBC1, 0xD095FBC1, 0xD096FBC1, 0xD097FBC1, 0xD098FBC1, 0xD099FBC1, 0xD09AFBC1, 0xD09BFBC1, 0xD09CFBC1, 0xD09DFBC1, 0xD09EFBC1, 0xD09FFBC1, 0xD0A0FBC1, 0xD0A1FBC1, 0xD0A2FBC1, 0xD0A3FBC1, 0xD0A4FBC1, 0xD0A5FBC1, 0xD0A6FBC1, 0xD0A7FBC1, 0xD0A8FBC1, 0xD0A9FBC1, 0xD0AAFBC1, 0xD0ABFBC1, 0xD0ACFBC1, 0xD0ADFBC1, 0xD0AEFBC1, 0xD0AFFBC1, 0xD0B0FBC1, 0xD0B1FBC1, 0xD0B2FBC1, 0xD0B3FBC1, 0xD0B4FBC1, 0xD0B5FBC1, 0xD0B6FBC1, 0xD0B7FBC1, 0xD0B8FBC1, 0xD0B9FBC1, 0xD0BAFBC1, 0xD0BBFBC1, 0xD0BCFBC1, 0xD0BDFBC1, 0xD0BEFBC1, 0xD0BFFBC1, 0xD0C0FBC1, 0xD0C1FBC1, 0xD0C2FBC1, 0xD0C3FBC1, 0xD0C4FBC1, 0xD0C5FBC1, 0xD0C6FBC1, 0xD0C7FBC1, 0xD0C8FBC1, 0xD0C9FBC1, 0xD0CAFBC1, 0xD0CBFBC1, 0xD0CCFBC1, 0xD0CDFBC1, 0xD0CEFBC1, 0xD0CFFBC1, 0xD0D0FBC1, 0xD0D1FBC1, 0xD0D2FBC1, 0xD0D3FBC1, 0xD0D4FBC1, 0xD0D5FBC1, 0xD0D6FBC1, 0xD0D7FBC1, 0xD0D8FBC1, 0xD0D9FBC1, 0xD0DAFBC1, 0xD0DBFBC1, 0xD0DCFBC1, 0xD0DDFBC1, 0xD0DEFBC1, 0xD0DFFBC1, 0xD0E0FBC1, 0xD0E1FBC1, 0xD0E2FBC1, 0xD0E3FBC1, 0xD0E4FBC1, 0xD0E5FBC1, 0xD0E6FBC1, 0xD0E7FBC1, 0xD0E8FBC1, 0xD0E9FBC1, 0xD0EAFBC1, 0xD0EBFBC1, 0xD0ECFBC1, 0xD0EDFBC1, 0xD0EEFBC1, 0xD0EFFBC1, 0xD0F0FBC1, 0xD0F1FBC1, 0xD0F2FBC1, 0xD0F3FBC1, 0xD0F4FBC1, 0xD0F5FBC1, 0xD0F6FBC1, 0xD0F7FBC1, 0xD0F8FBC1, 0xD0F9FBC1, 0xD0FAFBC1, 0xD0FBFBC1, 0xD0FCFBC1, 0xD0FDFBC1, 0xD0FEFBC1, 0xD0FFFBC1, 0xD100FBC1, 0xD101FBC1, 0xD102FBC1, 0xD103FBC1, 0xD104FBC1, 0xD105FBC1, 0xD106FBC1, 0xD107FBC1, 0xD108FBC1, 0xD109FBC1, 0xD10AFBC1, 0xD10BFBC1, 0xD10CFBC1, 0xD10DFBC1, 0xD10EFBC1, 0xD10FFBC1, 0xD110FBC1, 0xD111FBC1, 0xD112FBC1, 0xD113FBC1, 0xD114FBC1, 0xD115FBC1, 0xD116FBC1, 0xD117FBC1, 0xD118FBC1, 0xD119FBC1, 0xD11AFBC1, 0xD11BFBC1, 0xD11CFBC1, 0xD11DFBC1, 0xD11EFBC1, 0xD11FFBC1, 0xD120FBC1, 0xD121FBC1, 0xD122FBC1, 0xD123FBC1, 0xD124FBC1, 0xD125FBC1, 0xD126FBC1, 0xD127FBC1, 0xD128FBC1, 0xD129FBC1, 0xD12AFBC1, 0xD12BFBC1, 0xD12CFBC1, 0xD12DFBC1, 0xD12EFBC1, 0xD12FFBC1, 0xD130FBC1, 0xD131FBC1, 0xD132FBC1, 0xD133FBC1, 0xD134FBC1, 0xD135FBC1, 0xD136FBC1, 0xD137FBC1, /* D08E */
+ 0xD138FBC1, 0xD139FBC1, 0xD13AFBC1, 0xD13BFBC1, 0xD13CFBC1, 0xD13DFBC1, 0xD13EFBC1, 0xD13FFBC1, 0xD140FBC1, 0xD141FBC1, 0xD142FBC1, 0xD143FBC1, 0xD144FBC1, 0xD145FBC1, 0xD146FBC1, 0xD147FBC1, 0xD148FBC1, 0xD149FBC1, 0xD14AFBC1, 0xD14BFBC1, 0xD14CFBC1, 0xD14DFBC1, 0xD14EFBC1, 0xD14FFBC1, 0xD150FBC1, 0xD151FBC1, 0xD152FBC1, 0xD153FBC1, 0xD154FBC1, 0xD155FBC1, 0xD156FBC1, 0xD157FBC1, 0xD158FBC1, 0xD159FBC1, 0xD15AFBC1, 0xD15BFBC1, 0xD15CFBC1, 0xD15DFBC1, 0xD15EFBC1, 0xD15FFBC1, 0xD160FBC1, 0xD161FBC1, 0xD162FBC1, 0xD163FBC1, 0xD164FBC1, 0xD165FBC1, 0xD166FBC1, 0xD167FBC1, 0xD168FBC1, 0xD169FBC1, 0xD16AFBC1, 0xD16BFBC1, 0xD16CFBC1, 0xD16DFBC1, 0xD16EFBC1, 0xD16FFBC1, 0xD170FBC1, 0xD171FBC1, 0xD172FBC1, 0xD173FBC1, 0xD174FBC1, 0xD175FBC1, 0xD176FBC1, 0xD177FBC1, 0xD178FBC1, 0xD179FBC1, 0xD17AFBC1, 0xD17BFBC1, 0xD17CFBC1, 0xD17DFBC1, 0xD17EFBC1, 0xD17FFBC1, 0xD180FBC1, 0xD181FBC1, 0xD182FBC1, 0xD183FBC1, 0xD184FBC1, 0xD185FBC1, 0xD186FBC1, 0xD187FBC1, 0xD188FBC1, 0xD189FBC1, 0xD18AFBC1, 0xD18BFBC1, 0xD18CFBC1, 0xD18DFBC1, 0xD18EFBC1, 0xD18FFBC1, 0xD190FBC1, 0xD191FBC1, 0xD192FBC1, 0xD193FBC1, 0xD194FBC1, 0xD195FBC1, 0xD196FBC1, 0xD197FBC1, 0xD198FBC1, 0xD199FBC1, 0xD19AFBC1, 0xD19BFBC1, 0xD19CFBC1, 0xD19DFBC1, 0xD19EFBC1, 0xD19FFBC1, 0xD1A0FBC1, 0xD1A1FBC1, 0xD1A2FBC1, 0xD1A3FBC1, 0xD1A4FBC1, 0xD1A5FBC1, 0xD1A6FBC1, 0xD1A7FBC1, 0xD1A8FBC1, 0xD1A9FBC1, 0xD1AAFBC1, 0xD1ABFBC1, 0xD1ACFBC1, 0xD1ADFBC1, 0xD1AEFBC1, 0xD1AFFBC1, 0xD1B0FBC1, 0xD1B1FBC1, 0xD1B2FBC1, 0xD1B3FBC1, 0xD1B4FBC1, 0xD1B5FBC1, 0xD1B6FBC1, 0xD1B7FBC1, 0xD1B8FBC1, 0xD1B9FBC1, 0xD1BAFBC1, 0xD1BBFBC1, 0xD1BCFBC1, 0xD1BDFBC1, 0xD1BEFBC1, 0xD1BFFBC1, 0xD1C0FBC1, 0xD1C1FBC1, 0xD1C2FBC1, 0xD1C3FBC1, 0xD1C4FBC1, 0xD1C5FBC1, 0xD1C6FBC1, 0xD1C7FBC1, 0xD1C8FBC1, 0xD1C9FBC1, 0xD1CAFBC1, 0xD1CBFBC1, 0xD1CCFBC1, 0xD1CDFBC1, 0xD1CEFBC1, 0xD1CFFBC1, 0xD1D0FBC1, 0xD1D1FBC1, 0xD1D2FBC1, 0xD1D3FBC1, 0xD1D4FBC1, 0xD1D5FBC1, 0xD1D6FBC1, 0xD1D7FBC1, 0xD1D8FBC1, 0xD1D9FBC1, 0xD1DAFBC1, 0xD1DBFBC1, 0xD1DCFBC1, 0xD1DDFBC1, 0xD1DEFBC1, 0xD1DFFBC1, 0xD1E0FBC1, 0xD1E1FBC1, /* D138 */
+ 0xD1E2FBC1, 0xD1E3FBC1, 0xD1E4FBC1, 0xD1E5FBC1, 0xD1E6FBC1, 0xD1E7FBC1, 0xD1E8FBC1, 0xD1E9FBC1, 0xD1EAFBC1, 0xD1EBFBC1, 0xD1ECFBC1, 0xD1EDFBC1, 0xD1EEFBC1, 0xD1EFFBC1, 0xD1F0FBC1, 0xD1F1FBC1, 0xD1F2FBC1, 0xD1F3FBC1, 0xD1F4FBC1, 0xD1F5FBC1, 0xD1F6FBC1, 0xD1F7FBC1, 0xD1F8FBC1, 0xD1F9FBC1, 0xD1FAFBC1, 0xD1FBFBC1, 0xD1FCFBC1, 0xD1FDFBC1, 0xD1FEFBC1, 0xD1FFFBC1, 0xD200FBC1, 0xD201FBC1, 0xD202FBC1, 0xD203FBC1, 0xD204FBC1, 0xD205FBC1, 0xD206FBC1, 0xD207FBC1, 0xD208FBC1, 0xD209FBC1, 0xD20AFBC1, 0xD20BFBC1, 0xD20CFBC1, 0xD20DFBC1, 0xD20EFBC1, 0xD20FFBC1, 0xD210FBC1, 0xD211FBC1, 0xD212FBC1, 0xD213FBC1, 0xD214FBC1, 0xD215FBC1, 0xD216FBC1, 0xD217FBC1, 0xD218FBC1, 0xD219FBC1, 0xD21AFBC1, 0xD21BFBC1, 0xD21CFBC1, 0xD21DFBC1, 0xD21EFBC1, 0xD21FFBC1, 0xD220FBC1, 0xD221FBC1, 0xD222FBC1, 0xD223FBC1, 0xD224FBC1, 0xD225FBC1, 0xD226FBC1, 0xD227FBC1, 0xD228FBC1, 0xD229FBC1, 0xD22AFBC1, 0xD22BFBC1, 0xD22CFBC1, 0xD22DFBC1, 0xD22EFBC1, 0xD22FFBC1, 0xD230FBC1, 0xD231FBC1, 0xD232FBC1, 0xD233FBC1, 0xD234FBC1, 0xD235FBC1, 0xD236FBC1, 0xD237FBC1, 0xD238FBC1, 0xD239FBC1, 0xD23AFBC1, 0xD23BFBC1, 0xD23CFBC1, 0xD23DFBC1, 0xD23EFBC1, 0xD23FFBC1, 0xD240FBC1, 0xD241FBC1, 0xD242FBC1, 0xD243FBC1, 0xD244FBC1, 0xD245FBC1, 0xD246FBC1, 0xD247FBC1, 0xD248FBC1, 0xD249FBC1, 0xD24AFBC1, 0xD24BFBC1, 0xD24CFBC1, 0xD24DFBC1, 0xD24EFBC1, 0xD24FFBC1, 0xD250FBC1, 0xD251FBC1, 0xD252FBC1, 0xD253FBC1, 0xD254FBC1, 0xD255FBC1, 0xD256FBC1, 0xD257FBC1, 0xD258FBC1, 0xD259FBC1, 0xD25AFBC1, 0xD25BFBC1, 0xD25CFBC1, 0xD25DFBC1, 0xD25EFBC1, 0xD25FFBC1, 0xD260FBC1, 0xD261FBC1, 0xD262FBC1, 0xD263FBC1, 0xD264FBC1, 0xD265FBC1, 0xD266FBC1, 0xD267FBC1, 0xD268FBC1, 0xD269FBC1, 0xD26AFBC1, 0xD26BFBC1, 0xD26CFBC1, 0xD26DFBC1, 0xD26EFBC1, 0xD26FFBC1, 0xD270FBC1, 0xD271FBC1, 0xD272FBC1, 0xD273FBC1, 0xD274FBC1, 0xD275FBC1, 0xD276FBC1, 0xD277FBC1, 0xD278FBC1, 0xD279FBC1, 0xD27AFBC1, 0xD27BFBC1, 0xD27CFBC1, 0xD27DFBC1, 0xD27EFBC1, 0xD27FFBC1, 0xD280FBC1, 0xD281FBC1, 0xD282FBC1, 0xD283FBC1, 0xD284FBC1, 0xD285FBC1, 0xD286FBC1, 0xD287FBC1, 0xD288FBC1, 0xD289FBC1, 0xD28AFBC1, 0xD28BFBC1, /* D1E2 */
+ 0xD28CFBC1, 0xD28DFBC1, 0xD28EFBC1, 0xD28FFBC1, 0xD290FBC1, 0xD291FBC1, 0xD292FBC1, 0xD293FBC1, 0xD294FBC1, 0xD295FBC1, 0xD296FBC1, 0xD297FBC1, 0xD298FBC1, 0xD299FBC1, 0xD29AFBC1, 0xD29BFBC1, 0xD29CFBC1, 0xD29DFBC1, 0xD29EFBC1, 0xD29FFBC1, 0xD2A0FBC1, 0xD2A1FBC1, 0xD2A2FBC1, 0xD2A3FBC1, 0xD2A4FBC1, 0xD2A5FBC1, 0xD2A6FBC1, 0xD2A7FBC1, 0xD2A8FBC1, 0xD2A9FBC1, 0xD2AAFBC1, 0xD2ABFBC1, 0xD2ACFBC1, 0xD2ADFBC1, 0xD2AEFBC1, 0xD2AFFBC1, 0xD2B0FBC1, 0xD2B1FBC1, 0xD2B2FBC1, 0xD2B3FBC1, 0xD2B4FBC1, 0xD2B5FBC1, 0xD2B6FBC1, 0xD2B7FBC1, 0xD2B8FBC1, 0xD2B9FBC1, 0xD2BAFBC1, 0xD2BBFBC1, 0xD2BCFBC1, 0xD2BDFBC1, 0xD2BEFBC1, 0xD2BFFBC1, 0xD2C0FBC1, 0xD2C1FBC1, 0xD2C2FBC1, 0xD2C3FBC1, 0xD2C4FBC1, 0xD2C5FBC1, 0xD2C6FBC1, 0xD2C7FBC1, 0xD2C8FBC1, 0xD2C9FBC1, 0xD2CAFBC1, 0xD2CBFBC1, 0xD2CCFBC1, 0xD2CDFBC1, 0xD2CEFBC1, 0xD2CFFBC1, 0xD2D0FBC1, 0xD2D1FBC1, 0xD2D2FBC1, 0xD2D3FBC1, 0xD2D4FBC1, 0xD2D5FBC1, 0xD2D6FBC1, 0xD2D7FBC1, 0xD2D8FBC1, 0xD2D9FBC1, 0xD2DAFBC1, 0xD2DBFBC1, 0xD2DCFBC1, 0xD2DDFBC1, 0xD2DEFBC1, 0xD2DFFBC1, 0xD2E0FBC1, 0xD2E1FBC1, 0xD2E2FBC1, 0xD2E3FBC1, 0xD2E4FBC1, 0xD2E5FBC1, 0xD2E6FBC1, 0xD2E7FBC1, 0xD2E8FBC1, 0xD2E9FBC1, 0xD2EAFBC1, 0xD2EBFBC1, 0xD2ECFBC1, 0xD2EDFBC1, 0xD2EEFBC1, 0xD2EFFBC1, 0xD2F0FBC1, 0xD2F1FBC1, 0xD2F2FBC1, 0xD2F3FBC1, 0xD2F4FBC1, 0xD2F5FBC1, 0xD2F6FBC1, 0xD2F7FBC1, 0xD2F8FBC1, 0xD2F9FBC1, 0xD2FAFBC1, 0xD2FBFBC1, 0xD2FCFBC1, 0xD2FDFBC1, 0xD2FEFBC1, 0xD2FFFBC1, 0xD300FBC1, 0xD301FBC1, 0xD302FBC1, 0xD303FBC1, 0xD304FBC1, 0xD305FBC1, 0xD306FBC1, 0xD307FBC1, 0xD308FBC1, 0xD309FBC1, 0xD30AFBC1, 0xD30BFBC1, 0xD30CFBC1, 0xD30DFBC1, 0xD30EFBC1, 0xD30FFBC1, 0xD310FBC1, 0xD311FBC1, 0xD312FBC1, 0xD313FBC1, 0xD314FBC1, 0xD315FBC1, 0xD316FBC1, 0xD317FBC1, 0xD318FBC1, 0xD319FBC1, 0xD31AFBC1, 0xD31BFBC1, 0xD31CFBC1, 0xD31DFBC1, 0xD31EFBC1, 0xD31FFBC1, 0xD320FBC1, 0xD321FBC1, 0xD322FBC1, 0xD323FBC1, 0xD324FBC1, 0xD325FBC1, 0xD326FBC1, 0xD327FBC1, 0xD328FBC1, 0xD329FBC1, 0xD32AFBC1, 0xD32BFBC1, 0xD32CFBC1, 0xD32DFBC1, 0xD32EFBC1, 0xD32FFBC1, 0xD330FBC1, 0xD331FBC1, 0xD332FBC1, 0xD333FBC1, 0xD334FBC1, 0xD335FBC1, /* D28C */
+ 0xD336FBC1, 0xD337FBC1, 0xD338FBC1, 0xD339FBC1, 0xD33AFBC1, 0xD33BFBC1, 0xD33CFBC1, 0xD33DFBC1, 0xD33EFBC1, 0xD33FFBC1, 0xD340FBC1, 0xD341FBC1, 0xD342FBC1, 0xD343FBC1, 0xD344FBC1, 0xD345FBC1, 0xD346FBC1, 0xD347FBC1, 0xD348FBC1, 0xD349FBC1, 0xD34AFBC1, 0xD34BFBC1, 0xD34CFBC1, 0xD34DFBC1, 0xD34EFBC1, 0xD34FFBC1, 0xD350FBC1, 0xD351FBC1, 0xD352FBC1, 0xD353FBC1, 0xD354FBC1, 0xD355FBC1, 0xD356FBC1, 0xD357FBC1, 0xD358FBC1, 0xD359FBC1, 0xD35AFBC1, 0xD35BFBC1, 0xD35CFBC1, 0xD35DFBC1, 0xD35EFBC1, 0xD35FFBC1, 0xD360FBC1, 0xD361FBC1, 0xD362FBC1, 0xD363FBC1, 0xD364FBC1, 0xD365FBC1, 0xD366FBC1, 0xD367FBC1, 0xD368FBC1, 0xD369FBC1, 0xD36AFBC1, 0xD36BFBC1, 0xD36CFBC1, 0xD36DFBC1, 0xD36EFBC1, 0xD36FFBC1, 0xD370FBC1, 0xD371FBC1, 0xD372FBC1, 0xD373FBC1, 0xD374FBC1, 0xD375FBC1, 0xD376FBC1, 0xD377FBC1, 0xD378FBC1, 0xD379FBC1, 0xD37AFBC1, 0xD37BFBC1, 0xD37CFBC1, 0xD37DFBC1, 0xD37EFBC1, 0xD37FFBC1, 0xD380FBC1, 0xD381FBC1, 0xD382FBC1, 0xD383FBC1, 0xD384FBC1, 0xD385FBC1, 0xD386FBC1, 0xD387FBC1, 0xD388FBC1, 0xD389FBC1, 0xD38AFBC1, 0xD38BFBC1, 0xD38CFBC1, 0xD38DFBC1, 0xD38EFBC1, 0xD38FFBC1, 0xD390FBC1, 0xD391FBC1, 0xD392FBC1, 0xD393FBC1, 0xD394FBC1, 0xD395FBC1, 0xD396FBC1, 0xD397FBC1, 0xD398FBC1, 0xD399FBC1, 0xD39AFBC1, 0xD39BFBC1, 0xD39CFBC1, 0xD39DFBC1, 0xD39EFBC1, 0xD39FFBC1, 0xD3A0FBC1, 0xD3A1FBC1, 0xD3A2FBC1, 0xD3A3FBC1, 0xD3A4FBC1, 0xD3A5FBC1, 0xD3A6FBC1, 0xD3A7FBC1, 0xD3A8FBC1, 0xD3A9FBC1, 0xD3AAFBC1, 0xD3ABFBC1, 0xD3ACFBC1, 0xD3ADFBC1, 0xD3AEFBC1, 0xD3AFFBC1, 0xD3B0FBC1, 0xD3B1FBC1, 0xD3B2FBC1, 0xD3B3FBC1, 0xD3B4FBC1, 0xD3B5FBC1, 0xD3B6FBC1, 0xD3B7FBC1, 0xD3B8FBC1, 0xD3B9FBC1, 0xD3BAFBC1, 0xD3BBFBC1, 0xD3BCFBC1, 0xD3BDFBC1, 0xD3BEFBC1, 0xD3BFFBC1, 0xD3C0FBC1, 0xD3C1FBC1, 0xD3C2FBC1, 0xD3C3FBC1, 0xD3C4FBC1, 0xD3C5FBC1, 0xD3C6FBC1, 0xD3C7FBC1, 0xD3C8FBC1, 0xD3C9FBC1, 0xD3CAFBC1, 0xD3CBFBC1, 0xD3CCFBC1, 0xD3CDFBC1, 0xD3CEFBC1, 0xD3CFFBC1, 0xD3D0FBC1, 0xD3D1FBC1, 0xD3D2FBC1, 0xD3D3FBC1, 0xD3D4FBC1, 0xD3D5FBC1, 0xD3D6FBC1, 0xD3D7FBC1, 0xD3D8FBC1, 0xD3D9FBC1, 0xD3DAFBC1, 0xD3DBFBC1, 0xD3DCFBC1, 0xD3DDFBC1, 0xD3DEFBC1, 0xD3DFFBC1, /* D336 */
+ 0xD3E0FBC1, 0xD3E1FBC1, 0xD3E2FBC1, 0xD3E3FBC1, 0xD3E4FBC1, 0xD3E5FBC1, 0xD3E6FBC1, 0xD3E7FBC1, 0xD3E8FBC1, 0xD3E9FBC1, 0xD3EAFBC1, 0xD3EBFBC1, 0xD3ECFBC1, 0xD3EDFBC1, 0xD3EEFBC1, 0xD3EFFBC1, 0xD3F0FBC1, 0xD3F1FBC1, 0xD3F2FBC1, 0xD3F3FBC1, 0xD3F4FBC1, 0xD3F5FBC1, 0xD3F6FBC1, 0xD3F7FBC1, 0xD3F8FBC1, 0xD3F9FBC1, 0xD3FAFBC1, 0xD3FBFBC1, 0xD3FCFBC1, 0xD3FDFBC1, 0xD3FEFBC1, 0xD3FFFBC1, 0xD400FBC1, 0xD401FBC1, 0xD402FBC1, 0xD403FBC1, 0xD404FBC1, 0xD405FBC1, 0xD406FBC1, 0xD407FBC1, 0xD408FBC1, 0xD409FBC1, 0xD40AFBC1, 0xD40BFBC1, 0xD40CFBC1, 0xD40DFBC1, 0xD40EFBC1, 0xD40FFBC1, 0xD410FBC1, 0xD411FBC1, 0xD412FBC1, 0xD413FBC1, 0xD414FBC1, 0xD415FBC1, 0xD416FBC1, 0xD417FBC1, 0xD418FBC1, 0xD419FBC1, 0xD41AFBC1, 0xD41BFBC1, 0xD41CFBC1, 0xD41DFBC1, 0xD41EFBC1, 0xD41FFBC1, 0xD420FBC1, 0xD421FBC1, 0xD422FBC1, 0xD423FBC1, 0xD424FBC1, 0xD425FBC1, 0xD426FBC1, 0xD427FBC1, 0xD428FBC1, 0xD429FBC1, 0xD42AFBC1, 0xD42BFBC1, 0xD42CFBC1, 0xD42DFBC1, 0xD42EFBC1, 0xD42FFBC1, 0xD430FBC1, 0xD431FBC1, 0xD432FBC1, 0xD433FBC1, 0xD434FBC1, 0xD435FBC1, 0xD436FBC1, 0xD437FBC1, 0xD438FBC1, 0xD439FBC1, 0xD43AFBC1, 0xD43BFBC1, 0xD43CFBC1, 0xD43DFBC1, 0xD43EFBC1, 0xD43FFBC1, 0xD440FBC1, 0xD441FBC1, 0xD442FBC1, 0xD443FBC1, 0xD444FBC1, 0xD445FBC1, 0xD446FBC1, 0xD447FBC1, 0xD448FBC1, 0xD449FBC1, 0xD44AFBC1, 0xD44BFBC1, 0xD44CFBC1, 0xD44DFBC1, 0xD44EFBC1, 0xD44FFBC1, 0xD450FBC1, 0xD451FBC1, 0xD452FBC1, 0xD453FBC1, 0xD454FBC1, 0xD455FBC1, 0xD456FBC1, 0xD457FBC1, 0xD458FBC1, 0xD459FBC1, 0xD45AFBC1, 0xD45BFBC1, 0xD45CFBC1, 0xD45DFBC1, 0xD45EFBC1, 0xD45FFBC1, 0xD460FBC1, 0xD461FBC1, 0xD462FBC1, 0xD463FBC1, 0xD464FBC1, 0xD465FBC1, 0xD466FBC1, 0xD467FBC1, 0xD468FBC1, 0xD469FBC1, 0xD46AFBC1, 0xD46BFBC1, 0xD46CFBC1, 0xD46DFBC1, 0xD46EFBC1, 0xD46FFBC1, 0xD470FBC1, 0xD471FBC1, 0xD472FBC1, 0xD473FBC1, 0xD474FBC1, 0xD475FBC1, 0xD476FBC1, 0xD477FBC1, 0xD478FBC1, 0xD479FBC1, 0xD47AFBC1, 0xD47BFBC1, 0xD47CFBC1, 0xD47DFBC1, 0xD47EFBC1, 0xD47FFBC1, 0xD480FBC1, 0xD481FBC1, 0xD482FBC1, 0xD483FBC1, 0xD484FBC1, 0xD485FBC1, 0xD486FBC1, 0xD487FBC1, 0xD488FBC1, 0xD489FBC1, /* D3E0 */
+ 0xD48AFBC1, 0xD48BFBC1, 0xD48CFBC1, 0xD48DFBC1, 0xD48EFBC1, 0xD48FFBC1, 0xD490FBC1, 0xD491FBC1, 0xD492FBC1, 0xD493FBC1, 0xD494FBC1, 0xD495FBC1, 0xD496FBC1, 0xD497FBC1, 0xD498FBC1, 0xD499FBC1, 0xD49AFBC1, 0xD49BFBC1, 0xD49CFBC1, 0xD49DFBC1, 0xD49EFBC1, 0xD49FFBC1, 0xD4A0FBC1, 0xD4A1FBC1, 0xD4A2FBC1, 0xD4A3FBC1, 0xD4A4FBC1, 0xD4A5FBC1, 0xD4A6FBC1, 0xD4A7FBC1, 0xD4A8FBC1, 0xD4A9FBC1, 0xD4AAFBC1, 0xD4ABFBC1, 0xD4ACFBC1, 0xD4ADFBC1, 0xD4AEFBC1, 0xD4AFFBC1, 0xD4B0FBC1, 0xD4B1FBC1, 0xD4B2FBC1, 0xD4B3FBC1, 0xD4B4FBC1, 0xD4B5FBC1, 0xD4B6FBC1, 0xD4B7FBC1, 0xD4B8FBC1, 0xD4B9FBC1, 0xD4BAFBC1, 0xD4BBFBC1, 0xD4BCFBC1, 0xD4BDFBC1, 0xD4BEFBC1, 0xD4BFFBC1, 0xD4C0FBC1, 0xD4C1FBC1, 0xD4C2FBC1, 0xD4C3FBC1, 0xD4C4FBC1, 0xD4C5FBC1, 0xD4C6FBC1, 0xD4C7FBC1, 0xD4C8FBC1, 0xD4C9FBC1, 0xD4CAFBC1, 0xD4CBFBC1, 0xD4CCFBC1, 0xD4CDFBC1, 0xD4CEFBC1, 0xD4CFFBC1, 0xD4D0FBC1, 0xD4D1FBC1, 0xD4D2FBC1, 0xD4D3FBC1, 0xD4D4FBC1, 0xD4D5FBC1, 0xD4D6FBC1, 0xD4D7FBC1, 0xD4D8FBC1, 0xD4D9FBC1, 0xD4DAFBC1, 0xD4DBFBC1, 0xD4DCFBC1, 0xD4DDFBC1, 0xD4DEFBC1, 0xD4DFFBC1, 0xD4E0FBC1, 0xD4E1FBC1, 0xD4E2FBC1, 0xD4E3FBC1, 0xD4E4FBC1, 0xD4E5FBC1, 0xD4E6FBC1, 0xD4E7FBC1, 0xD4E8FBC1, 0xD4E9FBC1, 0xD4EAFBC1, 0xD4EBFBC1, 0xD4ECFBC1, 0xD4EDFBC1, 0xD4EEFBC1, 0xD4EFFBC1, 0xD4F0FBC1, 0xD4F1FBC1, 0xD4F2FBC1, 0xD4F3FBC1, 0xD4F4FBC1, 0xD4F5FBC1, 0xD4F6FBC1, 0xD4F7FBC1, 0xD4F8FBC1, 0xD4F9FBC1, 0xD4FAFBC1, 0xD4FBFBC1, 0xD4FCFBC1, 0xD4FDFBC1, 0xD4FEFBC1, 0xD4FFFBC1, 0xD500FBC1, 0xD501FBC1, 0xD502FBC1, 0xD503FBC1, 0xD504FBC1, 0xD505FBC1, 0xD506FBC1, 0xD507FBC1, 0xD508FBC1, 0xD509FBC1, 0xD50AFBC1, 0xD50BFBC1, 0xD50CFBC1, 0xD50DFBC1, 0xD50EFBC1, 0xD50FFBC1, 0xD510FBC1, 0xD511FBC1, 0xD512FBC1, 0xD513FBC1, 0xD514FBC1, 0xD515FBC1, 0xD516FBC1, 0xD517FBC1, 0xD518FBC1, 0xD519FBC1, 0xD51AFBC1, 0xD51BFBC1, 0xD51CFBC1, 0xD51DFBC1, 0xD51EFBC1, 0xD51FFBC1, 0xD520FBC1, 0xD521FBC1, 0xD522FBC1, 0xD523FBC1, 0xD524FBC1, 0xD525FBC1, 0xD526FBC1, 0xD527FBC1, 0xD528FBC1, 0xD529FBC1, 0xD52AFBC1, 0xD52BFBC1, 0xD52CFBC1, 0xD52DFBC1, 0xD52EFBC1, 0xD52FFBC1, 0xD530FBC1, 0xD531FBC1, 0xD532FBC1, 0xD533FBC1, /* D48A */
+ 0xD534FBC1, 0xD535FBC1, 0xD536FBC1, 0xD537FBC1, 0xD538FBC1, 0xD539FBC1, 0xD53AFBC1, 0xD53BFBC1, 0xD53CFBC1, 0xD53DFBC1, 0xD53EFBC1, 0xD53FFBC1, 0xD540FBC1, 0xD541FBC1, 0xD542FBC1, 0xD543FBC1, 0xD544FBC1, 0xD545FBC1, 0xD546FBC1, 0xD547FBC1, 0xD548FBC1, 0xD549FBC1, 0xD54AFBC1, 0xD54BFBC1, 0xD54CFBC1, 0xD54DFBC1, 0xD54EFBC1, 0xD54FFBC1, 0xD550FBC1, 0xD551FBC1, 0xD552FBC1, 0xD553FBC1, 0xD554FBC1, 0xD555FBC1, 0xD556FBC1, 0xD557FBC1, 0xD558FBC1, 0xD559FBC1, 0xD55AFBC1, 0xD55BFBC1, 0xD55CFBC1, 0xD55DFBC1, 0xD55EFBC1, 0xD55FFBC1, 0xD560FBC1, 0xD561FBC1, 0xD562FBC1, 0xD563FBC1, 0xD564FBC1, 0xD565FBC1, 0xD566FBC1, 0xD567FBC1, 0xD568FBC1, 0xD569FBC1, 0xD56AFBC1, 0xD56BFBC1, 0xD56CFBC1, 0xD56DFBC1, 0xD56EFBC1, 0xD56FFBC1, 0xD570FBC1, 0xD571FBC1, 0xD572FBC1, 0xD573FBC1, 0xD574FBC1, 0xD575FBC1, 0xD576FBC1, 0xD577FBC1, 0xD578FBC1, 0xD579FBC1, 0xD57AFBC1, 0xD57BFBC1, 0xD57CFBC1, 0xD57DFBC1, 0xD57EFBC1, 0xD57FFBC1, 0xD580FBC1, 0xD581FBC1, 0xD582FBC1, 0xD583FBC1, 0xD584FBC1, 0xD585FBC1, 0xD586FBC1, 0xD587FBC1, 0xD588FBC1, 0xD589FBC1, 0xD58AFBC1, 0xD58BFBC1, 0xD58CFBC1, 0xD58DFBC1, 0xD58EFBC1, 0xD58FFBC1, 0xD590FBC1, 0xD591FBC1, 0xD592FBC1, 0xD593FBC1, 0xD594FBC1, 0xD595FBC1, 0xD596FBC1, 0xD597FBC1, 0xD598FBC1, 0xD599FBC1, 0xD59AFBC1, 0xD59BFBC1, 0xD59CFBC1, 0xD59DFBC1, 0xD59EFBC1, 0xD59FFBC1, 0xD5A0FBC1, 0xD5A1FBC1, 0xD5A2FBC1, 0xD5A3FBC1, 0xD5A4FBC1, 0xD5A5FBC1, 0xD5A6FBC1, 0xD5A7FBC1, 0xD5A8FBC1, 0xD5A9FBC1, 0xD5AAFBC1, 0xD5ABFBC1, 0xD5ACFBC1, 0xD5ADFBC1, 0xD5AEFBC1, 0xD5AFFBC1, 0xD5B0FBC1, 0xD5B1FBC1, 0xD5B2FBC1, 0xD5B3FBC1, 0xD5B4FBC1, 0xD5B5FBC1, 0xD5B6FBC1, 0xD5B7FBC1, 0xD5B8FBC1, 0xD5B9FBC1, 0xD5BAFBC1, 0xD5BBFBC1, 0xD5BCFBC1, 0xD5BDFBC1, 0xD5BEFBC1, 0xD5BFFBC1, 0xD5C0FBC1, 0xD5C1FBC1, 0xD5C2FBC1, 0xD5C3FBC1, 0xD5C4FBC1, 0xD5C5FBC1, 0xD5C6FBC1, 0xD5C7FBC1, 0xD5C8FBC1, 0xD5C9FBC1, 0xD5CAFBC1, 0xD5CBFBC1, 0xD5CCFBC1, 0xD5CDFBC1, 0xD5CEFBC1, 0xD5CFFBC1, 0xD5D0FBC1, 0xD5D1FBC1, 0xD5D2FBC1, 0xD5D3FBC1, 0xD5D4FBC1, 0xD5D5FBC1, 0xD5D6FBC1, 0xD5D7FBC1, 0xD5D8FBC1, 0xD5D9FBC1, 0xD5DAFBC1, 0xD5DBFBC1, 0xD5DCFBC1, 0xD5DDFBC1, /* D534 */
+ 0xD5DEFBC1, 0xD5DFFBC1, 0xD5E0FBC1, 0xD5E1FBC1, 0xD5E2FBC1, 0xD5E3FBC1, 0xD5E4FBC1, 0xD5E5FBC1, 0xD5E6FBC1, 0xD5E7FBC1, 0xD5E8FBC1, 0xD5E9FBC1, 0xD5EAFBC1, 0xD5EBFBC1, 0xD5ECFBC1, 0xD5EDFBC1, 0xD5EEFBC1, 0xD5EFFBC1, 0xD5F0FBC1, 0xD5F1FBC1, 0xD5F2FBC1, 0xD5F3FBC1, 0xD5F4FBC1, 0xD5F5FBC1, 0xD5F6FBC1, 0xD5F7FBC1, 0xD5F8FBC1, 0xD5F9FBC1, 0xD5FAFBC1, 0xD5FBFBC1, 0xD5FCFBC1, 0xD5FDFBC1, 0xD5FEFBC1, 0xD5FFFBC1, 0xD600FBC1, 0xD601FBC1, 0xD602FBC1, 0xD603FBC1, 0xD604FBC1, 0xD605FBC1, 0xD606FBC1, 0xD607FBC1, 0xD608FBC1, 0xD609FBC1, 0xD60AFBC1, 0xD60BFBC1, 0xD60CFBC1, 0xD60DFBC1, 0xD60EFBC1, 0xD60FFBC1, 0xD610FBC1, 0xD611FBC1, 0xD612FBC1, 0xD613FBC1, 0xD614FBC1, 0xD615FBC1, 0xD616FBC1, 0xD617FBC1, 0xD618FBC1, 0xD619FBC1, 0xD61AFBC1, 0xD61BFBC1, 0xD61CFBC1, 0xD61DFBC1, 0xD61EFBC1, 0xD61FFBC1, 0xD620FBC1, 0xD621FBC1, 0xD622FBC1, 0xD623FBC1, 0xD624FBC1, 0xD625FBC1, 0xD626FBC1, 0xD627FBC1, 0xD628FBC1, 0xD629FBC1, 0xD62AFBC1, 0xD62BFBC1, 0xD62CFBC1, 0xD62DFBC1, 0xD62EFBC1, 0xD62FFBC1, 0xD630FBC1, 0xD631FBC1, 0xD632FBC1, 0xD633FBC1, 0xD634FBC1, 0xD635FBC1, 0xD636FBC1, 0xD637FBC1, 0xD638FBC1, 0xD639FBC1, 0xD63AFBC1, 0xD63BFBC1, 0xD63CFBC1, 0xD63DFBC1, 0xD63EFBC1, 0xD63FFBC1, 0xD640FBC1, 0xD641FBC1, 0xD642FBC1, 0xD643FBC1, 0xD644FBC1, 0xD645FBC1, 0xD646FBC1, 0xD647FBC1, 0xD648FBC1, 0xD649FBC1, 0xD64AFBC1, 0xD64BFBC1, 0xD64CFBC1, 0xD64DFBC1, 0xD64EFBC1, 0xD64FFBC1, 0xD650FBC1, 0xD651FBC1, 0xD652FBC1, 0xD653FBC1, 0xD654FBC1, 0xD655FBC1, 0xD656FBC1, 0xD657FBC1, 0xD658FBC1, 0xD659FBC1, 0xD65AFBC1, 0xD65BFBC1, 0xD65CFBC1, 0xD65DFBC1, 0xD65EFBC1, 0xD65FFBC1, 0xD660FBC1, 0xD661FBC1, 0xD662FBC1, 0xD663FBC1, 0xD664FBC1, 0xD665FBC1, 0xD666FBC1, 0xD667FBC1, 0xD668FBC1, 0xD669FBC1, 0xD66AFBC1, 0xD66BFBC1, 0xD66CFBC1, 0xD66DFBC1, 0xD66EFBC1, 0xD66FFBC1, 0xD670FBC1, 0xD671FBC1, 0xD672FBC1, 0xD673FBC1, 0xD674FBC1, 0xD675FBC1, 0xD676FBC1, 0xD677FBC1, 0xD678FBC1, 0xD679FBC1, 0xD67AFBC1, 0xD67BFBC1, 0xD67CFBC1, 0xD67DFBC1, 0xD67EFBC1, 0xD67FFBC1, 0xD680FBC1, 0xD681FBC1, 0xD682FBC1, 0xD683FBC1, 0xD684FBC1, 0xD685FBC1, 0xD686FBC1, 0xD687FBC1, /* D5DE */
+ 0xD688FBC1, 0xD689FBC1, 0xD68AFBC1, 0xD68BFBC1, 0xD68CFBC1, 0xD68DFBC1, 0xD68EFBC1, 0xD68FFBC1, 0xD690FBC1, 0xD691FBC1, 0xD692FBC1, 0xD693FBC1, 0xD694FBC1, 0xD695FBC1, 0xD696FBC1, 0xD697FBC1, 0xD698FBC1, 0xD699FBC1, 0xD69AFBC1, 0xD69BFBC1, 0xD69CFBC1, 0xD69DFBC1, 0xD69EFBC1, 0xD69FFBC1, 0xD6A0FBC1, 0xD6A1FBC1, 0xD6A2FBC1, 0xD6A3FBC1, 0xD6A4FBC1, 0xD6A5FBC1, 0xD6A6FBC1, 0xD6A7FBC1, 0xD6A8FBC1, 0xD6A9FBC1, 0xD6AAFBC1, 0xD6ABFBC1, 0xD6ACFBC1, 0xD6ADFBC1, 0xD6AEFBC1, 0xD6AFFBC1, 0xD6B0FBC1, 0xD6B1FBC1, 0xD6B2FBC1, 0xD6B3FBC1, 0xD6B4FBC1, 0xD6B5FBC1, 0xD6B6FBC1, 0xD6B7FBC1, 0xD6B8FBC1, 0xD6B9FBC1, 0xD6BAFBC1, 0xD6BBFBC1, 0xD6BCFBC1, 0xD6BDFBC1, 0xD6BEFBC1, 0xD6BFFBC1, 0xD6C0FBC1, 0xD6C1FBC1, 0xD6C2FBC1, 0xD6C3FBC1, 0xD6C4FBC1, 0xD6C5FBC1, 0xD6C6FBC1, 0xD6C7FBC1, 0xD6C8FBC1, 0xD6C9FBC1, 0xD6CAFBC1, 0xD6CBFBC1, 0xD6CCFBC1, 0xD6CDFBC1, 0xD6CEFBC1, 0xD6CFFBC1, 0xD6D0FBC1, 0xD6D1FBC1, 0xD6D2FBC1, 0xD6D3FBC1, 0xD6D4FBC1, 0xD6D5FBC1, 0xD6D6FBC1, 0xD6D7FBC1, 0xD6D8FBC1, 0xD6D9FBC1, 0xD6DAFBC1, 0xD6DBFBC1, 0xD6DCFBC1, 0xD6DDFBC1, 0xD6DEFBC1, 0xD6DFFBC1, 0xD6E0FBC1, 0xD6E1FBC1, 0xD6E2FBC1, 0xD6E3FBC1, 0xD6E4FBC1, 0xD6E5FBC1, 0xD6E6FBC1, 0xD6E7FBC1, 0xD6E8FBC1, 0xD6E9FBC1, 0xD6EAFBC1, 0xD6EBFBC1, 0xD6ECFBC1, 0xD6EDFBC1, 0xD6EEFBC1, 0xD6EFFBC1, 0xD6F0FBC1, 0xD6F1FBC1, 0xD6F2FBC1, 0xD6F3FBC1, 0xD6F4FBC1, 0xD6F5FBC1, 0xD6F6FBC1, 0xD6F7FBC1, 0xD6F8FBC1, 0xD6F9FBC1, 0xD6FAFBC1, 0xD6FBFBC1, 0xD6FCFBC1, 0xD6FDFBC1, 0xD6FEFBC1, 0xD6FFFBC1, 0xD700FBC1, 0xD701FBC1, 0xD702FBC1, 0xD703FBC1, 0xD704FBC1, 0xD705FBC1, 0xD706FBC1, 0xD707FBC1, 0xD708FBC1, 0xD709FBC1, 0xD70AFBC1, 0xD70BFBC1, 0xD70CFBC1, 0xD70DFBC1, 0xD70EFBC1, 0xD70FFBC1, 0xD710FBC1, 0xD711FBC1, 0xD712FBC1, 0xD713FBC1, 0xD714FBC1, 0xD715FBC1, 0xD716FBC1, 0xD717FBC1, 0xD718FBC1, 0xD719FBC1, 0xD71AFBC1, 0xD71BFBC1, 0xD71CFBC1, 0xD71DFBC1, 0xD71EFBC1, 0xD71FFBC1, 0xD720FBC1, 0xD721FBC1, 0xD722FBC1, 0xD723FBC1, 0xD724FBC1, 0xD725FBC1, 0xD726FBC1, 0xD727FBC1, 0xD728FBC1, 0xD729FBC1, 0xD72AFBC1, 0xD72BFBC1, 0xD72CFBC1, 0xD72DFBC1, 0xD72EFBC1, 0xD72FFBC1, 0xD730FBC1, 0xD731FBC1, /* D688 */
+ 0xD732FBC1, 0xD733FBC1, 0xD734FBC1, 0xD735FBC1, 0xD736FBC1, 0xD737FBC1, 0xD738FBC1, 0xD739FBC1, 0xD73AFBC1, 0xD73BFBC1, 0xD73CFBC1, 0xD73DFBC1, 0xD73EFBC1, 0xD73FFBC1, 0xD740FBC1, 0xD741FBC1, 0xD742FBC1, 0xD743FBC1, 0xD744FBC1, 0xD745FBC1, 0xD746FBC1, 0xD747FBC1, 0xD748FBC1, 0xD749FBC1, 0xD74AFBC1, 0xD74BFBC1, 0xD74CFBC1, 0xD74DFBC1, 0xD74EFBC1, 0xD74FFBC1, 0xD750FBC1, 0xD751FBC1, 0xD752FBC1, 0xD753FBC1, 0xD754FBC1, 0xD755FBC1, 0xD756FBC1, 0xD757FBC1, 0xD758FBC1, 0xD759FBC1, 0xD75AFBC1, 0xD75BFBC1, 0xD75CFBC1, 0xD75DFBC1, 0xD75EFBC1, 0xD75FFBC1, 0xD760FBC1, 0xD761FBC1, 0xD762FBC1, 0xD763FBC1, 0xD764FBC1, 0xD765FBC1, 0xD766FBC1, 0xD767FBC1, 0xD768FBC1, 0xD769FBC1, 0xD76AFBC1, 0xD76BFBC1, 0xD76CFBC1, 0xD76DFBC1, 0xD76EFBC1, 0xD76FFBC1, 0xD770FBC1, 0xD771FBC1, 0xD772FBC1, 0xD773FBC1, 0xD774FBC1, 0xD775FBC1, 0xD776FBC1, 0xD777FBC1, 0xD778FBC1, 0xD779FBC1, 0xD77AFBC1, 0xD77BFBC1, 0xD77CFBC1, 0xD77DFBC1, 0xD77EFBC1, 0xD77FFBC1, 0xD780FBC1, 0xD781FBC1, 0xD782FBC1, 0xD783FBC1, 0xD784FBC1, 0xD785FBC1, 0xD786FBC1, 0xD787FBC1, 0xD788FBC1, 0xD789FBC1, 0xD78AFBC1, 0xD78BFBC1, 0xD78CFBC1, 0xD78DFBC1, 0xD78EFBC1, 0xD78FFBC1, 0xD790FBC1, 0xD791FBC1, 0xD792FBC1, 0xD793FBC1, 0xD794FBC1, 0xD795FBC1, 0xD796FBC1, 0xD797FBC1, 0xD798FBC1, 0xD799FBC1, 0xD79AFBC1, 0xD79BFBC1, 0xD79CFBC1, 0xD79DFBC1, 0xD79EFBC1, 0xD79FFBC1, 0xD7A0FBC1, 0xD7A1FBC1, 0xD7A2FBC1, 0xD7A3FBC1, 0xD7A4FBC1, 0xD7A5FBC1, 0xD7A6FBC1, 0xD7A7FBC1, 0xD7A8FBC1, 0xD7A9FBC1, 0xD7AAFBC1, 0xD7ABFBC1, 0xD7ACFBC1, 0xD7ADFBC1, 0xD7AEFBC1, 0xD7AFFBC1, 0xD7B0FBC1, 0xD7B1FBC1, 0xD7B2FBC1, 0xD7B3FBC1, 0xD7B4FBC1, 0xD7B5FBC1, 0xD7B6FBC1, 0xD7B7FBC1, 0xD7B8FBC1, 0xD7B9FBC1, 0xD7BAFBC1, 0xD7BBFBC1, 0xD7BCFBC1, 0xD7BDFBC1, 0xD7BEFBC1, 0xD7BFFBC1, 0xD7C0FBC1, 0xD7C1FBC1, 0xD7C2FBC1, 0xD7C3FBC1, 0xD7C4FBC1, 0xD7C5FBC1, 0xD7C6FBC1, 0xD7C7FBC1, 0xD7C8FBC1, 0xD7C9FBC1, 0xD7CAFBC1, 0xD7CBFBC1, 0xD7CCFBC1, 0xD7CDFBC1, 0xD7CEFBC1, 0xD7CFFBC1, 0xD7D0FBC1, 0xD7D1FBC1, 0xD7D2FBC1, 0xD7D3FBC1, 0xD7D4FBC1, 0xD7D5FBC1, 0xD7D6FBC1, 0xD7D7FBC1, 0xD7D8FBC1, 0xD7D9FBC1, 0xD7DAFBC1, 0xD7DBFBC1, /* D732 */
+ 0xD7DCFBC1, 0xD7DDFBC1, 0xD7DEFBC1, 0xD7DFFBC1, 0xD7E0FBC1, 0xD7E1FBC1, 0xD7E2FBC1, 0xD7E3FBC1, 0xD7E4FBC1, 0xD7E5FBC1, 0xD7E6FBC1, 0xD7E7FBC1, 0xD7E8FBC1, 0xD7E9FBC1, 0xD7EAFBC1, 0xD7EBFBC1, 0xD7ECFBC1, 0xD7EDFBC1, 0xD7EEFBC1, 0xD7EFFBC1, 0xD7F0FBC1, 0xD7F1FBC1, 0xD7F2FBC1, 0xD7F3FBC1, 0xD7F4FBC1, 0xD7F5FBC1, 0xD7F6FBC1, 0xD7F7FBC1, 0xD7F8FBC1, 0xD7F9FBC1, 0xD7FAFBC1, 0xD7FBFBC1, 0xD7FCFBC1, 0xD7FDFBC1, 0xD7FEFBC1, 0xD7FFFBC1, 0xD800FBC1, 0xD801FBC1, 0xD802FBC1, 0xD803FBC1, 0xD804FBC1, 0xD805FBC1, 0xD806FBC1, 0xD807FBC1, 0xD808FBC1, 0xD809FBC1, 0xD80AFBC1, 0xD80BFBC1, 0xD80CFBC1, 0xD80DFBC1, 0xD80EFBC1, 0xD80FFBC1, 0xD810FBC1, 0xD811FBC1, 0xD812FBC1, 0xD813FBC1, 0xD814FBC1, 0xD815FBC1, 0xD816FBC1, 0xD817FBC1, 0xD818FBC1, 0xD819FBC1, 0xD81AFBC1, 0xD81BFBC1, 0xD81CFBC1, 0xD81DFBC1, 0xD81EFBC1, 0xD81FFBC1, 0xD820FBC1, 0xD821FBC1, 0xD822FBC1, 0xD823FBC1, 0xD824FBC1, 0xD825FBC1, 0xD826FBC1, 0xD827FBC1, 0xD828FBC1, 0xD829FBC1, 0xD82AFBC1, 0xD82BFBC1, 0xD82CFBC1, 0xD82DFBC1, 0xD82EFBC1, 0xD82FFBC1, 0xD830FBC1, 0xD831FBC1, 0xD832FBC1, 0xD833FBC1, 0xD834FBC1, 0xD835FBC1, 0xD836FBC1, 0xD837FBC1, 0xD838FBC1, 0xD839FBC1, 0xD83AFBC1, 0xD83BFBC1, 0xD83CFBC1, 0xD83DFBC1, 0xD83EFBC1, 0xD83FFBC1, 0xD840FBC1, 0xD841FBC1, 0xD842FBC1, 0xD843FBC1, 0xD844FBC1, 0xD845FBC1, 0xD846FBC1, 0xD847FBC1, 0xD848FBC1, 0xD849FBC1, 0xD84AFBC1, 0xD84BFBC1, 0xD84CFBC1, 0xD84DFBC1, 0xD84EFBC1, 0xD84FFBC1, 0xD850FBC1, 0xD851FBC1, 0xD852FBC1, 0xD853FBC1, 0xD854FBC1, 0xD855FBC1, 0xD856FBC1, 0xD857FBC1, 0xD858FBC1, 0xD859FBC1, 0xD85AFBC1, 0xD85BFBC1, 0xD85CFBC1, 0xD85DFBC1, 0xD85EFBC1, 0xD85FFBC1, 0xD860FBC1, 0xD861FBC1, 0xD862FBC1, 0xD863FBC1, 0xD864FBC1, 0xD865FBC1, 0xD866FBC1, 0xD867FBC1, 0xD868FBC1, 0xD869FBC1, 0xD86AFBC1, 0xD86BFBC1, 0xD86CFBC1, 0xD86DFBC1, 0xD86EFBC1, 0xD86FFBC1, 0xD870FBC1, 0xD871FBC1, 0xD872FBC1, 0xD873FBC1, 0xD874FBC1, 0xD875FBC1, 0xD876FBC1, 0xD877FBC1, 0xD878FBC1, 0xD879FBC1, 0xD87AFBC1, 0xD87BFBC1, 0xD87CFBC1, 0xD87DFBC1, 0xD87EFBC1, 0xD87FFBC1, 0xD880FBC1, 0xD881FBC1, 0xD882FBC1, 0xD883FBC1, 0xD884FBC1, 0xD885FBC1, /* D7DC */
+ 0xD886FBC1, 0xD887FBC1, 0xD888FBC1, 0xD889FBC1, 0xD88AFBC1, 0xD88BFBC1, 0xD88CFBC1, 0xD88DFBC1, 0xD88EFBC1, 0xD88FFBC1, 0xD890FBC1, 0xD891FBC1, 0xD892FBC1, 0xD893FBC1, 0xD894FBC1, 0xD895FBC1, 0xD896FBC1, 0xD897FBC1, 0xD898FBC1, 0xD899FBC1, 0xD89AFBC1, 0xD89BFBC1, 0xD89CFBC1, 0xD89DFBC1, 0xD89EFBC1, 0xD89FFBC1, 0xD8A0FBC1, 0xD8A1FBC1, 0xD8A2FBC1, 0xD8A3FBC1, 0xD8A4FBC1, 0xD8A5FBC1, 0xD8A6FBC1, 0xD8A7FBC1, 0xD8A8FBC1, 0xD8A9FBC1, 0xD8AAFBC1, 0xD8ABFBC1, 0xD8ACFBC1, 0xD8ADFBC1, 0xD8AEFBC1, 0xD8AFFBC1, 0xD8B0FBC1, 0xD8B1FBC1, 0xD8B2FBC1, 0xD8B3FBC1, 0xD8B4FBC1, 0xD8B5FBC1, 0xD8B6FBC1, 0xD8B7FBC1, 0xD8B8FBC1, 0xD8B9FBC1, 0xD8BAFBC1, 0xD8BBFBC1, 0xD8BCFBC1, 0xD8BDFBC1, 0xD8BEFBC1, 0xD8BFFBC1, 0xD8C0FBC1, 0xD8C1FBC1, 0xD8C2FBC1, 0xD8C3FBC1, 0xD8C4FBC1, 0xD8C5FBC1, 0xD8C6FBC1, 0xD8C7FBC1, 0xD8C8FBC1, 0xD8C9FBC1, 0xD8CAFBC1, 0xD8CBFBC1, 0xD8CCFBC1, 0xD8CDFBC1, 0xD8CEFBC1, 0xD8CFFBC1, 0xD8D0FBC1, 0xD8D1FBC1, 0xD8D2FBC1, 0xD8D3FBC1, 0xD8D4FBC1, 0xD8D5FBC1, 0xD8D6FBC1, 0xD8D7FBC1, 0xD8D8FBC1, 0xD8D9FBC1, 0xD8DAFBC1, 0xD8DBFBC1, 0xD8DCFBC1, 0xD8DDFBC1, 0xD8DEFBC1, 0xD8DFFBC1, 0xD8E0FBC1, 0xD8E1FBC1, 0xD8E2FBC1, 0xD8E3FBC1, 0xD8E4FBC1, 0xD8E5FBC1, 0xD8E6FBC1, 0xD8E7FBC1, 0xD8E8FBC1, 0xD8E9FBC1, 0xD8EAFBC1, 0xD8EBFBC1, 0xD8ECFBC1, 0xD8EDFBC1, 0xD8EEFBC1, 0xD8EFFBC1, 0xD8F0FBC1, 0xD8F1FBC1, 0xD8F2FBC1, 0xD8F3FBC1, 0xD8F4FBC1, 0xD8F5FBC1, 0xD8F6FBC1, 0xD8F7FBC1, 0xD8F8FBC1, 0xD8F9FBC1, 0xD8FAFBC1, 0xD8FBFBC1, 0xD8FCFBC1, 0xD8FDFBC1, 0xD8FEFBC1, 0xD8FFFBC1, 0xD900FBC1, 0xD901FBC1, 0xD902FBC1, 0xD903FBC1, 0xD904FBC1, 0xD905FBC1, 0xD906FBC1, 0xD907FBC1, 0xD908FBC1, 0xD909FBC1, 0xD90AFBC1, 0xD90BFBC1, 0xD90CFBC1, 0xD90DFBC1, 0xD90EFBC1, 0xD90FFBC1, 0xD910FBC1, 0xD911FBC1, 0xD912FBC1, 0xD913FBC1, 0xD914FBC1, 0xD915FBC1, 0xD916FBC1, 0xD917FBC1, 0xD918FBC1, 0xD919FBC1, 0xD91AFBC1, 0xD91BFBC1, 0xD91CFBC1, 0xD91DFBC1, 0xD91EFBC1, 0xD91FFBC1, 0xD920FBC1, 0xD921FBC1, 0xD922FBC1, 0xD923FBC1, 0xD924FBC1, 0xD925FBC1, 0xD926FBC1, 0xD927FBC1, 0xD928FBC1, 0xD929FBC1, 0xD92AFBC1, 0xD92BFBC1, 0xD92CFBC1, 0xD92DFBC1, 0xD92EFBC1, 0xD92FFBC1, /* D886 */
+ 0xD930FBC1, 0xD931FBC1, 0xD932FBC1, 0xD933FBC1, 0xD934FBC1, 0xD935FBC1, 0xD936FBC1, 0xD937FBC1, 0xD938FBC1, 0xD939FBC1, 0xD93AFBC1, 0xD93BFBC1, 0xD93CFBC1, 0xD93DFBC1, 0xD93EFBC1, 0xD93FFBC1, 0xD940FBC1, 0xD941FBC1, 0xD942FBC1, 0xD943FBC1, 0xD944FBC1, 0xD945FBC1, 0xD946FBC1, 0xD947FBC1, 0xD948FBC1, 0xD949FBC1, 0xD94AFBC1, 0xD94BFBC1, 0xD94CFBC1, 0xD94DFBC1, 0xD94EFBC1, 0xD94FFBC1, 0xD950FBC1, 0xD951FBC1, 0xD952FBC1, 0xD953FBC1, 0xD954FBC1, 0xD955FBC1, 0xD956FBC1, 0xD957FBC1, 0xD958FBC1, 0xD959FBC1, 0xD95AFBC1, 0xD95BFBC1, 0xD95CFBC1, 0xD95DFBC1, 0xD95EFBC1, 0xD95FFBC1, 0xD960FBC1, 0xD961FBC1, 0xD962FBC1, 0xD963FBC1, 0xD964FBC1, 0xD965FBC1, 0xD966FBC1, 0xD967FBC1, 0xD968FBC1, 0xD969FBC1, 0xD96AFBC1, 0xD96BFBC1, 0xD96CFBC1, 0xD96DFBC1, 0xD96EFBC1, 0xD96FFBC1, 0xD970FBC1, 0xD971FBC1, 0xD972FBC1, 0xD973FBC1, 0xD974FBC1, 0xD975FBC1, 0xD976FBC1, 0xD977FBC1, 0xD978FBC1, 0xD979FBC1, 0xD97AFBC1, 0xD97BFBC1, 0xD97CFBC1, 0xD97DFBC1, 0xD97EFBC1, 0xD97FFBC1, 0xD980FBC1, 0xD981FBC1, 0xD982FBC1, 0xD983FBC1, 0xD984FBC1, 0xD985FBC1, 0xD986FBC1, 0xD987FBC1, 0xD988FBC1, 0xD989FBC1, 0xD98AFBC1, 0xD98BFBC1, 0xD98CFBC1, 0xD98DFBC1, 0xD98EFBC1, 0xD98FFBC1, 0xD990FBC1, 0xD991FBC1, 0xD992FBC1, 0xD993FBC1, 0xD994FBC1, 0xD995FBC1, 0xD996FBC1, 0xD997FBC1, 0xD998FBC1, 0xD999FBC1, 0xD99AFBC1, 0xD99BFBC1, 0xD99CFBC1, 0xD99DFBC1, 0xD99EFBC1, 0xD99FFBC1, 0xD9A0FBC1, 0xD9A1FBC1, 0xD9A2FBC1, 0xD9A3FBC1, 0xD9A4FBC1, 0xD9A5FBC1, 0xD9A6FBC1, 0xD9A7FBC1, 0xD9A8FBC1, 0xD9A9FBC1, 0xD9AAFBC1, 0xD9ABFBC1, 0xD9ACFBC1, 0xD9ADFBC1, 0xD9AEFBC1, 0xD9AFFBC1, 0xD9B0FBC1, 0xD9B1FBC1, 0xD9B2FBC1, 0xD9B3FBC1, 0xD9B4FBC1, 0xD9B5FBC1, 0xD9B6FBC1, 0xD9B7FBC1, 0xD9B8FBC1, 0xD9B9FBC1, 0xD9BAFBC1, 0xD9BBFBC1, 0xD9BCFBC1, 0xD9BDFBC1, 0xD9BEFBC1, 0xD9BFFBC1, 0xD9C0FBC1, 0xD9C1FBC1, 0xD9C2FBC1, 0xD9C3FBC1, 0xD9C4FBC1, 0xD9C5FBC1, 0xD9C6FBC1, 0xD9C7FBC1, 0xD9C8FBC1, 0xD9C9FBC1, 0xD9CAFBC1, 0xD9CBFBC1, 0xD9CCFBC1, 0xD9CDFBC1, 0xD9CEFBC1, 0xD9CFFBC1, 0xD9D0FBC1, 0xD9D1FBC1, 0xD9D2FBC1, 0xD9D3FBC1, 0xD9D4FBC1, 0xD9D5FBC1, 0xD9D6FBC1, 0xD9D7FBC1, 0xD9D8FBC1, 0xD9D9FBC1, /* D930 */
+ 0xD9DAFBC1, 0xD9DBFBC1, 0xD9DCFBC1, 0xD9DDFBC1, 0xD9DEFBC1, 0xD9DFFBC1, 0xD9E0FBC1, 0xD9E1FBC1, 0xD9E2FBC1, 0xD9E3FBC1, 0xD9E4FBC1, 0xD9E5FBC1, 0xD9E6FBC1, 0xD9E7FBC1, 0xD9E8FBC1, 0xD9E9FBC1, 0xD9EAFBC1, 0xD9EBFBC1, 0xD9ECFBC1, 0xD9EDFBC1, 0xD9EEFBC1, 0xD9EFFBC1, 0xD9F0FBC1, 0xD9F1FBC1, 0xD9F2FBC1, 0xD9F3FBC1, 0xD9F4FBC1, 0xD9F5FBC1, 0xD9F6FBC1, 0xD9F7FBC1, 0xD9F8FBC1, 0xD9F9FBC1, 0xD9FAFBC1, 0xD9FBFBC1, 0xD9FCFBC1, 0xD9FDFBC1, 0xD9FEFBC1, 0xD9FFFBC1, 0xDA00FBC1, 0xDA01FBC1, 0xDA02FBC1, 0xDA03FBC1, 0xDA04FBC1, 0xDA05FBC1, 0xDA06FBC1, 0xDA07FBC1, 0xDA08FBC1, 0xDA09FBC1, 0xDA0AFBC1, 0xDA0BFBC1, 0xDA0CFBC1, 0xDA0DFBC1, 0xDA0EFBC1, 0xDA0FFBC1, 0xDA10FBC1, 0xDA11FBC1, 0xDA12FBC1, 0xDA13FBC1, 0xDA14FBC1, 0xDA15FBC1, 0xDA16FBC1, 0xDA17FBC1, 0xDA18FBC1, 0xDA19FBC1, 0xDA1AFBC1, 0xDA1BFBC1, 0xDA1CFBC1, 0xDA1DFBC1, 0xDA1EFBC1, 0xDA1FFBC1, 0xDA20FBC1, 0xDA21FBC1, 0xDA22FBC1, 0xDA23FBC1, 0xDA24FBC1, 0xDA25FBC1, 0xDA26FBC1, 0xDA27FBC1, 0xDA28FBC1, 0xDA29FBC1, 0xDA2AFBC1, 0xDA2BFBC1, 0xDA2CFBC1, 0xDA2DFBC1, 0xDA2EFBC1, 0xDA2FFBC1, 0xDA30FBC1, 0xDA31FBC1, 0xDA32FBC1, 0xDA33FBC1, 0xDA34FBC1, 0xDA35FBC1, 0xDA36FBC1, 0xDA37FBC1, 0xDA38FBC1, 0xDA39FBC1, 0xDA3AFBC1, 0xDA3BFBC1, 0xDA3CFBC1, 0xDA3DFBC1, 0xDA3EFBC1, 0xDA3FFBC1, 0xDA40FBC1, 0xDA41FBC1, 0xDA42FBC1, 0xDA43FBC1, 0xDA44FBC1, 0xDA45FBC1, 0xDA46FBC1, 0xDA47FBC1, 0xDA48FBC1, 0xDA49FBC1, 0xDA4AFBC1, 0xDA4BFBC1, 0xDA4CFBC1, 0xDA4DFBC1, 0xDA4EFBC1, 0xDA4FFBC1, 0xDA50FBC1, 0xDA51FBC1, 0xDA52FBC1, 0xDA53FBC1, 0xDA54FBC1, 0xDA55FBC1, 0xDA56FBC1, 0xDA57FBC1, 0xDA58FBC1, 0xDA59FBC1, 0xDA5AFBC1, 0xDA5BFBC1, 0xDA5CFBC1, 0xDA5DFBC1, 0xDA5EFBC1, 0xDA5FFBC1, 0xDA60FBC1, 0xDA61FBC1, 0xDA62FBC1, 0xDA63FBC1, 0xDA64FBC1, 0xDA65FBC1, 0xDA66FBC1, 0xDA67FBC1, 0xDA68FBC1, 0xDA69FBC1, 0xDA6AFBC1, 0xDA6BFBC1, 0xDA6CFBC1, 0xDA6DFBC1, 0xDA6EFBC1, 0xDA6FFBC1, 0xDA70FBC1, 0xDA71FBC1, 0xDA72FBC1, 0xDA73FBC1, 0xDA74FBC1, 0xDA75FBC1, 0xDA76FBC1, 0xDA77FBC1, 0xDA78FBC1, 0xDA79FBC1, 0xDA7AFBC1, 0xDA7BFBC1, 0xDA7CFBC1, 0xDA7DFBC1, 0xDA7EFBC1, 0xDA7FFBC1, 0xDA80FBC1, 0xDA81FBC1, 0xDA82FBC1, 0xDA83FBC1, /* D9DA */
+ 0xDA84FBC1, 0xDA85FBC1, 0xDA86FBC1, 0xDA87FBC1, 0xDA88FBC1, 0xDA89FBC1, 0xDA8AFBC1, 0xDA8BFBC1, 0xDA8CFBC1, 0xDA8DFBC1, 0xDA8EFBC1, 0xDA8FFBC1, 0xDA90FBC1, 0xDA91FBC1, 0xDA92FBC1, 0xDA93FBC1, 0xDA94FBC1, 0xDA95FBC1, 0xDA96FBC1, 0xDA97FBC1, 0xDA98FBC1, 0xDA99FBC1, 0xDA9AFBC1, 0xDA9BFBC1, 0xDA9CFBC1, 0xDA9DFBC1, 0xDA9EFBC1, 0xDA9FFBC1, 0xDAA0FBC1, 0xDAA1FBC1, 0xDAA2FBC1, 0xDAA3FBC1, 0xDAA4FBC1, 0xDAA5FBC1, 0xDAA6FBC1, 0xDAA7FBC1, 0xDAA8FBC1, 0xDAA9FBC1, 0xDAAAFBC1, 0xDAABFBC1, 0xDAACFBC1, 0xDAADFBC1, 0xDAAEFBC1, 0xDAAFFBC1, 0xDAB0FBC1, 0xDAB1FBC1, 0xDAB2FBC1, 0xDAB3FBC1, 0xDAB4FBC1, 0xDAB5FBC1, 0xDAB6FBC1, 0xDAB7FBC1, 0xDAB8FBC1, 0xDAB9FBC1, 0xDABAFBC1, 0xDABBFBC1, 0xDABCFBC1, 0xDABDFBC1, 0xDABEFBC1, 0xDABFFBC1, 0xDAC0FBC1, 0xDAC1FBC1, 0xDAC2FBC1, 0xDAC3FBC1, 0xDAC4FBC1, 0xDAC5FBC1, 0xDAC6FBC1, 0xDAC7FBC1, 0xDAC8FBC1, 0xDAC9FBC1, 0xDACAFBC1, 0xDACBFBC1, 0xDACCFBC1, 0xDACDFBC1, 0xDACEFBC1, 0xDACFFBC1, 0xDAD0FBC1, 0xDAD1FBC1, 0xDAD2FBC1, 0xDAD3FBC1, 0xDAD4FBC1, 0xDAD5FBC1, 0xDAD6FBC1, 0xDAD7FBC1, 0xDAD8FBC1, 0xDAD9FBC1, 0xDADAFBC1, 0xDADBFBC1, 0xDADCFBC1, 0xDADDFBC1, 0xDADEFBC1, 0xDADFFBC1, 0xDAE0FBC1, 0xDAE1FBC1, 0xDAE2FBC1, 0xDAE3FBC1, 0xDAE4FBC1, 0xDAE5FBC1, 0xDAE6FBC1, 0xDAE7FBC1, 0xDAE8FBC1, 0xDAE9FBC1, 0xDAEAFBC1, 0xDAEBFBC1, 0xDAECFBC1, 0xDAEDFBC1, 0xDAEEFBC1, 0xDAEFFBC1, 0xDAF0FBC1, 0xDAF1FBC1, 0xDAF2FBC1, 0xDAF3FBC1, 0xDAF4FBC1, 0xDAF5FBC1, 0xDAF6FBC1, 0xDAF7FBC1, 0xDAF8FBC1, 0xDAF9FBC1, 0xDAFAFBC1, 0xDAFBFBC1, 0xDAFCFBC1, 0xDAFDFBC1, 0xDAFEFBC1, 0xDAFFFBC1, 0xDB00FBC1, 0xDB01FBC1, 0xDB02FBC1, 0xDB03FBC1, 0xDB04FBC1, 0xDB05FBC1, 0xDB06FBC1, 0xDB07FBC1, 0xDB08FBC1, 0xDB09FBC1, 0xDB0AFBC1, 0xDB0BFBC1, 0xDB0CFBC1, 0xDB0DFBC1, 0xDB0EFBC1, 0xDB0FFBC1, 0xDB10FBC1, 0xDB11FBC1, 0xDB12FBC1, 0xDB13FBC1, 0xDB14FBC1, 0xDB15FBC1, 0xDB16FBC1, 0xDB17FBC1, 0xDB18FBC1, 0xDB19FBC1, 0xDB1AFBC1, 0xDB1BFBC1, 0xDB1CFBC1, 0xDB1DFBC1, 0xDB1EFBC1, 0xDB1FFBC1, 0xDB20FBC1, 0xDB21FBC1, 0xDB22FBC1, 0xDB23FBC1, 0xDB24FBC1, 0xDB25FBC1, 0xDB26FBC1, 0xDB27FBC1, 0xDB28FBC1, 0xDB29FBC1, 0xDB2AFBC1, 0xDB2BFBC1, 0xDB2CFBC1, 0xDB2DFBC1, /* DA84 */
+ 0xDB2EFBC1, 0xDB2FFBC1, 0xDB30FBC1, 0xDB31FBC1, 0xDB32FBC1, 0xDB33FBC1, 0xDB34FBC1, 0xDB35FBC1, 0xDB36FBC1, 0xDB37FBC1, 0xDB38FBC1, 0xDB39FBC1, 0xDB3AFBC1, 0xDB3BFBC1, 0xDB3CFBC1, 0xDB3DFBC1, 0xDB3EFBC1, 0xDB3FFBC1, 0xDB40FBC1, 0xDB41FBC1, 0xDB42FBC1, 0xDB43FBC1, 0xDB44FBC1, 0xDB45FBC1, 0xDB46FBC1, 0xDB47FBC1, 0xDB48FBC1, 0xDB49FBC1, 0xDB4AFBC1, 0xDB4BFBC1, 0xDB4CFBC1, 0xDB4DFBC1, 0xDB4EFBC1, 0xDB4FFBC1, 0xDB50FBC1, 0xDB51FBC1, 0xDB52FBC1, 0xDB53FBC1, 0xDB54FBC1, 0xDB55FBC1, 0xDB56FBC1, 0xDB57FBC1, 0xDB58FBC1, 0xDB59FBC1, 0xDB5AFBC1, 0xDB5BFBC1, 0xDB5CFBC1, 0xDB5DFBC1, 0xDB5EFBC1, 0xDB5FFBC1, 0xDB60FBC1, 0xDB61FBC1, 0xDB62FBC1, 0xDB63FBC1, 0xDB64FBC1, 0xDB65FBC1, 0xDB66FBC1, 0xDB67FBC1, 0xDB68FBC1, 0xDB69FBC1, 0xDB6AFBC1, 0xDB6BFBC1, 0xDB6CFBC1, 0xDB6DFBC1, 0xDB6EFBC1, 0xDB6FFBC1, 0xDB70FBC1, 0xDB71FBC1, 0xDB72FBC1, 0xDB73FBC1, 0xDB74FBC1, 0xDB75FBC1, 0xDB76FBC1, 0xDB77FBC1, 0xDB78FBC1, 0xDB79FBC1, 0xDB7AFBC1, 0xDB7BFBC1, 0xDB7CFBC1, 0xDB7DFBC1, 0xDB7EFBC1, 0xDB7FFBC1, 0xDB80FBC1, 0xDB81FBC1, 0xDB82FBC1, 0xDB83FBC1, 0xDB84FBC1, 0xDB85FBC1, 0xDB86FBC1, 0xDB87FBC1, 0xDB88FBC1, 0xDB89FBC1, 0xDB8AFBC1, 0xDB8BFBC1, 0xDB8CFBC1, 0xDB8DFBC1, 0xDB8EFBC1, 0xDB8FFBC1, 0xDB90FBC1, 0xDB91FBC1, 0xDB92FBC1, 0xDB93FBC1, 0xDB94FBC1, 0xDB95FBC1, 0xDB96FBC1, 0xDB97FBC1, 0xDB98FBC1, 0xDB99FBC1, 0xDB9AFBC1, 0xDB9BFBC1, 0xDB9CFBC1, 0xDB9DFBC1, 0xDB9EFBC1, 0xDB9FFBC1, 0xDBA0FBC1, 0xDBA1FBC1, 0xDBA2FBC1, 0xDBA3FBC1, 0xDBA4FBC1, 0xDBA5FBC1, 0xDBA6FBC1, 0xDBA7FBC1, 0xDBA8FBC1, 0xDBA9FBC1, 0xDBAAFBC1, 0xDBABFBC1, 0xDBACFBC1, 0xDBADFBC1, 0xDBAEFBC1, 0xDBAFFBC1, 0xDBB0FBC1, 0xDBB1FBC1, 0xDBB2FBC1, 0xDBB3FBC1, 0xDBB4FBC1, 0xDBB5FBC1, 0xDBB6FBC1, 0xDBB7FBC1, 0xDBB8FBC1, 0xDBB9FBC1, 0xDBBAFBC1, 0xDBBBFBC1, 0xDBBCFBC1, 0xDBBDFBC1, 0xDBBEFBC1, 0xDBBFFBC1, 0xDBC0FBC1, 0xDBC1FBC1, 0xDBC2FBC1, 0xDBC3FBC1, 0xDBC4FBC1, 0xDBC5FBC1, 0xDBC6FBC1, 0xDBC7FBC1, 0xDBC8FBC1, 0xDBC9FBC1, 0xDBCAFBC1, 0xDBCBFBC1, 0xDBCCFBC1, 0xDBCDFBC1, 0xDBCEFBC1, 0xDBCFFBC1, 0xDBD0FBC1, 0xDBD1FBC1, 0xDBD2FBC1, 0xDBD3FBC1, 0xDBD4FBC1, 0xDBD5FBC1, 0xDBD6FBC1, 0xDBD7FBC1, /* DB2E */
+ 0xDBD8FBC1, 0xDBD9FBC1, 0xDBDAFBC1, 0xDBDBFBC1, 0xDBDCFBC1, 0xDBDDFBC1, 0xDBDEFBC1, 0xDBDFFBC1, 0xDBE0FBC1, 0xDBE1FBC1, 0xDBE2FBC1, 0xDBE3FBC1, 0xDBE4FBC1, 0xDBE5FBC1, 0xDBE6FBC1, 0xDBE7FBC1, 0xDBE8FBC1, 0xDBE9FBC1, 0xDBEAFBC1, 0xDBEBFBC1, 0xDBECFBC1, 0xDBEDFBC1, 0xDBEEFBC1, 0xDBEFFBC1, 0xDBF0FBC1, 0xDBF1FBC1, 0xDBF2FBC1, 0xDBF3FBC1, 0xDBF4FBC1, 0xDBF5FBC1, 0xDBF6FBC1, 0xDBF7FBC1, 0xDBF8FBC1, 0xDBF9FBC1, 0xDBFAFBC1, 0xDBFBFBC1, 0xDBFCFBC1, 0xDBFDFBC1, 0xDBFEFBC1, 0xDBFFFBC1, 0xDC00FBC1, 0xDC01FBC1, 0xDC02FBC1, 0xDC03FBC1, 0xDC04FBC1, 0xDC05FBC1, 0xDC06FBC1, 0xDC07FBC1, 0xDC08FBC1, 0xDC09FBC1, 0xDC0AFBC1, 0xDC0BFBC1, 0xDC0CFBC1, 0xDC0DFBC1, 0xDC0EFBC1, 0xDC0FFBC1, 0xDC10FBC1, 0xDC11FBC1, 0xDC12FBC1, 0xDC13FBC1, 0xDC14FBC1, 0xDC15FBC1, 0xDC16FBC1, 0xDC17FBC1, 0xDC18FBC1, 0xDC19FBC1, 0xDC1AFBC1, 0xDC1BFBC1, 0xDC1CFBC1, 0xDC1DFBC1, 0xDC1EFBC1, 0xDC1FFBC1, 0xDC20FBC1, 0xDC21FBC1, 0xDC22FBC1, 0xDC23FBC1, 0xDC24FBC1, 0xDC25FBC1, 0xDC26FBC1, 0xDC27FBC1, 0xDC28FBC1, 0xDC29FBC1, 0xDC2AFBC1, 0xDC2BFBC1, 0xDC2CFBC1, 0xDC2DFBC1, 0xDC2EFBC1, 0xDC2FFBC1, 0xDC30FBC1, 0xDC31FBC1, 0xDC32FBC1, 0xDC33FBC1, 0xDC34FBC1, 0xDC35FBC1, 0xDC36FBC1, 0xDC37FBC1, 0xDC38FBC1, 0xDC39FBC1, 0xDC3AFBC1, 0xDC3BFBC1, 0xDC3CFBC1, 0xDC3DFBC1, 0xDC3EFBC1, 0xDC3FFBC1, 0xDC40FBC1, 0xDC41FBC1, 0xDC42FBC1, 0xDC43FBC1, 0xDC44FBC1, 0xDC45FBC1, 0xDC46FBC1, 0xDC47FBC1, 0xDC48FBC1, 0xDC49FBC1, 0xDC4AFBC1, 0xDC4BFBC1, 0xDC4CFBC1, 0xDC4DFBC1, 0xDC4EFBC1, 0xDC4FFBC1, 0xDC50FBC1, 0xDC51FBC1, 0xDC52FBC1, 0xDC53FBC1, 0xDC54FBC1, 0xDC55FBC1, 0xDC56FBC1, 0xDC57FBC1, 0xDC58FBC1, 0xDC59FBC1, 0xDC5AFBC1, 0xDC5BFBC1, 0xDC5CFBC1, 0xDC5DFBC1, 0xDC5EFBC1, 0xDC5FFBC1, 0xDC60FBC1, 0xDC61FBC1, 0xDC62FBC1, 0xDC63FBC1, 0xDC64FBC1, 0xDC65FBC1, 0xDC66FBC1, 0xDC67FBC1, 0xDC68FBC1, 0xDC69FBC1, 0xDC6AFBC1, 0xDC6BFBC1, 0xDC6CFBC1, 0xDC6DFBC1, 0xDC6EFBC1, 0xDC6FFBC1, 0xDC70FBC1, 0xDC71FBC1, 0xDC72FBC1, 0xDC73FBC1, 0xDC74FBC1, 0xDC75FBC1, 0xDC76FBC1, 0xDC77FBC1, 0xDC78FBC1, 0xDC79FBC1, 0xDC7AFBC1, 0xDC7BFBC1, 0xDC7CFBC1, 0xDC7DFBC1, 0xDC7EFBC1, 0xDC7FFBC1, 0xDC80FBC1, 0xDC81FBC1, /* DBD8 */
+ 0xDC82FBC1, 0xDC83FBC1, 0xDC84FBC1, 0xDC85FBC1, 0xDC86FBC1, 0xDC87FBC1, 0xDC88FBC1, 0xDC89FBC1, 0xDC8AFBC1, 0xDC8BFBC1, 0xDC8CFBC1, 0xDC8DFBC1, 0xDC8EFBC1, 0xDC8FFBC1, 0xDC90FBC1, 0xDC91FBC1, 0xDC92FBC1, 0xDC93FBC1, 0xDC94FBC1, 0xDC95FBC1, 0xDC96FBC1, 0xDC97FBC1, 0xDC98FBC1, 0xDC99FBC1, 0xDC9AFBC1, 0xDC9BFBC1, 0xDC9CFBC1, 0xDC9DFBC1, 0xDC9EFBC1, 0xDC9FFBC1, 0xDCA0FBC1, 0xDCA1FBC1, 0xDCA2FBC1, 0xDCA3FBC1, 0xDCA4FBC1, 0xDCA5FBC1, 0xDCA6FBC1, 0xDCA7FBC1, 0xDCA8FBC1, 0xDCA9FBC1, 0xDCAAFBC1, 0xDCABFBC1, 0xDCACFBC1, 0xDCADFBC1, 0xDCAEFBC1, 0xDCAFFBC1, 0xDCB0FBC1, 0xDCB1FBC1, 0xDCB2FBC1, 0xDCB3FBC1, 0xDCB4FBC1, 0xDCB5FBC1, 0xDCB6FBC1, 0xDCB7FBC1, 0xDCB8FBC1, 0xDCB9FBC1, 0xDCBAFBC1, 0xDCBBFBC1, 0xDCBCFBC1, 0xDCBDFBC1, 0xDCBEFBC1, 0xDCBFFBC1, 0xDCC0FBC1, 0xDCC1FBC1, 0xDCC2FBC1, 0xDCC3FBC1, 0xDCC4FBC1, 0xDCC5FBC1, 0xDCC6FBC1, 0xDCC7FBC1, 0xDCC8FBC1, 0xDCC9FBC1, 0xDCCAFBC1, 0xDCCBFBC1, 0xDCCCFBC1, 0xDCCDFBC1, 0xDCCEFBC1, 0xDCCFFBC1, 0xDCD0FBC1, 0xDCD1FBC1, 0xDCD2FBC1, 0xDCD3FBC1, 0xDCD4FBC1, 0xDCD5FBC1, 0xDCD6FBC1, 0xDCD7FBC1, 0xDCD8FBC1, 0xDCD9FBC1, 0xDCDAFBC1, 0xDCDBFBC1, 0xDCDCFBC1, 0xDCDDFBC1, 0xDCDEFBC1, 0xDCDFFBC1, 0xDCE0FBC1, 0xDCE1FBC1, 0xDCE2FBC1, 0xDCE3FBC1, 0xDCE4FBC1, 0xDCE5FBC1, 0xDCE6FBC1, 0xDCE7FBC1, 0xDCE8FBC1, 0xDCE9FBC1, 0xDCEAFBC1, 0xDCEBFBC1, 0xDCECFBC1, 0xDCEDFBC1, 0xDCEEFBC1, 0xDCEFFBC1, 0xDCF0FBC1, 0xDCF1FBC1, 0xDCF2FBC1, 0xDCF3FBC1, 0xDCF4FBC1, 0xDCF5FBC1, 0xDCF6FBC1, 0xDCF7FBC1, 0xDCF8FBC1, 0xDCF9FBC1, 0xDCFAFBC1, 0xDCFBFBC1, 0xDCFCFBC1, 0xDCFDFBC1, 0xDCFEFBC1, 0xDCFFFBC1, 0xDD00FBC1, 0xDD01FBC1, 0xDD02FBC1, 0xDD03FBC1, 0xDD04FBC1, 0xDD05FBC1, 0xDD06FBC1, 0xDD07FBC1, 0xDD08FBC1, 0xDD09FBC1, 0xDD0AFBC1, 0xDD0BFBC1, 0xDD0CFBC1, 0xDD0DFBC1, 0xDD0EFBC1, 0xDD0FFBC1, 0xDD10FBC1, 0xDD11FBC1, 0xDD12FBC1, 0xDD13FBC1, 0xDD14FBC1, 0xDD15FBC1, 0xDD16FBC1, 0xDD17FBC1, 0xDD18FBC1, 0xDD19FBC1, 0xDD1AFBC1, 0xDD1BFBC1, 0xDD1CFBC1, 0xDD1DFBC1, 0xDD1EFBC1, 0xDD1FFBC1, 0xDD20FBC1, 0xDD21FBC1, 0xDD22FBC1, 0xDD23FBC1, 0xDD24FBC1, 0xDD25FBC1, 0xDD26FBC1, 0xDD27FBC1, 0xDD28FBC1, 0xDD29FBC1, 0xDD2AFBC1, 0xDD2BFBC1, /* DC82 */
+ 0xDD2CFBC1, 0xDD2DFBC1, 0xDD2EFBC1, 0xDD2FFBC1, 0xDD30FBC1, 0xDD31FBC1, 0xDD32FBC1, 0xDD33FBC1, 0xDD34FBC1, 0xDD35FBC1, 0xDD36FBC1, 0xDD37FBC1, 0xDD38FBC1, 0xDD39FBC1, 0xDD3AFBC1, 0xDD3BFBC1, 0xDD3CFBC1, 0xDD3DFBC1, 0xDD3EFBC1, 0xDD3FFBC1, 0xDD40FBC1, 0xDD41FBC1, 0xDD42FBC1, 0xDD43FBC1, 0xDD44FBC1, 0xDD45FBC1, 0xDD46FBC1, 0xDD47FBC1, 0xDD48FBC1, 0xDD49FBC1, 0xDD4AFBC1, 0xDD4BFBC1, 0xDD4CFBC1, 0xDD4DFBC1, 0xDD4EFBC1, 0xDD4FFBC1, 0xDD50FBC1, 0xDD51FBC1, 0xDD52FBC1, 0xDD53FBC1, 0xDD54FBC1, 0xDD55FBC1, 0xDD56FBC1, 0xDD57FBC1, 0xDD58FBC1, 0xDD59FBC1, 0xDD5AFBC1, 0xDD5BFBC1, 0xDD5CFBC1, 0xDD5DFBC1, 0xDD5EFBC1, 0xDD5FFBC1, 0xDD60FBC1, 0xDD61FBC1, 0xDD62FBC1, 0xDD63FBC1, 0xDD64FBC1, 0xDD65FBC1, 0xDD66FBC1, 0xDD67FBC1, 0xDD68FBC1, 0xDD69FBC1, 0xDD6AFBC1, 0xDD6BFBC1, 0xDD6CFBC1, 0xDD6DFBC1, 0xDD6EFBC1, 0xDD6FFBC1, 0xDD70FBC1, 0xDD71FBC1, 0xDD72FBC1, 0xDD73FBC1, 0xDD74FBC1, 0xDD75FBC1, 0xDD76FBC1, 0xDD77FBC1, 0xDD78FBC1, 0xDD79FBC1, 0xDD7AFBC1, 0xDD7BFBC1, 0xDD7CFBC1, 0xDD7DFBC1, 0xDD7EFBC1, 0xDD7FFBC1, 0xDD80FBC1, 0xDD81FBC1, 0xDD82FBC1, 0xDD83FBC1, 0xDD84FBC1, 0xDD85FBC1, 0xDD86FBC1, 0xDD87FBC1, 0xDD88FBC1, 0xDD89FBC1, 0xDD8AFBC1, 0xDD8BFBC1, 0xDD8CFBC1, 0xDD8DFBC1, 0xDD8EFBC1, 0xDD8FFBC1, 0xDD90FBC1, 0xDD91FBC1, 0xDD92FBC1, 0xDD93FBC1, 0xDD94FBC1, 0xDD95FBC1, 0xDD96FBC1, 0xDD97FBC1, 0xDD98FBC1, 0xDD99FBC1, 0xDD9AFBC1, 0xDD9BFBC1, 0xDD9CFBC1, 0xDD9DFBC1, 0xDD9EFBC1, 0xDD9FFBC1, 0xDDA0FBC1, 0xDDA1FBC1, 0xDDA2FBC1, 0xDDA3FBC1, 0xDDA4FBC1, 0xDDA5FBC1, 0xDDA6FBC1, 0xDDA7FBC1, 0xDDA8FBC1, 0xDDA9FBC1, 0xDDAAFBC1, 0xDDABFBC1, 0xDDACFBC1, 0xDDADFBC1, 0xDDAEFBC1, 0xDDAFFBC1, 0xDDB0FBC1, 0xDDB1FBC1, 0xDDB2FBC1, 0xDDB3FBC1, 0xDDB4FBC1, 0xDDB5FBC1, 0xDDB6FBC1, 0xDDB7FBC1, 0xDDB8FBC1, 0xDDB9FBC1, 0xDDBAFBC1, 0xDDBBFBC1, 0xDDBCFBC1, 0xDDBDFBC1, 0xDDBEFBC1, 0xDDBFFBC1, 0xDDC0FBC1, 0xDDC1FBC1, 0xDDC2FBC1, 0xDDC3FBC1, 0xDDC4FBC1, 0xDDC5FBC1, 0xDDC6FBC1, 0xDDC7FBC1, 0xDDC8FBC1, 0xDDC9FBC1, 0xDDCAFBC1, 0xDDCBFBC1, 0xDDCCFBC1, 0xDDCDFBC1, 0xDDCEFBC1, 0xDDCFFBC1, 0xDDD0FBC1, 0xDDD1FBC1, 0xDDD2FBC1, 0xDDD3FBC1, 0xDDD4FBC1, 0xDDD5FBC1, /* DD2C */
+ 0xDDD6FBC1, 0xDDD7FBC1, 0xDDD8FBC1, 0xDDD9FBC1, 0xDDDAFBC1, 0xDDDBFBC1, 0xDDDCFBC1, 0xDDDDFBC1, 0xDDDEFBC1, 0xDDDFFBC1, 0xDDE0FBC1, 0xDDE1FBC1, 0xDDE2FBC1, 0xDDE3FBC1, 0xDDE4FBC1, 0xDDE5FBC1, 0xDDE6FBC1, 0xDDE7FBC1, 0xDDE8FBC1, 0xDDE9FBC1, 0xDDEAFBC1, 0xDDEBFBC1, 0xDDECFBC1, 0xDDEDFBC1, 0xDDEEFBC1, 0xDDEFFBC1, 0xDDF0FBC1, 0xDDF1FBC1, 0xDDF2FBC1, 0xDDF3FBC1, 0xDDF4FBC1, 0xDDF5FBC1, 0xDDF6FBC1, 0xDDF7FBC1, 0xDDF8FBC1, 0xDDF9FBC1, 0xDDFAFBC1, 0xDDFBFBC1, 0xDDFCFBC1, 0xDDFDFBC1, 0xDDFEFBC1, 0xDDFFFBC1, 0xDE00FBC1, 0xDE01FBC1, 0xDE02FBC1, 0xDE03FBC1, 0xDE04FBC1, 0xDE05FBC1, 0xDE06FBC1, 0xDE07FBC1, 0xDE08FBC1, 0xDE09FBC1, 0xDE0AFBC1, 0xDE0BFBC1, 0xDE0CFBC1, 0xDE0DFBC1, 0xDE0EFBC1, 0xDE0FFBC1, 0xDE10FBC1, 0xDE11FBC1, 0xDE12FBC1, 0xDE13FBC1, 0xDE14FBC1, 0xDE15FBC1, 0xDE16FBC1, 0xDE17FBC1, 0xDE18FBC1, 0xDE19FBC1, 0xDE1AFBC1, 0xDE1BFBC1, 0xDE1CFBC1, 0xDE1DFBC1, 0xDE1EFBC1, 0xDE1FFBC1, 0xDE20FBC1, 0xDE21FBC1, 0xDE22FBC1, 0xDE23FBC1, 0xDE24FBC1, 0xDE25FBC1, 0xDE26FBC1, 0xDE27FBC1, 0xDE28FBC1, 0xDE29FBC1, 0xDE2AFBC1, 0xDE2BFBC1, 0xDE2CFBC1, 0xDE2DFBC1, 0xDE2EFBC1, 0xDE2FFBC1, 0xDE30FBC1, 0xDE31FBC1, 0xDE32FBC1, 0xDE33FBC1, 0xDE34FBC1, 0xDE35FBC1, 0xDE36FBC1, 0xDE37FBC1, 0xDE38FBC1, 0xDE39FBC1, 0xDE3AFBC1, 0xDE3BFBC1, 0xDE3CFBC1, 0xDE3DFBC1, 0xDE3EFBC1, 0xDE3FFBC1, 0xDE40FBC1, 0xDE41FBC1, 0xDE42FBC1, 0xDE43FBC1, 0xDE44FBC1, 0xDE45FBC1, 0xDE46FBC1, 0xDE47FBC1, 0xDE48FBC1, 0xDE49FBC1, 0xDE4AFBC1, 0xDE4BFBC1, 0xDE4CFBC1, 0xDE4DFBC1, 0xDE4EFBC1, 0xDE4FFBC1, 0xDE50FBC1, 0xDE51FBC1, 0xDE52FBC1, 0xDE53FBC1, 0xDE54FBC1, 0xDE55FBC1, 0xDE56FBC1, 0xDE57FBC1, 0xDE58FBC1, 0xDE59FBC1, 0xDE5AFBC1, 0xDE5BFBC1, 0xDE5CFBC1, 0xDE5DFBC1, 0xDE5EFBC1, 0xDE5FFBC1, 0xDE60FBC1, 0xDE61FBC1, 0xDE62FBC1, 0xDE63FBC1, 0xDE64FBC1, 0xDE65FBC1, 0xDE66FBC1, 0xDE67FBC1, 0xDE68FBC1, 0xDE69FBC1, 0xDE6AFBC1, 0xDE6BFBC1, 0xDE6CFBC1, 0xDE6DFBC1, 0xDE6EFBC1, 0xDE6FFBC1, 0xDE70FBC1, 0xDE71FBC1, 0xDE72FBC1, 0xDE73FBC1, 0xDE74FBC1, 0xDE75FBC1, 0xDE76FBC1, 0xDE77FBC1, 0xDE78FBC1, 0xDE79FBC1, 0xDE7AFBC1, 0xDE7BFBC1, 0xDE7CFBC1, 0xDE7DFBC1, 0xDE7EFBC1, 0xDE7FFBC1, /* DDD6 */
+ 0xDE80FBC1, 0xDE81FBC1, 0xDE82FBC1, 0xDE83FBC1, 0xDE84FBC1, 0xDE85FBC1, 0xDE86FBC1, 0xDE87FBC1, 0xDE88FBC1, 0xDE89FBC1, 0xDE8AFBC1, 0xDE8BFBC1, 0xDE8CFBC1, 0xDE8DFBC1, 0xDE8EFBC1, 0xDE8FFBC1, 0xDE90FBC1, 0xDE91FBC1, 0xDE92FBC1, 0xDE93FBC1, 0xDE94FBC1, 0xDE95FBC1, 0xDE96FBC1, 0xDE97FBC1, 0xDE98FBC1, 0xDE99FBC1, 0xDE9AFBC1, 0xDE9BFBC1, 0xDE9CFBC1, 0xDE9DFBC1, 0xDE9EFBC1, 0xDE9FFBC1, 0xDEA0FBC1, 0xDEA1FBC1, 0xDEA2FBC1, 0xDEA3FBC1, 0xDEA4FBC1, 0xDEA5FBC1, 0xDEA6FBC1, 0xDEA7FBC1, 0xDEA8FBC1, 0xDEA9FBC1, 0xDEAAFBC1, 0xDEABFBC1, 0xDEACFBC1, 0xDEADFBC1, 0xDEAEFBC1, 0xDEAFFBC1, 0xDEB0FBC1, 0xDEB1FBC1, 0xDEB2FBC1, 0xDEB3FBC1, 0xDEB4FBC1, 0xDEB5FBC1, 0xDEB6FBC1, 0xDEB7FBC1, 0xDEB8FBC1, 0xDEB9FBC1, 0xDEBAFBC1, 0xDEBBFBC1, 0xDEBCFBC1, 0xDEBDFBC1, 0xDEBEFBC1, 0xDEBFFBC1, 0xDEC0FBC1, 0xDEC1FBC1, 0xDEC2FBC1, 0xDEC3FBC1, 0xDEC4FBC1, 0xDEC5FBC1, 0xDEC6FBC1, 0xDEC7FBC1, 0xDEC8FBC1, 0xDEC9FBC1, 0xDECAFBC1, 0xDECBFBC1, 0xDECCFBC1, 0xDECDFBC1, 0xDECEFBC1, 0xDECFFBC1, 0xDED0FBC1, 0xDED1FBC1, 0xDED2FBC1, 0xDED3FBC1, 0xDED4FBC1, 0xDED5FBC1, 0xDED6FBC1, 0xDED7FBC1, 0xDED8FBC1, 0xDED9FBC1, 0xDEDAFBC1, 0xDEDBFBC1, 0xDEDCFBC1, 0xDEDDFBC1, 0xDEDEFBC1, 0xDEDFFBC1, 0xDEE0FBC1, 0xDEE1FBC1, 0xDEE2FBC1, 0xDEE3FBC1, 0xDEE4FBC1, 0xDEE5FBC1, 0xDEE6FBC1, 0xDEE7FBC1, 0xDEE8FBC1, 0xDEE9FBC1, 0xDEEAFBC1, 0xDEEBFBC1, 0xDEECFBC1, 0xDEEDFBC1, 0xDEEEFBC1, 0xDEEFFBC1, 0xDEF0FBC1, 0xDEF1FBC1, 0xDEF2FBC1, 0xDEF3FBC1, 0xDEF4FBC1, 0xDEF5FBC1, 0xDEF6FBC1, 0xDEF7FBC1, 0xDEF8FBC1, 0xDEF9FBC1, 0xDEFAFBC1, 0xDEFBFBC1, 0xDEFCFBC1, 0xDEFDFBC1, 0xDEFEFBC1, 0xDEFFFBC1, 0xDF00FBC1, 0xDF01FBC1, 0xDF02FBC1, 0xDF03FBC1, 0xDF04FBC1, 0xDF05FBC1, 0xDF06FBC1, 0xDF07FBC1, 0xDF08FBC1, 0xDF09FBC1, 0xDF0AFBC1, 0xDF0BFBC1, 0xDF0CFBC1, 0xDF0DFBC1, 0xDF0EFBC1, 0xDF0FFBC1, 0xDF10FBC1, 0xDF11FBC1, 0xDF12FBC1, 0xDF13FBC1, 0xDF14FBC1, 0xDF15FBC1, 0xDF16FBC1, 0xDF17FBC1, 0xDF18FBC1, 0xDF19FBC1, 0xDF1AFBC1, 0xDF1BFBC1, 0xDF1CFBC1, 0xDF1DFBC1, 0xDF1EFBC1, 0xDF1FFBC1, 0xDF20FBC1, 0xDF21FBC1, 0xDF22FBC1, 0xDF23FBC1, 0xDF24FBC1, 0xDF25FBC1, 0xDF26FBC1, 0xDF27FBC1, 0xDF28FBC1, 0xDF29FBC1, /* DE80 */
+ 0xDF2AFBC1, 0xDF2BFBC1, 0xDF2CFBC1, 0xDF2DFBC1, 0xDF2EFBC1, 0xDF2FFBC1, 0xDF30FBC1, 0xDF31FBC1, 0xDF32FBC1, 0xDF33FBC1, 0xDF34FBC1, 0xDF35FBC1, 0xDF36FBC1, 0xDF37FBC1, 0xDF38FBC1, 0xDF39FBC1, 0xDF3AFBC1, 0xDF3BFBC1, 0xDF3CFBC1, 0xDF3DFBC1, 0xDF3EFBC1, 0xDF3FFBC1, 0xDF40FBC1, 0xDF41FBC1, 0xDF42FBC1, 0xDF43FBC1, 0xDF44FBC1, 0xDF45FBC1, 0xDF46FBC1, 0xDF47FBC1, 0xDF48FBC1, 0xDF49FBC1, 0xDF4AFBC1, 0xDF4BFBC1, 0xDF4CFBC1, 0xDF4DFBC1, 0xDF4EFBC1, 0xDF4FFBC1, 0xDF50FBC1, 0xDF51FBC1, 0xDF52FBC1, 0xDF53FBC1, 0xDF54FBC1, 0xDF55FBC1, 0xDF56FBC1, 0xDF57FBC1, 0xDF58FBC1, 0xDF59FBC1, 0xDF5AFBC1, 0xDF5BFBC1, 0xDF5CFBC1, 0xDF5DFBC1, 0xDF5EFBC1, 0xDF5FFBC1, 0xDF60FBC1, 0xDF61FBC1, 0xDF62FBC1, 0xDF63FBC1, 0xDF64FBC1, 0xDF65FBC1, 0xDF66FBC1, 0xDF67FBC1, 0xDF68FBC1, 0xDF69FBC1, 0xDF6AFBC1, 0xDF6BFBC1, 0xDF6CFBC1, 0xDF6DFBC1, 0xDF6EFBC1, 0xDF6FFBC1, 0xDF70FBC1, 0xDF71FBC1, 0xDF72FBC1, 0xDF73FBC1, 0xDF74FBC1, 0xDF75FBC1, 0xDF76FBC1, 0xDF77FBC1, 0xDF78FBC1, 0xDF79FBC1, 0xDF7AFBC1, 0xDF7BFBC1, 0xDF7CFBC1, 0xDF7DFBC1, 0xDF7EFBC1, 0xDF7FFBC1, 0xDF80FBC1, 0xDF81FBC1, 0xDF82FBC1, 0xDF83FBC1, 0xDF84FBC1, 0xDF85FBC1, 0xDF86FBC1, 0xDF87FBC1, 0xDF88FBC1, 0xDF89FBC1, 0xDF8AFBC1, 0xDF8BFBC1, 0xDF8CFBC1, 0xDF8DFBC1, 0xDF8EFBC1, 0xDF8FFBC1, 0xDF90FBC1, 0xDF91FBC1, 0xDF92FBC1, 0xDF93FBC1, 0xDF94FBC1, 0xDF95FBC1, 0xDF96FBC1, 0xDF97FBC1, 0xDF98FBC1, 0xDF99FBC1, 0xDF9AFBC1, 0xDF9BFBC1, 0xDF9CFBC1, 0xDF9DFBC1, 0xDF9EFBC1, 0xDF9FFBC1, 0xDFA0FBC1, 0xDFA1FBC1, 0xDFA2FBC1, 0xDFA3FBC1, 0xDFA4FBC1, 0xDFA5FBC1, 0xDFA6FBC1, 0xDFA7FBC1, 0xDFA8FBC1, 0xDFA9FBC1, 0xDFAAFBC1, 0xDFABFBC1, 0xDFACFBC1, 0xDFADFBC1, 0xDFAEFBC1, 0xDFAFFBC1, 0xDFB0FBC1, 0xDFB1FBC1, 0xDFB2FBC1, 0xDFB3FBC1, 0xDFB4FBC1, 0xDFB5FBC1, 0xDFB6FBC1, 0xDFB7FBC1, 0xDFB8FBC1, 0xDFB9FBC1, 0xDFBAFBC1, 0xDFBBFBC1, 0xDFBCFBC1, 0xDFBDFBC1, 0xDFBEFBC1, 0xDFBFFBC1, 0xDFC0FBC1, 0xDFC1FBC1, 0xDFC2FBC1, 0xDFC3FBC1, 0xDFC4FBC1, 0xDFC5FBC1, 0xDFC6FBC1, 0xDFC7FBC1, 0xDFC8FBC1, 0xDFC9FBC1, 0xDFCAFBC1, 0xDFCBFBC1, 0xDFCCFBC1, 0xDFCDFBC1, 0xDFCEFBC1, 0xDFCFFBC1, 0xDFD0FBC1, 0xDFD1FBC1, 0xDFD2FBC1, 0xDFD3FBC1, /* DF2A */
+ 0xDFD4FBC1, 0xDFD5FBC1, 0xDFD6FBC1, 0xDFD7FBC1, 0xDFD8FBC1, 0xDFD9FBC1, 0xDFDAFBC1, 0xDFDBFBC1, 0xDFDCFBC1, 0xDFDDFBC1, 0xDFDEFBC1, 0xDFDFFBC1, 0xDFE0FBC1, 0xDFE1FBC1, 0xDFE2FBC1, 0xDFE3FBC1, 0xDFE4FBC1, 0xDFE5FBC1, 0xDFE6FBC1, 0xDFE7FBC1, 0xDFE8FBC1, 0xDFE9FBC1, 0xDFEAFBC1, 0xDFEBFBC1, 0xDFECFBC1, 0xDFEDFBC1, 0xDFEEFBC1, 0xDFEFFBC1, 0xDFF0FBC1, 0xDFF1FBC1, 0xDFF2FBC1, 0xDFF3FBC1, 0xDFF4FBC1, 0xDFF5FBC1, 0xDFF6FBC1, 0xDFF7FBC1, 0xDFF8FBC1, 0xDFF9FBC1, 0xDFFAFBC1, 0xDFFBFBC1, 0xDFFCFBC1, 0xDFFDFBC1, 0xDFFEFBC1, 0xDFFFFBC1, 0xE000FBC1, 0xE001FBC1, 0xE002FBC1, 0xE003FBC1, 0xE004FBC1, 0xE005FBC1, 0xE006FBC1, 0xE007FBC1, 0xE008FBC1, 0xE009FBC1, 0xE00AFBC1, 0xE00BFBC1, 0xE00CFBC1, 0xE00DFBC1, 0xE00EFBC1, 0xE00FFBC1, 0xE010FBC1, 0xE011FBC1, 0xE012FBC1, 0xE013FBC1, 0xE014FBC1, 0xE015FBC1, 0xE016FBC1, 0xE017FBC1, 0xE018FBC1, 0xE019FBC1, 0xE01AFBC1, 0xE01BFBC1, 0xE01CFBC1, 0xE01DFBC1, 0xE01EFBC1, 0xE01FFBC1, 0xE020FBC1, 0xE021FBC1, 0xE022FBC1, 0xE023FBC1, 0xE024FBC1, 0xE025FBC1, 0xE026FBC1, 0xE027FBC1, 0xE028FBC1, 0xE029FBC1, 0xE02AFBC1, 0xE02BFBC1, 0xE02CFBC1, 0xE02DFBC1, 0xE02EFBC1, 0xE02FFBC1, 0xE030FBC1, 0xE031FBC1, 0xE032FBC1, 0xE033FBC1, 0xE034FBC1, 0xE035FBC1, 0xE036FBC1, 0xE037FBC1, 0xE038FBC1, 0xE039FBC1, 0xE03AFBC1, 0xE03BFBC1, 0xE03CFBC1, 0xE03DFBC1, 0xE03EFBC1, 0xE03FFBC1, 0xE040FBC1, 0xE041FBC1, 0xE042FBC1, 0xE043FBC1, 0xE044FBC1, 0xE045FBC1, 0xE046FBC1, 0xE047FBC1, 0xE048FBC1, 0xE049FBC1, 0xE04AFBC1, 0xE04BFBC1, 0xE04CFBC1, 0xE04DFBC1, 0xE04EFBC1, 0xE04FFBC1, 0xE050FBC1, 0xE051FBC1, 0xE052FBC1, 0xE053FBC1, 0xE054FBC1, 0xE055FBC1, 0xE056FBC1, 0xE057FBC1, 0xE058FBC1, 0xE059FBC1, 0xE05AFBC1, 0xE05BFBC1, 0xE05CFBC1, 0xE05DFBC1, 0xE05EFBC1, 0xE05FFBC1, 0xE060FBC1, 0xE061FBC1, 0xE062FBC1, 0xE063FBC1, 0xE064FBC1, 0xE065FBC1, 0xE066FBC1, 0xE067FBC1, 0xE068FBC1, 0xE069FBC1, 0xE06AFBC1, 0xE06BFBC1, 0xE06CFBC1, 0xE06DFBC1, 0xE06EFBC1, 0xE06FFBC1, 0xE070FBC1, 0xE071FBC1, 0xE072FBC1, 0xE073FBC1, 0xE074FBC1, 0xE075FBC1, 0xE076FBC1, 0xE077FBC1, 0xE078FBC1, 0xE079FBC1, 0xE07AFBC1, 0xE07BFBC1, 0xE07CFBC1, 0xE07DFBC1, /* DFD4 */
+ 0xE07EFBC1, 0xE07FFBC1, 0xE080FBC1, 0xE081FBC1, 0xE082FBC1, 0xE083FBC1, 0xE084FBC1, 0xE085FBC1, 0xE086FBC1, 0xE087FBC1, 0xE088FBC1, 0xE089FBC1, 0xE08AFBC1, 0xE08BFBC1, 0xE08CFBC1, 0xE08DFBC1, 0xE08EFBC1, 0xE08FFBC1, 0xE090FBC1, 0xE091FBC1, 0xE092FBC1, 0xE093FBC1, 0xE094FBC1, 0xE095FBC1, 0xE096FBC1, 0xE097FBC1, 0xE098FBC1, 0xE099FBC1, 0xE09AFBC1, 0xE09BFBC1, 0xE09CFBC1, 0xE09DFBC1, 0xE09EFBC1, 0xE09FFBC1, 0xE0A0FBC1, 0xE0A1FBC1, 0xE0A2FBC1, 0xE0A3FBC1, 0xE0A4FBC1, 0xE0A5FBC1, 0xE0A6FBC1, 0xE0A7FBC1, 0xE0A8FBC1, 0xE0A9FBC1, 0xE0AAFBC1, 0xE0ABFBC1, 0xE0ACFBC1, 0xE0ADFBC1, 0xE0AEFBC1, 0xE0AFFBC1, 0xE0B0FBC1, 0xE0B1FBC1, 0xE0B2FBC1, 0xE0B3FBC1, 0xE0B4FBC1, 0xE0B5FBC1, 0xE0B6FBC1, 0xE0B7FBC1, 0xE0B8FBC1, 0xE0B9FBC1, 0xE0BAFBC1, 0xE0BBFBC1, 0xE0BCFBC1, 0xE0BDFBC1, 0xE0BEFBC1, 0xE0BFFBC1, 0xE0C0FBC1, 0xE0C1FBC1, 0xE0C2FBC1, 0xE0C3FBC1, 0xE0C4FBC1, 0xE0C5FBC1, 0xE0C6FBC1, 0xE0C7FBC1, 0xE0C8FBC1, 0xE0C9FBC1, 0xE0CAFBC1, 0xE0CBFBC1, 0xE0CCFBC1, 0xE0CDFBC1, 0xE0CEFBC1, 0xE0CFFBC1, 0xE0D0FBC1, 0xE0D1FBC1, 0xE0D2FBC1, 0xE0D3FBC1, 0xE0D4FBC1, 0xE0D5FBC1, 0xE0D6FBC1, 0xE0D7FBC1, 0xE0D8FBC1, 0xE0D9FBC1, 0xE0DAFBC1, 0xE0DBFBC1, 0xE0DCFBC1, 0xE0DDFBC1, 0xE0DEFBC1, 0xE0DFFBC1, 0xE0E0FBC1, 0xE0E1FBC1, 0xE0E2FBC1, 0xE0E3FBC1, 0xE0E4FBC1, 0xE0E5FBC1, 0xE0E6FBC1, 0xE0E7FBC1, 0xE0E8FBC1, 0xE0E9FBC1, 0xE0EAFBC1, 0xE0EBFBC1, 0xE0ECFBC1, 0xE0EDFBC1, 0xE0EEFBC1, 0xE0EFFBC1, 0xE0F0FBC1, 0xE0F1FBC1, 0xE0F2FBC1, 0xE0F3FBC1, 0xE0F4FBC1, 0xE0F5FBC1, 0xE0F6FBC1, 0xE0F7FBC1, 0xE0F8FBC1, 0xE0F9FBC1, 0xE0FAFBC1, 0xE0FBFBC1, 0xE0FCFBC1, 0xE0FDFBC1, 0xE0FEFBC1, 0xE0FFFBC1, 0xE100FBC1, 0xE101FBC1, 0xE102FBC1, 0xE103FBC1, 0xE104FBC1, 0xE105FBC1, 0xE106FBC1, 0xE107FBC1, 0xE108FBC1, 0xE109FBC1, 0xE10AFBC1, 0xE10BFBC1, 0xE10CFBC1, 0xE10DFBC1, 0xE10EFBC1, 0xE10FFBC1, 0xE110FBC1, 0xE111FBC1, 0xE112FBC1, 0xE113FBC1, 0xE114FBC1, 0xE115FBC1, 0xE116FBC1, 0xE117FBC1, 0xE118FBC1, 0xE119FBC1, 0xE11AFBC1, 0xE11BFBC1, 0xE11CFBC1, 0xE11DFBC1, 0xE11EFBC1, 0xE11FFBC1, 0xE120FBC1, 0xE121FBC1, 0xE122FBC1, 0xE123FBC1, 0xE124FBC1, 0xE125FBC1, 0xE126FBC1, 0xE127FBC1, /* E07E */
+ 0xE128FBC1, 0xE129FBC1, 0xE12AFBC1, 0xE12BFBC1, 0xE12CFBC1, 0xE12DFBC1, 0xE12EFBC1, 0xE12FFBC1, 0xE130FBC1, 0xE131FBC1, 0xE132FBC1, 0xE133FBC1, 0xE134FBC1, 0xE135FBC1, 0xE136FBC1, 0xE137FBC1, 0xE138FBC1, 0xE139FBC1, 0xE13AFBC1, 0xE13BFBC1, 0xE13CFBC1, 0xE13DFBC1, 0xE13EFBC1, 0xE13FFBC1, 0xE140FBC1, 0xE141FBC1, 0xE142FBC1, 0xE143FBC1, 0xE144FBC1, 0xE145FBC1, 0xE146FBC1, 0xE147FBC1, 0xE148FBC1, 0xE149FBC1, 0xE14AFBC1, 0xE14BFBC1, 0xE14CFBC1, 0xE14DFBC1, 0xE14EFBC1, 0xE14FFBC1, 0xE150FBC1, 0xE151FBC1, 0xE152FBC1, 0xE153FBC1, 0xE154FBC1, 0xE155FBC1, 0xE156FBC1, 0xE157FBC1, 0xE158FBC1, 0xE159FBC1, 0xE15AFBC1, 0xE15BFBC1, 0xE15CFBC1, 0xE15DFBC1, 0xE15EFBC1, 0xE15FFBC1, 0xE160FBC1, 0xE161FBC1, 0xE162FBC1, 0xE163FBC1, 0xE164FBC1, 0xE165FBC1, 0xE166FBC1, 0xE167FBC1, 0xE168FBC1, 0xE169FBC1, 0xE16AFBC1, 0xE16BFBC1, 0xE16CFBC1, 0xE16DFBC1, 0xE16EFBC1, 0xE16FFBC1, 0xE170FBC1, 0xE171FBC1, 0xE172FBC1, 0xE173FBC1, 0xE174FBC1, 0xE175FBC1, 0xE176FBC1, 0xE177FBC1, 0xE178FBC1, 0xE179FBC1, 0xE17AFBC1, 0xE17BFBC1, 0xE17CFBC1, 0xE17DFBC1, 0xE17EFBC1, 0xE17FFBC1, 0xE180FBC1, 0xE181FBC1, 0xE182FBC1, 0xE183FBC1, 0xE184FBC1, 0xE185FBC1, 0xE186FBC1, 0xE187FBC1, 0xE188FBC1, 0xE189FBC1, 0xE18AFBC1, 0xE18BFBC1, 0xE18CFBC1, 0xE18DFBC1, 0xE18EFBC1, 0xE18FFBC1, 0xE190FBC1, 0xE191FBC1, 0xE192FBC1, 0xE193FBC1, 0xE194FBC1, 0xE195FBC1, 0xE196FBC1, 0xE197FBC1, 0xE198FBC1, 0xE199FBC1, 0xE19AFBC1, 0xE19BFBC1, 0xE19CFBC1, 0xE19DFBC1, 0xE19EFBC1, 0xE19FFBC1, 0xE1A0FBC1, 0xE1A1FBC1, 0xE1A2FBC1, 0xE1A3FBC1, 0xE1A4FBC1, 0xE1A5FBC1, 0xE1A6FBC1, 0xE1A7FBC1, 0xE1A8FBC1, 0xE1A9FBC1, 0xE1AAFBC1, 0xE1ABFBC1, 0xE1ACFBC1, 0xE1ADFBC1, 0xE1AEFBC1, 0xE1AFFBC1, 0xE1B0FBC1, 0xE1B1FBC1, 0xE1B2FBC1, 0xE1B3FBC1, 0xE1B4FBC1, 0xE1B5FBC1, 0xE1B6FBC1, 0xE1B7FBC1, 0xE1B8FBC1, 0xE1B9FBC1, 0xE1BAFBC1, 0xE1BBFBC1, 0xE1BCFBC1, 0xE1BDFBC1, 0xE1BEFBC1, 0xE1BFFBC1, 0xE1C0FBC1, 0xE1C1FBC1, 0xE1C2FBC1, 0xE1C3FBC1, 0xE1C4FBC1, 0xE1C5FBC1, 0xE1C6FBC1, 0xE1C7FBC1, 0xE1C8FBC1, 0xE1C9FBC1, 0xE1CAFBC1, 0xE1CBFBC1, 0xE1CCFBC1, 0xE1CDFBC1, 0xE1CEFBC1, 0xE1CFFBC1, 0xE1D0FBC1, 0xE1D1FBC1, /* E128 */
+ 0xE1D2FBC1, 0xE1D3FBC1, 0xE1D4FBC1, 0xE1D5FBC1, 0xE1D6FBC1, 0xE1D7FBC1, 0xE1D8FBC1, 0xE1D9FBC1, 0xE1DAFBC1, 0xE1DBFBC1, 0xE1DCFBC1, 0xE1DDFBC1, 0xE1DEFBC1, 0xE1DFFBC1, 0xE1E0FBC1, 0xE1E1FBC1, 0xE1E2FBC1, 0xE1E3FBC1, 0xE1E4FBC1, 0xE1E5FBC1, 0xE1E6FBC1, 0xE1E7FBC1, 0xE1E8FBC1, 0xE1E9FBC1, 0xE1EAFBC1, 0xE1EBFBC1, 0xE1ECFBC1, 0xE1EDFBC1, 0xE1EEFBC1, 0xE1EFFBC1, 0xE1F0FBC1, 0xE1F1FBC1, 0xE1F2FBC1, 0xE1F3FBC1, 0xE1F4FBC1, 0xE1F5FBC1, 0xE1F6FBC1, 0xE1F7FBC1, 0xE1F8FBC1, 0xE1F9FBC1, 0xE1FAFBC1, 0xE1FBFBC1, 0xE1FCFBC1, 0xE1FDFBC1, 0xE1FEFBC1, 0xE1FFFBC1, 0xE200FBC1, 0xE201FBC1, 0xE202FBC1, 0xE203FBC1, 0xE204FBC1, 0xE205FBC1, 0xE206FBC1, 0xE207FBC1, 0xE208FBC1, 0xE209FBC1, 0xE20AFBC1, 0xE20BFBC1, 0xE20CFBC1, 0xE20DFBC1, 0xE20EFBC1, 0xE20FFBC1, 0xE210FBC1, 0xE211FBC1, 0xE212FBC1, 0xE213FBC1, 0xE214FBC1, 0xE215FBC1, 0xE216FBC1, 0xE217FBC1, 0xE218FBC1, 0xE219FBC1, 0xE21AFBC1, 0xE21BFBC1, 0xE21CFBC1, 0xE21DFBC1, 0xE21EFBC1, 0xE21FFBC1, 0xE220FBC1, 0xE221FBC1, 0xE222FBC1, 0xE223FBC1, 0xE224FBC1, 0xE225FBC1, 0xE226FBC1, 0xE227FBC1, 0xE228FBC1, 0xE229FBC1, 0xE22AFBC1, 0xE22BFBC1, 0xE22CFBC1, 0xE22DFBC1, 0xE22EFBC1, 0xE22FFBC1, 0xE230FBC1, 0xE231FBC1, 0xE232FBC1, 0xE233FBC1, 0xE234FBC1, 0xE235FBC1, 0xE236FBC1, 0xE237FBC1, 0xE238FBC1, 0xE239FBC1, 0xE23AFBC1, 0xE23BFBC1, 0xE23CFBC1, 0xE23DFBC1, 0xE23EFBC1, 0xE23FFBC1, 0xE240FBC1, 0xE241FBC1, 0xE242FBC1, 0xE243FBC1, 0xE244FBC1, 0xE245FBC1, 0xE246FBC1, 0xE247FBC1, 0xE248FBC1, 0xE249FBC1, 0xE24AFBC1, 0xE24BFBC1, 0xE24CFBC1, 0xE24DFBC1, 0xE24EFBC1, 0xE24FFBC1, 0xE250FBC1, 0xE251FBC1, 0xE252FBC1, 0xE253FBC1, 0xE254FBC1, 0xE255FBC1, 0xE256FBC1, 0xE257FBC1, 0xE258FBC1, 0xE259FBC1, 0xE25AFBC1, 0xE25BFBC1, 0xE25CFBC1, 0xE25DFBC1, 0xE25EFBC1, 0xE25FFBC1, 0xE260FBC1, 0xE261FBC1, 0xE262FBC1, 0xE263FBC1, 0xE264FBC1, 0xE265FBC1, 0xE266FBC1, 0xE267FBC1, 0xE268FBC1, 0xE269FBC1, 0xE26AFBC1, 0xE26BFBC1, 0xE26CFBC1, 0xE26DFBC1, 0xE26EFBC1, 0xE26FFBC1, 0xE270FBC1, 0xE271FBC1, 0xE272FBC1, 0xE273FBC1, 0xE274FBC1, 0xE275FBC1, 0xE276FBC1, 0xE277FBC1, 0xE278FBC1, 0xE279FBC1, 0xE27AFBC1, 0xE27BFBC1, /* E1D2 */
+ 0xE27CFBC1, 0xE27DFBC1, 0xE27EFBC1, 0xE27FFBC1, 0xE280FBC1, 0xE281FBC1, 0xE282FBC1, 0xE283FBC1, 0xE284FBC1, 0xE285FBC1, 0xE286FBC1, 0xE287FBC1, 0xE288FBC1, 0xE289FBC1, 0xE28AFBC1, 0xE28BFBC1, 0xE28CFBC1, 0xE28DFBC1, 0xE28EFBC1, 0xE28FFBC1, 0xE290FBC1, 0xE291FBC1, 0xE292FBC1, 0xE293FBC1, 0xE294FBC1, 0xE295FBC1, 0xE296FBC1, 0xE297FBC1, 0xE298FBC1, 0xE299FBC1, 0xE29AFBC1, 0xE29BFBC1, 0xE29CFBC1, 0xE29DFBC1, 0xE29EFBC1, 0xE29FFBC1, 0xE2A0FBC1, 0xE2A1FBC1, 0xE2A2FBC1, 0xE2A3FBC1, 0xE2A4FBC1, 0xE2A5FBC1, 0xE2A6FBC1, 0xE2A7FBC1, 0xE2A8FBC1, 0xE2A9FBC1, 0xE2AAFBC1, 0xE2ABFBC1, 0xE2ACFBC1, 0xE2ADFBC1, 0xE2AEFBC1, 0xE2AFFBC1, 0xE2B0FBC1, 0xE2B1FBC1, 0xE2B2FBC1, 0xE2B3FBC1, 0xE2B4FBC1, 0xE2B5FBC1, 0xE2B6FBC1, 0xE2B7FBC1, 0xE2B8FBC1, 0xE2B9FBC1, 0xE2BAFBC1, 0xE2BBFBC1, 0xE2BCFBC1, 0xE2BDFBC1, 0xE2BEFBC1, 0xE2BFFBC1, 0xE2C0FBC1, 0xE2C1FBC1, 0xE2C2FBC1, 0xE2C3FBC1, 0xE2C4FBC1, 0xE2C5FBC1, 0xE2C6FBC1, 0xE2C7FBC1, 0xE2C8FBC1, 0xE2C9FBC1, 0xE2CAFBC1, 0xE2CBFBC1, 0xE2CCFBC1, 0xE2CDFBC1, 0xE2CEFBC1, 0xE2CFFBC1, 0xE2D0FBC1, 0xE2D1FBC1, 0xE2D2FBC1, 0xE2D3FBC1, 0xE2D4FBC1, 0xE2D5FBC1, 0xE2D6FBC1, 0xE2D7FBC1, 0xE2D8FBC1, 0xE2D9FBC1, 0xE2DAFBC1, 0xE2DBFBC1, 0xE2DCFBC1, 0xE2DDFBC1, 0xE2DEFBC1, 0xE2DFFBC1, 0xE2E0FBC1, 0xE2E1FBC1, 0xE2E2FBC1, 0xE2E3FBC1, 0xE2E4FBC1, 0xE2E5FBC1, 0xE2E6FBC1, 0xE2E7FBC1, 0xE2E8FBC1, 0xE2E9FBC1, 0xE2EAFBC1, 0xE2EBFBC1, 0xE2ECFBC1, 0xE2EDFBC1, 0xE2EEFBC1, 0xE2EFFBC1, 0xE2F0FBC1, 0xE2F1FBC1, 0xE2F2FBC1, 0xE2F3FBC1, 0xE2F4FBC1, 0xE2F5FBC1, 0xE2F6FBC1, 0xE2F7FBC1, 0xE2F8FBC1, 0xE2F9FBC1, 0xE2FAFBC1, 0xE2FBFBC1, 0xE2FCFBC1, 0xE2FDFBC1, 0xE2FEFBC1, 0xE2FFFBC1, 0xE300FBC1, 0xE301FBC1, 0xE302FBC1, 0xE303FBC1, 0xE304FBC1, 0xE305FBC1, 0xE306FBC1, 0xE307FBC1, 0xE308FBC1, 0xE309FBC1, 0xE30AFBC1, 0xE30BFBC1, 0xE30CFBC1, 0xE30DFBC1, 0xE30EFBC1, 0xE30FFBC1, 0xE310FBC1, 0xE311FBC1, 0xE312FBC1, 0xE313FBC1, 0xE314FBC1, 0xE315FBC1, 0xE316FBC1, 0xE317FBC1, 0xE318FBC1, 0xE319FBC1, 0xE31AFBC1, 0xE31BFBC1, 0xE31CFBC1, 0xE31DFBC1, 0xE31EFBC1, 0xE31FFBC1, 0xE320FBC1, 0xE321FBC1, 0xE322FBC1, 0xE323FBC1, 0xE324FBC1, 0xE325FBC1, /* E27C */
+ 0xE326FBC1, 0xE327FBC1, 0xE328FBC1, 0xE329FBC1, 0xE32AFBC1, 0xE32BFBC1, 0xE32CFBC1, 0xE32DFBC1, 0xE32EFBC1, 0xE32FFBC1, 0xE330FBC1, 0xE331FBC1, 0xE332FBC1, 0xE333FBC1, 0xE334FBC1, 0xE335FBC1, 0xE336FBC1, 0xE337FBC1, 0xE338FBC1, 0xE339FBC1, 0xE33AFBC1, 0xE33BFBC1, 0xE33CFBC1, 0xE33DFBC1, 0xE33EFBC1, 0xE33FFBC1, 0xE340FBC1, 0xE341FBC1, 0xE342FBC1, 0xE343FBC1, 0xE344FBC1, 0xE345FBC1, 0xE346FBC1, 0xE347FBC1, 0xE348FBC1, 0xE349FBC1, 0xE34AFBC1, 0xE34BFBC1, 0xE34CFBC1, 0xE34DFBC1, 0xE34EFBC1, 0xE34FFBC1, 0xE350FBC1, 0xE351FBC1, 0xE352FBC1, 0xE353FBC1, 0xE354FBC1, 0xE355FBC1, 0xE356FBC1, 0xE357FBC1, 0xE358FBC1, 0xE359FBC1, 0xE35AFBC1, 0xE35BFBC1, 0xE35CFBC1, 0xE35DFBC1, 0xE35EFBC1, 0xE35FFBC1, 0xE360FBC1, 0xE361FBC1, 0xE362FBC1, 0xE363FBC1, 0xE364FBC1, 0xE365FBC1, 0xE366FBC1, 0xE367FBC1, 0xE368FBC1, 0xE369FBC1, 0xE36AFBC1, 0xE36BFBC1, 0xE36CFBC1, 0xE36DFBC1, 0xE36EFBC1, 0xE36FFBC1, 0xE370FBC1, 0xE371FBC1, 0xE372FBC1, 0xE373FBC1, 0xE374FBC1, 0xE375FBC1, 0xE376FBC1, 0xE377FBC1, 0xE378FBC1, 0xE379FBC1, 0xE37AFBC1, 0xE37BFBC1, 0xE37CFBC1, 0xE37DFBC1, 0xE37EFBC1, 0xE37FFBC1, 0xE380FBC1, 0xE381FBC1, 0xE382FBC1, 0xE383FBC1, 0xE384FBC1, 0xE385FBC1, 0xE386FBC1, 0xE387FBC1, 0xE388FBC1, 0xE389FBC1, 0xE38AFBC1, 0xE38BFBC1, 0xE38CFBC1, 0xE38DFBC1, 0xE38EFBC1, 0xE38FFBC1, 0xE390FBC1, 0xE391FBC1, 0xE392FBC1, 0xE393FBC1, 0xE394FBC1, 0xE395FBC1, 0xE396FBC1, 0xE397FBC1, 0xE398FBC1, 0xE399FBC1, 0xE39AFBC1, 0xE39BFBC1, 0xE39CFBC1, 0xE39DFBC1, 0xE39EFBC1, 0xE39FFBC1, 0xE3A0FBC1, 0xE3A1FBC1, 0xE3A2FBC1, 0xE3A3FBC1, 0xE3A4FBC1, 0xE3A5FBC1, 0xE3A6FBC1, 0xE3A7FBC1, 0xE3A8FBC1, 0xE3A9FBC1, 0xE3AAFBC1, 0xE3ABFBC1, 0xE3ACFBC1, 0xE3ADFBC1, 0xE3AEFBC1, 0xE3AFFBC1, 0xE3B0FBC1, 0xE3B1FBC1, 0xE3B2FBC1, 0xE3B3FBC1, 0xE3B4FBC1, 0xE3B5FBC1, 0xE3B6FBC1, 0xE3B7FBC1, 0xE3B8FBC1, 0xE3B9FBC1, 0xE3BAFBC1, 0xE3BBFBC1, 0xE3BCFBC1, 0xE3BDFBC1, 0xE3BEFBC1, 0xE3BFFBC1, 0xE3C0FBC1, 0xE3C1FBC1, 0xE3C2FBC1, 0xE3C3FBC1, 0xE3C4FBC1, 0xE3C5FBC1, 0xE3C6FBC1, 0xE3C7FBC1, 0xE3C8FBC1, 0xE3C9FBC1, 0xE3CAFBC1, 0xE3CBFBC1, 0xE3CCFBC1, 0xE3CDFBC1, 0xE3CEFBC1, 0xE3CFFBC1, /* E326 */
+ 0xE3D0FBC1, 0xE3D1FBC1, 0xE3D2FBC1, 0xE3D3FBC1, 0xE3D4FBC1, 0xE3D5FBC1, 0xE3D6FBC1, 0xE3D7FBC1, 0xE3D8FBC1, 0xE3D9FBC1, 0xE3DAFBC1, 0xE3DBFBC1, 0xE3DCFBC1, 0xE3DDFBC1, 0xE3DEFBC1, 0xE3DFFBC1, 0xE3E0FBC1, 0xE3E1FBC1, 0xE3E2FBC1, 0xE3E3FBC1, 0xE3E4FBC1, 0xE3E5FBC1, 0xE3E6FBC1, 0xE3E7FBC1, 0xE3E8FBC1, 0xE3E9FBC1, 0xE3EAFBC1, 0xE3EBFBC1, 0xE3ECFBC1, 0xE3EDFBC1, 0xE3EEFBC1, 0xE3EFFBC1, 0xE3F0FBC1, 0xE3F1FBC1, 0xE3F2FBC1, 0xE3F3FBC1, 0xE3F4FBC1, 0xE3F5FBC1, 0xE3F6FBC1, 0xE3F7FBC1, 0xE3F8FBC1, 0xE3F9FBC1, 0xE3FAFBC1, 0xE3FBFBC1, 0xE3FCFBC1, 0xE3FDFBC1, 0xE3FEFBC1, 0xE3FFFBC1, 0xE400FBC1, 0xE401FBC1, 0xE402FBC1, 0xE403FBC1, 0xE404FBC1, 0xE405FBC1, 0xE406FBC1, 0xE407FBC1, 0xE408FBC1, 0xE409FBC1, 0xE40AFBC1, 0xE40BFBC1, 0xE40CFBC1, 0xE40DFBC1, 0xE40EFBC1, 0xE40FFBC1, 0xE410FBC1, 0xE411FBC1, 0xE412FBC1, 0xE413FBC1, 0xE414FBC1, 0xE415FBC1, 0xE416FBC1, 0xE417FBC1, 0xE418FBC1, 0xE419FBC1, 0xE41AFBC1, 0xE41BFBC1, 0xE41CFBC1, 0xE41DFBC1, 0xE41EFBC1, 0xE41FFBC1, 0xE420FBC1, 0xE421FBC1, 0xE422FBC1, 0xE423FBC1, 0xE424FBC1, 0xE425FBC1, 0xE426FBC1, 0xE427FBC1, 0xE428FBC1, 0xE429FBC1, 0xE42AFBC1, 0xE42BFBC1, 0xE42CFBC1, 0xE42DFBC1, 0xE42EFBC1, 0xE42FFBC1, 0xE430FBC1, 0xE431FBC1, 0xE432FBC1, 0xE433FBC1, 0xE434FBC1, 0xE435FBC1, 0xE436FBC1, 0xE437FBC1, 0xE438FBC1, 0xE439FBC1, 0xE43AFBC1, 0xE43BFBC1, 0xE43CFBC1, 0xE43DFBC1, 0xE43EFBC1, 0xE43FFBC1, 0xE440FBC1, 0xE441FBC1, 0xE442FBC1, 0xE443FBC1, 0xE444FBC1, 0xE445FBC1, 0xE446FBC1, 0xE447FBC1, 0xE448FBC1, 0xE449FBC1, 0xE44AFBC1, 0xE44BFBC1, 0xE44CFBC1, 0xE44DFBC1, 0xE44EFBC1, 0xE44FFBC1, 0xE450FBC1, 0xE451FBC1, 0xE452FBC1, 0xE453FBC1, 0xE454FBC1, 0xE455FBC1, 0xE456FBC1, 0xE457FBC1, 0xE458FBC1, 0xE459FBC1, 0xE45AFBC1, 0xE45BFBC1, 0xE45CFBC1, 0xE45DFBC1, 0xE45EFBC1, 0xE45FFBC1, 0xE460FBC1, 0xE461FBC1, 0xE462FBC1, 0xE463FBC1, 0xE464FBC1, 0xE465FBC1, 0xE466FBC1, 0xE467FBC1, 0xE468FBC1, 0xE469FBC1, 0xE46AFBC1, 0xE46BFBC1, 0xE46CFBC1, 0xE46DFBC1, 0xE46EFBC1, 0xE46FFBC1, 0xE470FBC1, 0xE471FBC1, 0xE472FBC1, 0xE473FBC1, 0xE474FBC1, 0xE475FBC1, 0xE476FBC1, 0xE477FBC1, 0xE478FBC1, 0xE479FBC1, /* E3D0 */
+ 0xE47AFBC1, 0xE47BFBC1, 0xE47CFBC1, 0xE47DFBC1, 0xE47EFBC1, 0xE47FFBC1, 0xE480FBC1, 0xE481FBC1, 0xE482FBC1, 0xE483FBC1, 0xE484FBC1, 0xE485FBC1, 0xE486FBC1, 0xE487FBC1, 0xE488FBC1, 0xE489FBC1, 0xE48AFBC1, 0xE48BFBC1, 0xE48CFBC1, 0xE48DFBC1, 0xE48EFBC1, 0xE48FFBC1, 0xE490FBC1, 0xE491FBC1, 0xE492FBC1, 0xE493FBC1, 0xE494FBC1, 0xE495FBC1, 0xE496FBC1, 0xE497FBC1, 0xE498FBC1, 0xE499FBC1, 0xE49AFBC1, 0xE49BFBC1, 0xE49CFBC1, 0xE49DFBC1, 0xE49EFBC1, 0xE49FFBC1, 0xE4A0FBC1, 0xE4A1FBC1, 0xE4A2FBC1, 0xE4A3FBC1, 0xE4A4FBC1, 0xE4A5FBC1, 0xE4A6FBC1, 0xE4A7FBC1, 0xE4A8FBC1, 0xE4A9FBC1, 0xE4AAFBC1, 0xE4ABFBC1, 0xE4ACFBC1, 0xE4ADFBC1, 0xE4AEFBC1, 0xE4AFFBC1, 0xE4B0FBC1, 0xE4B1FBC1, 0xE4B2FBC1, 0xE4B3FBC1, 0xE4B4FBC1, 0xE4B5FBC1, 0xE4B6FBC1, 0xE4B7FBC1, 0xE4B8FBC1, 0xE4B9FBC1, 0xE4BAFBC1, 0xE4BBFBC1, 0xE4BCFBC1, 0xE4BDFBC1, 0xE4BEFBC1, 0xE4BFFBC1, 0xE4C0FBC1, 0xE4C1FBC1, 0xE4C2FBC1, 0xE4C3FBC1, 0xE4C4FBC1, 0xE4C5FBC1, 0xE4C6FBC1, 0xE4C7FBC1, 0xE4C8FBC1, 0xE4C9FBC1, 0xE4CAFBC1, 0xE4CBFBC1, 0xE4CCFBC1, 0xE4CDFBC1, 0xE4CEFBC1, 0xE4CFFBC1, 0xE4D0FBC1, 0xE4D1FBC1, 0xE4D2FBC1, 0xE4D3FBC1, 0xE4D4FBC1, 0xE4D5FBC1, 0xE4D6FBC1, 0xE4D7FBC1, 0xE4D8FBC1, 0xE4D9FBC1, 0xE4DAFBC1, 0xE4DBFBC1, 0xE4DCFBC1, 0xE4DDFBC1, 0xE4DEFBC1, 0xE4DFFBC1, 0xE4E0FBC1, 0xE4E1FBC1, 0xE4E2FBC1, 0xE4E3FBC1, 0xE4E4FBC1, 0xE4E5FBC1, 0xE4E6FBC1, 0xE4E7FBC1, 0xE4E8FBC1, 0xE4E9FBC1, 0xE4EAFBC1, 0xE4EBFBC1, 0xE4ECFBC1, 0xE4EDFBC1, 0xE4EEFBC1, 0xE4EFFBC1, 0xE4F0FBC1, 0xE4F1FBC1, 0xE4F2FBC1, 0xE4F3FBC1, 0xE4F4FBC1, 0xE4F5FBC1, 0xE4F6FBC1, 0xE4F7FBC1, 0xE4F8FBC1, 0xE4F9FBC1, 0xE4FAFBC1, 0xE4FBFBC1, 0xE4FCFBC1, 0xE4FDFBC1, 0xE4FEFBC1, 0xE4FFFBC1, 0xE500FBC1, 0xE501FBC1, 0xE502FBC1, 0xE503FBC1, 0xE504FBC1, 0xE505FBC1, 0xE506FBC1, 0xE507FBC1, 0xE508FBC1, 0xE509FBC1, 0xE50AFBC1, 0xE50BFBC1, 0xE50CFBC1, 0xE50DFBC1, 0xE50EFBC1, 0xE50FFBC1, 0xE510FBC1, 0xE511FBC1, 0xE512FBC1, 0xE513FBC1, 0xE514FBC1, 0xE515FBC1, 0xE516FBC1, 0xE517FBC1, 0xE518FBC1, 0xE519FBC1, 0xE51AFBC1, 0xE51BFBC1, 0xE51CFBC1, 0xE51DFBC1, 0xE51EFBC1, 0xE51FFBC1, 0xE520FBC1, 0xE521FBC1, 0xE522FBC1, 0xE523FBC1, /* E47A */
+ 0xE524FBC1, 0xE525FBC1, 0xE526FBC1, 0xE527FBC1, 0xE528FBC1, 0xE529FBC1, 0xE52AFBC1, 0xE52BFBC1, 0xE52CFBC1, 0xE52DFBC1, 0xE52EFBC1, 0xE52FFBC1, 0xE530FBC1, 0xE531FBC1, 0xE532FBC1, 0xE533FBC1, 0xE534FBC1, 0xE535FBC1, 0xE536FBC1, 0xE537FBC1, 0xE538FBC1, 0xE539FBC1, 0xE53AFBC1, 0xE53BFBC1, 0xE53CFBC1, 0xE53DFBC1, 0xE53EFBC1, 0xE53FFBC1, 0xE540FBC1, 0xE541FBC1, 0xE542FBC1, 0xE543FBC1, 0xE544FBC1, 0xE545FBC1, 0xE546FBC1, 0xE547FBC1, 0xE548FBC1, 0xE549FBC1, 0xE54AFBC1, 0xE54BFBC1, 0xE54CFBC1, 0xE54DFBC1, 0xE54EFBC1, 0xE54FFBC1, 0xE550FBC1, 0xE551FBC1, 0xE552FBC1, 0xE553FBC1, 0xE554FBC1, 0xE555FBC1, 0xE556FBC1, 0xE557FBC1, 0xE558FBC1, 0xE559FBC1, 0xE55AFBC1, 0xE55BFBC1, 0xE55CFBC1, 0xE55DFBC1, 0xE55EFBC1, 0xE55FFBC1, 0xE560FBC1, 0xE561FBC1, 0xE562FBC1, 0xE563FBC1, 0xE564FBC1, 0xE565FBC1, 0xE566FBC1, 0xE567FBC1, 0xE568FBC1, 0xE569FBC1, 0xE56AFBC1, 0xE56BFBC1, 0xE56CFBC1, 0xE56DFBC1, 0xE56EFBC1, 0xE56FFBC1, 0xE570FBC1, 0xE571FBC1, 0xE572FBC1, 0xE573FBC1, 0xE574FBC1, 0xE575FBC1, 0xE576FBC1, 0xE577FBC1, 0xE578FBC1, 0xE579FBC1, 0xE57AFBC1, 0xE57BFBC1, 0xE57CFBC1, 0xE57DFBC1, 0xE57EFBC1, 0xE57FFBC1, 0xE580FBC1, 0xE581FBC1, 0xE582FBC1, 0xE583FBC1, 0xE584FBC1, 0xE585FBC1, 0xE586FBC1, 0xE587FBC1, 0xE588FBC1, 0xE589FBC1, 0xE58AFBC1, 0xE58BFBC1, 0xE58CFBC1, 0xE58DFBC1, 0xE58EFBC1, 0xE58FFBC1, 0xE590FBC1, 0xE591FBC1, 0xE592FBC1, 0xE593FBC1, 0xE594FBC1, 0xE595FBC1, 0xE596FBC1, 0xE597FBC1, 0xE598FBC1, 0xE599FBC1, 0xE59AFBC1, 0xE59BFBC1, 0xE59CFBC1, 0xE59DFBC1, 0xE59EFBC1, 0xE59FFBC1, 0xE5A0FBC1, 0xE5A1FBC1, 0xE5A2FBC1, 0xE5A3FBC1, 0xE5A4FBC1, 0xE5A5FBC1, 0xE5A6FBC1, 0xE5A7FBC1, 0xE5A8FBC1, 0xE5A9FBC1, 0xE5AAFBC1, 0xE5ABFBC1, 0xE5ACFBC1, 0xE5ADFBC1, 0xE5AEFBC1, 0xE5AFFBC1, 0xE5B0FBC1, 0xE5B1FBC1, 0xE5B2FBC1, 0xE5B3FBC1, 0xE5B4FBC1, 0xE5B5FBC1, 0xE5B6FBC1, 0xE5B7FBC1, 0xE5B8FBC1, 0xE5B9FBC1, 0xE5BAFBC1, 0xE5BBFBC1, 0xE5BCFBC1, 0xE5BDFBC1, 0xE5BEFBC1, 0xE5BFFBC1, 0xE5C0FBC1, 0xE5C1FBC1, 0xE5C2FBC1, 0xE5C3FBC1, 0xE5C4FBC1, 0xE5C5FBC1, 0xE5C6FBC1, 0xE5C7FBC1, 0xE5C8FBC1, 0xE5C9FBC1, 0xE5CAFBC1, 0xE5CBFBC1, 0xE5CCFBC1, 0xE5CDFBC1, /* E524 */
+ 0xE5CEFBC1, 0xE5CFFBC1, 0xE5D0FBC1, 0xE5D1FBC1, 0xE5D2FBC1, 0xE5D3FBC1, 0xE5D4FBC1, 0xE5D5FBC1, 0xE5D6FBC1, 0xE5D7FBC1, 0xE5D8FBC1, 0xE5D9FBC1, 0xE5DAFBC1, 0xE5DBFBC1, 0xE5DCFBC1, 0xE5DDFBC1, 0xE5DEFBC1, 0xE5DFFBC1, 0xE5E0FBC1, 0xE5E1FBC1, 0xE5E2FBC1, 0xE5E3FBC1, 0xE5E4FBC1, 0xE5E5FBC1, 0xE5E6FBC1, 0xE5E7FBC1, 0xE5E8FBC1, 0xE5E9FBC1, 0xE5EAFBC1, 0xE5EBFBC1, 0xE5ECFBC1, 0xE5EDFBC1, 0xE5EEFBC1, 0xE5EFFBC1, 0xE5F0FBC1, 0xE5F1FBC1, 0xE5F2FBC1, 0xE5F3FBC1, 0xE5F4FBC1, 0xE5F5FBC1, 0xE5F6FBC1, 0xE5F7FBC1, 0xE5F8FBC1, 0xE5F9FBC1, 0xE5FAFBC1, 0xE5FBFBC1, 0xE5FCFBC1, 0xE5FDFBC1, 0xE5FEFBC1, 0xE5FFFBC1, 0xE600FBC1, 0xE601FBC1, 0xE602FBC1, 0xE603FBC1, 0xE604FBC1, 0xE605FBC1, 0xE606FBC1, 0xE607FBC1, 0xE608FBC1, 0xE609FBC1, 0xE60AFBC1, 0xE60BFBC1, 0xE60CFBC1, 0xE60DFBC1, 0xE60EFBC1, 0xE60FFBC1, 0xE610FBC1, 0xE611FBC1, 0xE612FBC1, 0xE613FBC1, 0xE614FBC1, 0xE615FBC1, 0xE616FBC1, 0xE617FBC1, 0xE618FBC1, 0xE619FBC1, 0xE61AFBC1, 0xE61BFBC1, 0xE61CFBC1, 0xE61DFBC1, 0xE61EFBC1, 0xE61FFBC1, 0xE620FBC1, 0xE621FBC1, 0xE622FBC1, 0xE623FBC1, 0xE624FBC1, 0xE625FBC1, 0xE626FBC1, 0xE627FBC1, 0xE628FBC1, 0xE629FBC1, 0xE62AFBC1, 0xE62BFBC1, 0xE62CFBC1, 0xE62DFBC1, 0xE62EFBC1, 0xE62FFBC1, 0xE630FBC1, 0xE631FBC1, 0xE632FBC1, 0xE633FBC1, 0xE634FBC1, 0xE635FBC1, 0xE636FBC1, 0xE637FBC1, 0xE638FBC1, 0xE639FBC1, 0xE63AFBC1, 0xE63BFBC1, 0xE63CFBC1, 0xE63DFBC1, 0xE63EFBC1, 0xE63FFBC1, 0xE640FBC1, 0xE641FBC1, 0xE642FBC1, 0xE643FBC1, 0xE644FBC1, 0xE645FBC1, 0xE646FBC1, 0xE647FBC1, 0xE648FBC1, 0xE649FBC1, 0xE64AFBC1, 0xE64BFBC1, 0xE64CFBC1, 0xE64DFBC1, 0xE64EFBC1, 0xE64FFBC1, 0xE650FBC1, 0xE651FBC1, 0xE652FBC1, 0xE653FBC1, 0xE654FBC1, 0xE655FBC1, 0xE656FBC1, 0xE657FBC1, 0xE658FBC1, 0xE659FBC1, 0xE65AFBC1, 0xE65BFBC1, 0xE65CFBC1, 0xE65DFBC1, 0xE65EFBC1, 0xE65FFBC1, 0xE660FBC1, 0xE661FBC1, 0xE662FBC1, 0xE663FBC1, 0xE664FBC1, 0xE665FBC1, 0xE666FBC1, 0xE667FBC1, 0xE668FBC1, 0xE669FBC1, 0xE66AFBC1, 0xE66BFBC1, 0xE66CFBC1, 0xE66DFBC1, 0xE66EFBC1, 0xE66FFBC1, 0xE670FBC1, 0xE671FBC1, 0xE672FBC1, 0xE673FBC1, 0xE674FBC1, 0xE675FBC1, 0xE676FBC1, 0xE677FBC1, /* E5CE */
+ 0xE678FBC1, 0xE679FBC1, 0xE67AFBC1, 0xE67BFBC1, 0xE67CFBC1, 0xE67DFBC1, 0xE67EFBC1, 0xE67FFBC1, 0xE680FBC1, 0xE681FBC1, 0xE682FBC1, 0xE683FBC1, 0xE684FBC1, 0xE685FBC1, 0xE686FBC1, 0xE687FBC1, 0xE688FBC1, 0xE689FBC1, 0xE68AFBC1, 0xE68BFBC1, 0xE68CFBC1, 0xE68DFBC1, 0xE68EFBC1, 0xE68FFBC1, 0xE690FBC1, 0xE691FBC1, 0xE692FBC1, 0xE693FBC1, 0xE694FBC1, 0xE695FBC1, 0xE696FBC1, 0xE697FBC1, 0xE698FBC1, 0xE699FBC1, 0xE69AFBC1, 0xE69BFBC1, 0xE69CFBC1, 0xE69DFBC1, 0xE69EFBC1, 0xE69FFBC1, 0xE6A0FBC1, 0xE6A1FBC1, 0xE6A2FBC1, 0xE6A3FBC1, 0xE6A4FBC1, 0xE6A5FBC1, 0xE6A6FBC1, 0xE6A7FBC1, 0xE6A8FBC1, 0xE6A9FBC1, 0xE6AAFBC1, 0xE6ABFBC1, 0xE6ACFBC1, 0xE6ADFBC1, 0xE6AEFBC1, 0xE6AFFBC1, 0xE6B0FBC1, 0xE6B1FBC1, 0xE6B2FBC1, 0xE6B3FBC1, 0xE6B4FBC1, 0xE6B5FBC1, 0xE6B6FBC1, 0xE6B7FBC1, 0xE6B8FBC1, 0xE6B9FBC1, 0xE6BAFBC1, 0xE6BBFBC1, 0xE6BCFBC1, 0xE6BDFBC1, 0xE6BEFBC1, 0xE6BFFBC1, 0xE6C0FBC1, 0xE6C1FBC1, 0xE6C2FBC1, 0xE6C3FBC1, 0xE6C4FBC1, 0xE6C5FBC1, 0xE6C6FBC1, 0xE6C7FBC1, 0xE6C8FBC1, 0xE6C9FBC1, 0xE6CAFBC1, 0xE6CBFBC1, 0xE6CCFBC1, 0xE6CDFBC1, 0xE6CEFBC1, 0xE6CFFBC1, 0xE6D0FBC1, 0xE6D1FBC1, 0xE6D2FBC1, 0xE6D3FBC1, 0xE6D4FBC1, 0xE6D5FBC1, 0xE6D6FBC1, 0xE6D7FBC1, 0xE6D8FBC1, 0xE6D9FBC1, 0xE6DAFBC1, 0xE6DBFBC1, 0xE6DCFBC1, 0xE6DDFBC1, 0xE6DEFBC1, 0xE6DFFBC1, 0xE6E0FBC1, 0xE6E1FBC1, 0xE6E2FBC1, 0xE6E3FBC1, 0xE6E4FBC1, 0xE6E5FBC1, 0xE6E6FBC1, 0xE6E7FBC1, 0xE6E8FBC1, 0xE6E9FBC1, 0xE6EAFBC1, 0xE6EBFBC1, 0xE6ECFBC1, 0xE6EDFBC1, 0xE6EEFBC1, 0xE6EFFBC1, 0xE6F0FBC1, 0xE6F1FBC1, 0xE6F2FBC1, 0xE6F3FBC1, 0xE6F4FBC1, 0xE6F5FBC1, 0xE6F6FBC1, 0xE6F7FBC1, 0xE6F8FBC1, 0xE6F9FBC1, 0xE6FAFBC1, 0xE6FBFBC1, 0xE6FCFBC1, 0xE6FDFBC1, 0xE6FEFBC1, 0xE6FFFBC1, 0xE700FBC1, 0xE701FBC1, 0xE702FBC1, 0xE703FBC1, 0xE704FBC1, 0xE705FBC1, 0xE706FBC1, 0xE707FBC1, 0xE708FBC1, 0xE709FBC1, 0xE70AFBC1, 0xE70BFBC1, 0xE70CFBC1, 0xE70DFBC1, 0xE70EFBC1, 0xE70FFBC1, 0xE710FBC1, 0xE711FBC1, 0xE712FBC1, 0xE713FBC1, 0xE714FBC1, 0xE715FBC1, 0xE716FBC1, 0xE717FBC1, 0xE718FBC1, 0xE719FBC1, 0xE71AFBC1, 0xE71BFBC1, 0xE71CFBC1, 0xE71DFBC1, 0xE71EFBC1, 0xE71FFBC1, 0xE720FBC1, 0xE721FBC1, /* E678 */
+ 0xE722FBC1, 0xE723FBC1, 0xE724FBC1, 0xE725FBC1, 0xE726FBC1, 0xE727FBC1, 0xE728FBC1, 0xE729FBC1, 0xE72AFBC1, 0xE72BFBC1, 0xE72CFBC1, 0xE72DFBC1, 0xE72EFBC1, 0xE72FFBC1, 0xE730FBC1, 0xE731FBC1, 0xE732FBC1, 0xE733FBC1, 0xE734FBC1, 0xE735FBC1, 0xE736FBC1, 0xE737FBC1, 0xE738FBC1, 0xE739FBC1, 0xE73AFBC1, 0xE73BFBC1, 0xE73CFBC1, 0xE73DFBC1, 0xE73EFBC1, 0xE73FFBC1, 0xE740FBC1, 0xE741FBC1, 0xE742FBC1, 0xE743FBC1, 0xE744FBC1, 0xE745FBC1, 0xE746FBC1, 0xE747FBC1, 0xE748FBC1, 0xE749FBC1, 0xE74AFBC1, 0xE74BFBC1, 0xE74CFBC1, 0xE74DFBC1, 0xE74EFBC1, 0xE74FFBC1, 0xE750FBC1, 0xE751FBC1, 0xE752FBC1, 0xE753FBC1, 0xE754FBC1, 0xE755FBC1, 0xE756FBC1, 0xE757FBC1, 0xE758FBC1, 0xE759FBC1, 0xE75AFBC1, 0xE75BFBC1, 0xE75CFBC1, 0xE75DFBC1, 0xE75EFBC1, 0xE75FFBC1, 0xE760FBC1, 0xE761FBC1, 0xE762FBC1, 0xE763FBC1, 0xE764FBC1, 0xE765FBC1, 0xE766FBC1, 0xE767FBC1, 0xE768FBC1, 0xE769FBC1, 0xE76AFBC1, 0xE76BFBC1, 0xE76CFBC1, 0xE76DFBC1, 0xE76EFBC1, 0xE76FFBC1, 0xE770FBC1, 0xE771FBC1, 0xE772FBC1, 0xE773FBC1, 0xE774FBC1, 0xE775FBC1, 0xE776FBC1, 0xE777FBC1, 0xE778FBC1, 0xE779FBC1, 0xE77AFBC1, 0xE77BFBC1, 0xE77CFBC1, 0xE77DFBC1, 0xE77EFBC1, 0xE77FFBC1, 0xE780FBC1, 0xE781FBC1, 0xE782FBC1, 0xE783FBC1, 0xE784FBC1, 0xE785FBC1, 0xE786FBC1, 0xE787FBC1, 0xE788FBC1, 0xE789FBC1, 0xE78AFBC1, 0xE78BFBC1, 0xE78CFBC1, 0xE78DFBC1, 0xE78EFBC1, 0xE78FFBC1, 0xE790FBC1, 0xE791FBC1, 0xE792FBC1, 0xE793FBC1, 0xE794FBC1, 0xE795FBC1, 0xE796FBC1, 0xE797FBC1, 0xE798FBC1, 0xE799FBC1, 0xE79AFBC1, 0xE79BFBC1, 0xE79CFBC1, 0xE79DFBC1, 0xE79EFBC1, 0xE79FFBC1, 0xE7A0FBC1, 0xE7A1FBC1, 0xE7A2FBC1, 0xE7A3FBC1, 0xE7A4FBC1, 0xE7A5FBC1, 0xE7A6FBC1, 0xE7A7FBC1, 0xE7A8FBC1, 0xE7A9FBC1, 0xE7AAFBC1, 0xE7ABFBC1, 0xE7ACFBC1, 0xE7ADFBC1, 0xE7AEFBC1, 0xE7AFFBC1, 0xE7B0FBC1, 0xE7B1FBC1, 0xE7B2FBC1, 0xE7B3FBC1, 0xE7B4FBC1, 0xE7B5FBC1, 0xE7B6FBC1, 0xE7B7FBC1, 0xE7B8FBC1, 0xE7B9FBC1, 0xE7BAFBC1, 0xE7BBFBC1, 0xE7BCFBC1, 0xE7BDFBC1, 0xE7BEFBC1, 0xE7BFFBC1, 0xE7C0FBC1, 0xE7C1FBC1, 0xE7C2FBC1, 0xE7C3FBC1, 0xE7C4FBC1, 0xE7C5FBC1, 0xE7C6FBC1, 0xE7C7FBC1, 0xE7C8FBC1, 0xE7C9FBC1, 0xE7CAFBC1, 0xE7CBFBC1, /* E722 */
+ 0xE7CCFBC1, 0xE7CDFBC1, 0xE7CEFBC1, 0xE7CFFBC1, 0xE7D0FBC1, 0xE7D1FBC1, 0xE7D2FBC1, 0xE7D3FBC1, 0xE7D4FBC1, 0xE7D5FBC1, 0xE7D6FBC1, 0xE7D7FBC1, 0xE7D8FBC1, 0xE7D9FBC1, 0xE7DAFBC1, 0xE7DBFBC1, 0xE7DCFBC1, 0xE7DDFBC1, 0xE7DEFBC1, 0xE7DFFBC1, 0xE7E0FBC1, 0xE7E1FBC1, 0xE7E2FBC1, 0xE7E3FBC1, 0xE7E4FBC1, 0xE7E5FBC1, 0xE7E6FBC1, 0xE7E7FBC1, 0xE7E8FBC1, 0xE7E9FBC1, 0xE7EAFBC1, 0xE7EBFBC1, 0xE7ECFBC1, 0xE7EDFBC1, 0xE7EEFBC1, 0xE7EFFBC1, 0xE7F0FBC1, 0xE7F1FBC1, 0xE7F2FBC1, 0xE7F3FBC1, 0xE7F4FBC1, 0xE7F5FBC1, 0xE7F6FBC1, 0xE7F7FBC1, 0xE7F8FBC1, 0xE7F9FBC1, 0xE7FAFBC1, 0xE7FBFBC1, 0xE7FCFBC1, 0xE7FDFBC1, 0xE7FEFBC1, 0xE7FFFBC1, 0xE800FBC1, 0xE801FBC1, 0xE802FBC1, 0xE803FBC1, 0xE804FBC1, 0xE805FBC1, 0xE806FBC1, 0xE807FBC1, 0xE808FBC1, 0xE809FBC1, 0xE80AFBC1, 0xE80BFBC1, 0xE80CFBC1, 0xE80DFBC1, 0xE80EFBC1, 0xE80FFBC1, 0xE810FBC1, 0xE811FBC1, 0xE812FBC1, 0xE813FBC1, 0xE814FBC1, 0xE815FBC1, 0xE816FBC1, 0xE817FBC1, 0xE818FBC1, 0xE819FBC1, 0xE81AFBC1, 0xE81BFBC1, 0xE81CFBC1, 0xE81DFBC1, 0xE81EFBC1, 0xE81FFBC1, 0xE820FBC1, 0xE821FBC1, 0xE822FBC1, 0xE823FBC1, 0xE824FBC1, 0xE825FBC1, 0xE826FBC1, 0xE827FBC1, 0xE828FBC1, 0xE829FBC1, 0xE82AFBC1, 0xE82BFBC1, 0xE82CFBC1, 0xE82DFBC1, 0xE82EFBC1, 0xE82FFBC1, 0xE830FBC1, 0xE831FBC1, 0xE832FBC1, 0xE833FBC1, 0xE834FBC1, 0xE835FBC1, 0xE836FBC1, 0xE837FBC1, 0xE838FBC1, 0xE839FBC1, 0xE83AFBC1, 0xE83BFBC1, 0xE83CFBC1, 0xE83DFBC1, 0xE83EFBC1, 0xE83FFBC1, 0xE840FBC1, 0xE841FBC1, 0xE842FBC1, 0xE843FBC1, 0xE844FBC1, 0xE845FBC1, 0xE846FBC1, 0xE847FBC1, 0xE848FBC1, 0xE849FBC1, 0xE84AFBC1, 0xE84BFBC1, 0xE84CFBC1, 0xE84DFBC1, 0xE84EFBC1, 0xE84FFBC1, 0xE850FBC1, 0xE851FBC1, 0xE852FBC1, 0xE853FBC1, 0xE854FBC1, 0xE855FBC1, 0xE856FBC1, 0xE857FBC1, 0xE858FBC1, 0xE859FBC1, 0xE85AFBC1, 0xE85BFBC1, 0xE85CFBC1, 0xE85DFBC1, 0xE85EFBC1, 0xE85FFBC1, 0xE860FBC1, 0xE861FBC1, 0xE862FBC1, 0xE863FBC1, 0xE864FBC1, 0xE865FBC1, 0xE866FBC1, 0xE867FBC1, 0xE868FBC1, 0xE869FBC1, 0xE86AFBC1, 0xE86BFBC1, 0xE86CFBC1, 0xE86DFBC1, 0xE86EFBC1, 0xE86FFBC1, 0xE870FBC1, 0xE871FBC1, 0xE872FBC1, 0xE873FBC1, 0xE874FBC1, 0xE875FBC1, /* E7CC */
+ 0xE876FBC1, 0xE877FBC1, 0xE878FBC1, 0xE879FBC1, 0xE87AFBC1, 0xE87BFBC1, 0xE87CFBC1, 0xE87DFBC1, 0xE87EFBC1, 0xE87FFBC1, 0xE880FBC1, 0xE881FBC1, 0xE882FBC1, 0xE883FBC1, 0xE884FBC1, 0xE885FBC1, 0xE886FBC1, 0xE887FBC1, 0xE888FBC1, 0xE889FBC1, 0xE88AFBC1, 0xE88BFBC1, 0xE88CFBC1, 0xE88DFBC1, 0xE88EFBC1, 0xE88FFBC1, 0xE890FBC1, 0xE891FBC1, 0xE892FBC1, 0xE893FBC1, 0xE894FBC1, 0xE895FBC1, 0xE896FBC1, 0xE897FBC1, 0xE898FBC1, 0xE899FBC1, 0xE89AFBC1, 0xE89BFBC1, 0xE89CFBC1, 0xE89DFBC1, 0xE89EFBC1, 0xE89FFBC1, 0xE8A0FBC1, 0xE8A1FBC1, 0xE8A2FBC1, 0xE8A3FBC1, 0xE8A4FBC1, 0xE8A5FBC1, 0xE8A6FBC1, 0xE8A7FBC1, 0xE8A8FBC1, 0xE8A9FBC1, 0xE8AAFBC1, 0xE8ABFBC1, 0xE8ACFBC1, 0xE8ADFBC1, 0xE8AEFBC1, 0xE8AFFBC1, 0xE8B0FBC1, 0xE8B1FBC1, 0xE8B2FBC1, 0xE8B3FBC1, 0xE8B4FBC1, 0xE8B5FBC1, 0xE8B6FBC1, 0xE8B7FBC1, 0xE8B8FBC1, 0xE8B9FBC1, 0xE8BAFBC1, 0xE8BBFBC1, 0xE8BCFBC1, 0xE8BDFBC1, 0xE8BEFBC1, 0xE8BFFBC1, 0xE8C0FBC1, 0xE8C1FBC1, 0xE8C2FBC1, 0xE8C3FBC1, 0xE8C4FBC1, 0xE8C5FBC1, 0xE8C6FBC1, 0xE8C7FBC1, 0xE8C8FBC1, 0xE8C9FBC1, 0xE8CAFBC1, 0xE8CBFBC1, 0xE8CCFBC1, 0xE8CDFBC1, 0xE8CEFBC1, 0xE8CFFBC1, 0xE8D0FBC1, 0xE8D1FBC1, 0xE8D2FBC1, 0xE8D3FBC1, 0xE8D4FBC1, 0xE8D5FBC1, 0xE8D6FBC1, 0xE8D7FBC1, 0xE8D8FBC1, 0xE8D9FBC1, 0xE8DAFBC1, 0xE8DBFBC1, 0xE8DCFBC1, 0xE8DDFBC1, 0xE8DEFBC1, 0xE8DFFBC1, 0xE8E0FBC1, 0xE8E1FBC1, 0xE8E2FBC1, 0xE8E3FBC1, 0xE8E4FBC1, 0xE8E5FBC1, 0xE8E6FBC1, 0xE8E7FBC1, 0xE8E8FBC1, 0xE8E9FBC1, 0xE8EAFBC1, 0xE8EBFBC1, 0xE8ECFBC1, 0xE8EDFBC1, 0xE8EEFBC1, 0xE8EFFBC1, 0xE8F0FBC1, 0xE8F1FBC1, 0xE8F2FBC1, 0xE8F3FBC1, 0xE8F4FBC1, 0xE8F5FBC1, 0xE8F6FBC1, 0xE8F7FBC1, 0xE8F8FBC1, 0xE8F9FBC1, 0xE8FAFBC1, 0xE8FBFBC1, 0xE8FCFBC1, 0xE8FDFBC1, 0xE8FEFBC1, 0xE8FFFBC1, 0xE900FBC1, 0xE901FBC1, 0xE902FBC1, 0xE903FBC1, 0xE904FBC1, 0xE905FBC1, 0xE906FBC1, 0xE907FBC1, 0xE908FBC1, 0xE909FBC1, 0xE90AFBC1, 0xE90BFBC1, 0xE90CFBC1, 0xE90DFBC1, 0xE90EFBC1, 0xE90FFBC1, 0xE910FBC1, 0xE911FBC1, 0xE912FBC1, 0xE913FBC1, 0xE914FBC1, 0xE915FBC1, 0xE916FBC1, 0xE917FBC1, 0xE918FBC1, 0xE919FBC1, 0xE91AFBC1, 0xE91BFBC1, 0xE91CFBC1, 0xE91DFBC1, 0xE91EFBC1, 0xE91FFBC1, /* E876 */
+ 0xE920FBC1, 0xE921FBC1, 0xE922FBC1, 0xE923FBC1, 0xE924FBC1, 0xE925FBC1, 0xE926FBC1, 0xE927FBC1, 0xE928FBC1, 0xE929FBC1, 0xE92AFBC1, 0xE92BFBC1, 0xE92CFBC1, 0xE92DFBC1, 0xE92EFBC1, 0xE92FFBC1, 0xE930FBC1, 0xE931FBC1, 0xE932FBC1, 0xE933FBC1, 0xE934FBC1, 0xE935FBC1, 0xE936FBC1, 0xE937FBC1, 0xE938FBC1, 0xE939FBC1, 0xE93AFBC1, 0xE93BFBC1, 0xE93CFBC1, 0xE93DFBC1, 0xE93EFBC1, 0xE93FFBC1, 0xE940FBC1, 0xE941FBC1, 0xE942FBC1, 0xE943FBC1, 0xE944FBC1, 0xE945FBC1, 0xE946FBC1, 0xE947FBC1, 0xE948FBC1, 0xE949FBC1, 0xE94AFBC1, 0xE94BFBC1, 0xE94CFBC1, 0xE94DFBC1, 0xE94EFBC1, 0xE94FFBC1, 0xE950FBC1, 0xE951FBC1, 0xE952FBC1, 0xE953FBC1, 0xE954FBC1, 0xE955FBC1, 0xE956FBC1, 0xE957FBC1, 0xE958FBC1, 0xE959FBC1, 0xE95AFBC1, 0xE95BFBC1, 0xE95CFBC1, 0xE95DFBC1, 0xE95EFBC1, 0xE95FFBC1, 0xE960FBC1, 0xE961FBC1, 0xE962FBC1, 0xE963FBC1, 0xE964FBC1, 0xE965FBC1, 0xE966FBC1, 0xE967FBC1, 0xE968FBC1, 0xE969FBC1, 0xE96AFBC1, 0xE96BFBC1, 0xE96CFBC1, 0xE96DFBC1, 0xE96EFBC1, 0xE96FFBC1, 0xE970FBC1, 0xE971FBC1, 0xE972FBC1, 0xE973FBC1, 0xE974FBC1, 0xE975FBC1, 0xE976FBC1, 0xE977FBC1, 0xE978FBC1, 0xE979FBC1, 0xE97AFBC1, 0xE97BFBC1, 0xE97CFBC1, 0xE97DFBC1, 0xE97EFBC1, 0xE97FFBC1, 0xE980FBC1, 0xE981FBC1, 0xE982FBC1, 0xE983FBC1, 0xE984FBC1, 0xE985FBC1, 0xE986FBC1, 0xE987FBC1, 0xE988FBC1, 0xE989FBC1, 0xE98AFBC1, 0xE98BFBC1, 0xE98CFBC1, 0xE98DFBC1, 0xE98EFBC1, 0xE98FFBC1, 0xE990FBC1, 0xE991FBC1, 0xE992FBC1, 0xE993FBC1, 0xE994FBC1, 0xE995FBC1, 0xE996FBC1, 0xE997FBC1, 0xE998FBC1, 0xE999FBC1, 0xE99AFBC1, 0xE99BFBC1, 0xE99CFBC1, 0xE99DFBC1, 0xE99EFBC1, 0xE99FFBC1, 0xE9A0FBC1, 0xE9A1FBC1, 0xE9A2FBC1, 0xE9A3FBC1, 0xE9A4FBC1, 0xE9A5FBC1, 0xE9A6FBC1, 0xE9A7FBC1, 0xE9A8FBC1, 0xE9A9FBC1, 0xE9AAFBC1, 0xE9ABFBC1, 0xE9ACFBC1, 0xE9ADFBC1, 0xE9AEFBC1, 0xE9AFFBC1, 0xE9B0FBC1, 0xE9B1FBC1, 0xE9B2FBC1, 0xE9B3FBC1, 0xE9B4FBC1, 0xE9B5FBC1, 0xE9B6FBC1, 0xE9B7FBC1, 0xE9B8FBC1, 0xE9B9FBC1, 0xE9BAFBC1, 0xE9BBFBC1, 0xE9BCFBC1, 0xE9BDFBC1, 0xE9BEFBC1, 0xE9BFFBC1, 0xE9C0FBC1, 0xE9C1FBC1, 0xE9C2FBC1, 0xE9C3FBC1, 0xE9C4FBC1, 0xE9C5FBC1, 0xE9C6FBC1, 0xE9C7FBC1, 0xE9C8FBC1, 0xE9C9FBC1, /* E920 */
+ 0xE9CAFBC1, 0xE9CBFBC1, 0xE9CCFBC1, 0xE9CDFBC1, 0xE9CEFBC1, 0xE9CFFBC1, 0xE9D0FBC1, 0xE9D1FBC1, 0xE9D2FBC1, 0xE9D3FBC1, 0xE9D4FBC1, 0xE9D5FBC1, 0xE9D6FBC1, 0xE9D7FBC1, 0xE9D8FBC1, 0xE9D9FBC1, 0xE9DAFBC1, 0xE9DBFBC1, 0xE9DCFBC1, 0xE9DDFBC1, 0xE9DEFBC1, 0xE9DFFBC1, 0xE9E0FBC1, 0xE9E1FBC1, 0xE9E2FBC1, 0xE9E3FBC1, 0xE9E4FBC1, 0xE9E5FBC1, 0xE9E6FBC1, 0xE9E7FBC1, 0xE9E8FBC1, 0xE9E9FBC1, 0xE9EAFBC1, 0xE9EBFBC1, 0xE9ECFBC1, 0xE9EDFBC1, 0xE9EEFBC1, 0xE9EFFBC1, 0xE9F0FBC1, 0xE9F1FBC1, 0xE9F2FBC1, 0xE9F3FBC1, 0xE9F4FBC1, 0xE9F5FBC1, 0xE9F6FBC1, 0xE9F7FBC1, 0xE9F8FBC1, 0xE9F9FBC1, 0xE9FAFBC1, 0xE9FBFBC1, 0xE9FCFBC1, 0xE9FDFBC1, 0xE9FEFBC1, 0xE9FFFBC1, 0xEA00FBC1, 0xEA01FBC1, 0xEA02FBC1, 0xEA03FBC1, 0xEA04FBC1, 0xEA05FBC1, 0xEA06FBC1, 0xEA07FBC1, 0xEA08FBC1, 0xEA09FBC1, 0xEA0AFBC1, 0xEA0BFBC1, 0xEA0CFBC1, 0xEA0DFBC1, 0xEA0EFBC1, 0xEA0FFBC1, 0xEA10FBC1, 0xEA11FBC1, 0xEA12FBC1, 0xEA13FBC1, 0xEA14FBC1, 0xEA15FBC1, 0xEA16FBC1, 0xEA17FBC1, 0xEA18FBC1, 0xEA19FBC1, 0xEA1AFBC1, 0xEA1BFBC1, 0xEA1CFBC1, 0xEA1DFBC1, 0xEA1EFBC1, 0xEA1FFBC1, 0xEA20FBC1, 0xEA21FBC1, 0xEA22FBC1, 0xEA23FBC1, 0xEA24FBC1, 0xEA25FBC1, 0xEA26FBC1, 0xEA27FBC1, 0xEA28FBC1, 0xEA29FBC1, 0xEA2AFBC1, 0xEA2BFBC1, 0xEA2CFBC1, 0xEA2DFBC1, 0xEA2EFBC1, 0xEA2FFBC1, 0xEA30FBC1, 0xEA31FBC1, 0xEA32FBC1, 0xEA33FBC1, 0xEA34FBC1, 0xEA35FBC1, 0xEA36FBC1, 0xEA37FBC1, 0xEA38FBC1, 0xEA39FBC1, 0xEA3AFBC1, 0xEA3BFBC1, 0xEA3CFBC1, 0xEA3DFBC1, 0xEA3EFBC1, 0xEA3FFBC1, 0xEA40FBC1, 0xEA41FBC1, 0xEA42FBC1, 0xEA43FBC1, 0xEA44FBC1, 0xEA45FBC1, 0xEA46FBC1, 0xEA47FBC1, 0xEA48FBC1, 0xEA49FBC1, 0xEA4AFBC1, 0xEA4BFBC1, 0xEA4CFBC1, 0xEA4DFBC1, 0xEA4EFBC1, 0xEA4FFBC1, 0xEA50FBC1, 0xEA51FBC1, 0xEA52FBC1, 0xEA53FBC1, 0xEA54FBC1, 0xEA55FBC1, 0xEA56FBC1, 0xEA57FBC1, 0xEA58FBC1, 0xEA59FBC1, 0xEA5AFBC1, 0xEA5BFBC1, 0xEA5CFBC1, 0xEA5DFBC1, 0xEA5EFBC1, 0xEA5FFBC1, 0xEA60FBC1, 0xEA61FBC1, 0xEA62FBC1, 0xEA63FBC1, 0xEA64FBC1, 0xEA65FBC1, 0xEA66FBC1, 0xEA67FBC1, 0xEA68FBC1, 0xEA69FBC1, 0xEA6AFBC1, 0xEA6BFBC1, 0xEA6CFBC1, 0xEA6DFBC1, 0xEA6EFBC1, 0xEA6FFBC1, 0xEA70FBC1, 0xEA71FBC1, 0xEA72FBC1, 0xEA73FBC1, /* E9CA */
+ 0xEA74FBC1, 0xEA75FBC1, 0xEA76FBC1, 0xEA77FBC1, 0xEA78FBC1, 0xEA79FBC1, 0xEA7AFBC1, 0xEA7BFBC1, 0xEA7CFBC1, 0xEA7DFBC1, 0xEA7EFBC1, 0xEA7FFBC1, 0xEA80FBC1, 0xEA81FBC1, 0xEA82FBC1, 0xEA83FBC1, 0xEA84FBC1, 0xEA85FBC1, 0xEA86FBC1, 0xEA87FBC1, 0xEA88FBC1, 0xEA89FBC1, 0xEA8AFBC1, 0xEA8BFBC1, 0xEA8CFBC1, 0xEA8DFBC1, 0xEA8EFBC1, 0xEA8FFBC1, 0xEA90FBC1, 0xEA91FBC1, 0xEA92FBC1, 0xEA93FBC1, 0xEA94FBC1, 0xEA95FBC1, 0xEA96FBC1, 0xEA97FBC1, 0xEA98FBC1, 0xEA99FBC1, 0xEA9AFBC1, 0xEA9BFBC1, 0xEA9CFBC1, 0xEA9DFBC1, 0xEA9EFBC1, 0xEA9FFBC1, 0xEAA0FBC1, 0xEAA1FBC1, 0xEAA2FBC1, 0xEAA3FBC1, 0xEAA4FBC1, 0xEAA5FBC1, 0xEAA6FBC1, 0xEAA7FBC1, 0xEAA8FBC1, 0xEAA9FBC1, 0xEAAAFBC1, 0xEAABFBC1, 0xEAACFBC1, 0xEAADFBC1, 0xEAAEFBC1, 0xEAAFFBC1, 0xEAB0FBC1, 0xEAB1FBC1, 0xEAB2FBC1, 0xEAB3FBC1, 0xEAB4FBC1, 0xEAB5FBC1, 0xEAB6FBC1, 0xEAB7FBC1, 0xEAB8FBC1, 0xEAB9FBC1, 0xEABAFBC1, 0xEABBFBC1, 0xEABCFBC1, 0xEABDFBC1, 0xEABEFBC1, 0xEABFFBC1, 0xEAC0FBC1, 0xEAC1FBC1, 0xEAC2FBC1, 0xEAC3FBC1, 0xEAC4FBC1, 0xEAC5FBC1, 0xEAC6FBC1, 0xEAC7FBC1, 0xEAC8FBC1, 0xEAC9FBC1, 0xEACAFBC1, 0xEACBFBC1, 0xEACCFBC1, 0xEACDFBC1, 0xEACEFBC1, 0xEACFFBC1, 0xEAD0FBC1, 0xEAD1FBC1, 0xEAD2FBC1, 0xEAD3FBC1, 0xEAD4FBC1, 0xEAD5FBC1, 0xEAD6FBC1, 0xEAD7FBC1, 0xEAD8FBC1, 0xEAD9FBC1, 0xEADAFBC1, 0xEADBFBC1, 0xEADCFBC1, 0xEADDFBC1, 0xEADEFBC1, 0xEADFFBC1, 0xEAE0FBC1, 0xEAE1FBC1, 0xEAE2FBC1, 0xEAE3FBC1, 0xEAE4FBC1, 0xEAE5FBC1, 0xEAE6FBC1, 0xEAE7FBC1, 0xEAE8FBC1, 0xEAE9FBC1, 0xEAEAFBC1, 0xEAEBFBC1, 0xEAECFBC1, 0xEAEDFBC1, 0xEAEEFBC1, 0xEAEFFBC1, 0xEAF0FBC1, 0xEAF1FBC1, 0xEAF2FBC1, 0xEAF3FBC1, 0xEAF4FBC1, 0xEAF5FBC1, 0xEAF6FBC1, 0xEAF7FBC1, 0xEAF8FBC1, 0xEAF9FBC1, 0xEAFAFBC1, 0xEAFBFBC1, 0xEAFCFBC1, 0xEAFDFBC1, 0xEAFEFBC1, 0xEAFFFBC1, 0xEB00FBC1, 0xEB01FBC1, 0xEB02FBC1, 0xEB03FBC1, 0xEB04FBC1, 0xEB05FBC1, 0xEB06FBC1, 0xEB07FBC1, 0xEB08FBC1, 0xEB09FBC1, 0xEB0AFBC1, 0xEB0BFBC1, 0xEB0CFBC1, 0xEB0DFBC1, 0xEB0EFBC1, 0xEB0FFBC1, 0xEB10FBC1, 0xEB11FBC1, 0xEB12FBC1, 0xEB13FBC1, 0xEB14FBC1, 0xEB15FBC1, 0xEB16FBC1, 0xEB17FBC1, 0xEB18FBC1, 0xEB19FBC1, 0xEB1AFBC1, 0xEB1BFBC1, 0xEB1CFBC1, 0xEB1DFBC1, /* EA74 */
+ 0xEB1EFBC1, 0xEB1FFBC1, 0xEB20FBC1, 0xEB21FBC1, 0xEB22FBC1, 0xEB23FBC1, 0xEB24FBC1, 0xEB25FBC1, 0xEB26FBC1, 0xEB27FBC1, 0xEB28FBC1, 0xEB29FBC1, 0xEB2AFBC1, 0xEB2BFBC1, 0xEB2CFBC1, 0xEB2DFBC1, 0xEB2EFBC1, 0xEB2FFBC1, 0xEB30FBC1, 0xEB31FBC1, 0xEB32FBC1, 0xEB33FBC1, 0xEB34FBC1, 0xEB35FBC1, 0xEB36FBC1, 0xEB37FBC1, 0xEB38FBC1, 0xEB39FBC1, 0xEB3AFBC1, 0xEB3BFBC1, 0xEB3CFBC1, 0xEB3DFBC1, 0xEB3EFBC1, 0xEB3FFBC1, 0xEB40FBC1, 0xEB41FBC1, 0xEB42FBC1, 0xEB43FBC1, 0xEB44FBC1, 0xEB45FBC1, 0xEB46FBC1, 0xEB47FBC1, 0xEB48FBC1, 0xEB49FBC1, 0xEB4AFBC1, 0xEB4BFBC1, 0xEB4CFBC1, 0xEB4DFBC1, 0xEB4EFBC1, 0xEB4FFBC1, 0xEB50FBC1, 0xEB51FBC1, 0xEB52FBC1, 0xEB53FBC1, 0xEB54FBC1, 0xEB55FBC1, 0xEB56FBC1, 0xEB57FBC1, 0xEB58FBC1, 0xEB59FBC1, 0xEB5AFBC1, 0xEB5BFBC1, 0xEB5CFBC1, 0xEB5DFBC1, 0xEB5EFBC1, 0xEB5FFBC1, 0xEB60FBC1, 0xEB61FBC1, 0xEB62FBC1, 0xEB63FBC1, 0xEB64FBC1, 0xEB65FBC1, 0xEB66FBC1, 0xEB67FBC1, 0xEB68FBC1, 0xEB69FBC1, 0xEB6AFBC1, 0xEB6BFBC1, 0xEB6CFBC1, 0xEB6DFBC1, 0xEB6EFBC1, 0xEB6FFBC1, 0xEB70FBC1, 0xEB71FBC1, 0xEB72FBC1, 0xEB73FBC1, 0xEB74FBC1, 0xEB75FBC1, 0xEB76FBC1, 0xEB77FBC1, 0xEB78FBC1, 0xEB79FBC1, 0xEB7AFBC1, 0xEB7BFBC1, 0xEB7CFBC1, 0xEB7DFBC1, 0xEB7EFBC1, 0xEB7FFBC1, 0xEB80FBC1, 0xEB81FBC1, 0xEB82FBC1, 0xEB83FBC1, 0xEB84FBC1, 0xEB85FBC1, 0xEB86FBC1, 0xEB87FBC1, 0xEB88FBC1, 0xEB89FBC1, 0xEB8AFBC1, 0xEB8BFBC1, 0xEB8CFBC1, 0xEB8DFBC1, 0xEB8EFBC1, 0xEB8FFBC1, 0xEB90FBC1, 0xEB91FBC1, 0xEB92FBC1, 0xEB93FBC1, 0xEB94FBC1, 0xEB95FBC1, 0xEB96FBC1, 0xEB97FBC1, 0xEB98FBC1, 0xEB99FBC1, 0xEB9AFBC1, 0xEB9BFBC1, 0xEB9CFBC1, 0xEB9DFBC1, 0xEB9EFBC1, 0xEB9FFBC1, 0xEBA0FBC1, 0xEBA1FBC1, 0xEBA2FBC1, 0xEBA3FBC1, 0xEBA4FBC1, 0xEBA5FBC1, 0xEBA6FBC1, 0xEBA7FBC1, 0xEBA8FBC1, 0xEBA9FBC1, 0xEBAAFBC1, 0xEBABFBC1, 0xEBACFBC1, 0xEBADFBC1, 0xEBAEFBC1, 0xEBAFFBC1, 0xEBB0FBC1, 0xEBB1FBC1, 0xEBB2FBC1, 0xEBB3FBC1, 0xEBB4FBC1, 0xEBB5FBC1, 0xEBB6FBC1, 0xEBB7FBC1, 0xEBB8FBC1, 0xEBB9FBC1, 0xEBBAFBC1, 0xEBBBFBC1, 0xEBBCFBC1, 0xEBBDFBC1, 0xEBBEFBC1, 0xEBBFFBC1, 0xEBC0FBC1, 0xEBC1FBC1, 0xEBC2FBC1, 0xEBC3FBC1, 0xEBC4FBC1, 0xEBC5FBC1, 0xEBC6FBC1, 0xEBC7FBC1, /* EB1E */
+ 0xEBC8FBC1, 0xEBC9FBC1, 0xEBCAFBC1, 0xEBCBFBC1, 0xEBCCFBC1, 0xEBCDFBC1, 0xEBCEFBC1, 0xEBCFFBC1, 0xEBD0FBC1, 0xEBD1FBC1, 0xEBD2FBC1, 0xEBD3FBC1, 0xEBD4FBC1, 0xEBD5FBC1, 0xEBD6FBC1, 0xEBD7FBC1, 0xEBD8FBC1, 0xEBD9FBC1, 0xEBDAFBC1, 0xEBDBFBC1, 0xEBDCFBC1, 0xEBDDFBC1, 0xEBDEFBC1, 0xEBDFFBC1, 0xEBE0FBC1, 0xEBE1FBC1, 0xEBE2FBC1, 0xEBE3FBC1, 0xEBE4FBC1, 0xEBE5FBC1, 0xEBE6FBC1, 0xEBE7FBC1, 0xEBE8FBC1, 0xEBE9FBC1, 0xEBEAFBC1, 0xEBEBFBC1, 0xEBECFBC1, 0xEBEDFBC1, 0xEBEEFBC1, 0xEBEFFBC1, 0xEBF0FBC1, 0xEBF1FBC1, 0xEBF2FBC1, 0xEBF3FBC1, 0xEBF4FBC1, 0xEBF5FBC1, 0xEBF6FBC1, 0xEBF7FBC1, 0xEBF8FBC1, 0xEBF9FBC1, 0xEBFAFBC1, 0xEBFBFBC1, 0xEBFCFBC1, 0xEBFDFBC1, 0xEBFEFBC1, 0xEBFFFBC1, 0xEC00FBC1, 0xEC01FBC1, 0xEC02FBC1, 0xEC03FBC1, 0xEC04FBC1, 0xEC05FBC1, 0xEC06FBC1, 0xEC07FBC1, 0xEC08FBC1, 0xEC09FBC1, 0xEC0AFBC1, 0xEC0BFBC1, 0xEC0CFBC1, 0xEC0DFBC1, 0xEC0EFBC1, 0xEC0FFBC1, 0xEC10FBC1, 0xEC11FBC1, 0xEC12FBC1, 0xEC13FBC1, 0xEC14FBC1, 0xEC15FBC1, 0xEC16FBC1, 0xEC17FBC1, 0xEC18FBC1, 0xEC19FBC1, 0xEC1AFBC1, 0xEC1BFBC1, 0xEC1CFBC1, 0xEC1DFBC1, 0xEC1EFBC1, 0xEC1FFBC1, 0xEC20FBC1, 0xEC21FBC1, 0xEC22FBC1, 0xEC23FBC1, 0xEC24FBC1, 0xEC25FBC1, 0xEC26FBC1, 0xEC27FBC1, 0xEC28FBC1, 0xEC29FBC1, 0xEC2AFBC1, 0xEC2BFBC1, 0xEC2CFBC1, 0xEC2DFBC1, 0xEC2EFBC1, 0xEC2FFBC1, 0xEC30FBC1, 0xEC31FBC1, 0xEC32FBC1, 0xEC33FBC1, 0xEC34FBC1, 0xEC35FBC1, 0xEC36FBC1, 0xEC37FBC1, 0xEC38FBC1, 0xEC39FBC1, 0xEC3AFBC1, 0xEC3BFBC1, 0xEC3CFBC1, 0xEC3DFBC1, 0xEC3EFBC1, 0xEC3FFBC1, 0xEC40FBC1, 0xEC41FBC1, 0xEC42FBC1, 0xEC43FBC1, 0xEC44FBC1, 0xEC45FBC1, 0xEC46FBC1, 0xEC47FBC1, 0xEC48FBC1, 0xEC49FBC1, 0xEC4AFBC1, 0xEC4BFBC1, 0xEC4CFBC1, 0xEC4DFBC1, 0xEC4EFBC1, 0xEC4FFBC1, 0xEC50FBC1, 0xEC51FBC1, 0xEC52FBC1, 0xEC53FBC1, 0xEC54FBC1, 0xEC55FBC1, 0xEC56FBC1, 0xEC57FBC1, 0xEC58FBC1, 0xEC59FBC1, 0xEC5AFBC1, 0xEC5BFBC1, 0xEC5CFBC1, 0xEC5DFBC1, 0xEC5EFBC1, 0xEC5FFBC1, 0xEC60FBC1, 0xEC61FBC1, 0xEC62FBC1, 0xEC63FBC1, 0xEC64FBC1, 0xEC65FBC1, 0xEC66FBC1, 0xEC67FBC1, 0xEC68FBC1, 0xEC69FBC1, 0xEC6AFBC1, 0xEC6BFBC1, 0xEC6CFBC1, 0xEC6DFBC1, 0xEC6EFBC1, 0xEC6FFBC1, 0xEC70FBC1, 0xEC71FBC1, /* EBC8 */
+ 0xEC72FBC1, 0xEC73FBC1, 0xEC74FBC1, 0xEC75FBC1, 0xEC76FBC1, 0xEC77FBC1, 0xEC78FBC1, 0xEC79FBC1, 0xEC7AFBC1, 0xEC7BFBC1, 0xEC7CFBC1, 0xEC7DFBC1, 0xEC7EFBC1, 0xEC7FFBC1, 0xEC80FBC1, 0xEC81FBC1, 0xEC82FBC1, 0xEC83FBC1, 0xEC84FBC1, 0xEC85FBC1, 0xEC86FBC1, 0xEC87FBC1, 0xEC88FBC1, 0xEC89FBC1, 0xEC8AFBC1, 0xEC8BFBC1, 0xEC8CFBC1, 0xEC8DFBC1, 0xEC8EFBC1, 0xEC8FFBC1, 0xEC90FBC1, 0xEC91FBC1, 0xEC92FBC1, 0xEC93FBC1, 0xEC94FBC1, 0xEC95FBC1, 0xEC96FBC1, 0xEC97FBC1, 0xEC98FBC1, 0xEC99FBC1, 0xEC9AFBC1, 0xEC9BFBC1, 0xEC9CFBC1, 0xEC9DFBC1, 0xEC9EFBC1, 0xEC9FFBC1, 0xECA0FBC1, 0xECA1FBC1, 0xECA2FBC1, 0xECA3FBC1, 0xECA4FBC1, 0xECA5FBC1, 0xECA6FBC1, 0xECA7FBC1, 0xECA8FBC1, 0xECA9FBC1, 0xECAAFBC1, 0xECABFBC1, 0xECACFBC1, 0xECADFBC1, 0xECAEFBC1, 0xECAFFBC1, 0xECB0FBC1, 0xECB1FBC1, 0xECB2FBC1, 0xECB3FBC1, 0xECB4FBC1, 0xECB5FBC1, 0xECB6FBC1, 0xECB7FBC1, 0xECB8FBC1, 0xECB9FBC1, 0xECBAFBC1, 0xECBBFBC1, 0xECBCFBC1, 0xECBDFBC1, 0xECBEFBC1, 0xECBFFBC1, 0xECC0FBC1, 0xECC1FBC1, 0xECC2FBC1, 0xECC3FBC1, 0xECC4FBC1, 0xECC5FBC1, 0xECC6FBC1, 0xECC7FBC1, 0xECC8FBC1, 0xECC9FBC1, 0xECCAFBC1, 0xECCBFBC1, 0xECCCFBC1, 0xECCDFBC1, 0xECCEFBC1, 0xECCFFBC1, 0xECD0FBC1, 0xECD1FBC1, 0xECD2FBC1, 0xECD3FBC1, 0xECD4FBC1, 0xECD5FBC1, 0xECD6FBC1, 0xECD7FBC1, 0xECD8FBC1, 0xECD9FBC1, 0xECDAFBC1, 0xECDBFBC1, 0xECDCFBC1, 0xECDDFBC1, 0xECDEFBC1, 0xECDFFBC1, 0xECE0FBC1, 0xECE1FBC1, 0xECE2FBC1, 0xECE3FBC1, 0xECE4FBC1, 0xECE5FBC1, 0xECE6FBC1, 0xECE7FBC1, 0xECE8FBC1, 0xECE9FBC1, 0xECEAFBC1, 0xECEBFBC1, 0xECECFBC1, 0xECEDFBC1, 0xECEEFBC1, 0xECEFFBC1, 0xECF0FBC1, 0xECF1FBC1, 0xECF2FBC1, 0xECF3FBC1, 0xECF4FBC1, 0xECF5FBC1, 0xECF6FBC1, 0xECF7FBC1, 0xECF8FBC1, 0xECF9FBC1, 0xECFAFBC1, 0xECFBFBC1, 0xECFCFBC1, 0xECFDFBC1, 0xECFEFBC1, 0xECFFFBC1, 0xED00FBC1, 0xED01FBC1, 0xED02FBC1, 0xED03FBC1, 0xED04FBC1, 0xED05FBC1, 0xED06FBC1, 0xED07FBC1, 0xED08FBC1, 0xED09FBC1, 0xED0AFBC1, 0xED0BFBC1, 0xED0CFBC1, 0xED0DFBC1, 0xED0EFBC1, 0xED0FFBC1, 0xED10FBC1, 0xED11FBC1, 0xED12FBC1, 0xED13FBC1, 0xED14FBC1, 0xED15FBC1, 0xED16FBC1, 0xED17FBC1, 0xED18FBC1, 0xED19FBC1, 0xED1AFBC1, 0xED1BFBC1, /* EC72 */
+ 0xED1CFBC1, 0xED1DFBC1, 0xED1EFBC1, 0xED1FFBC1, 0xED20FBC1, 0xED21FBC1, 0xED22FBC1, 0xED23FBC1, 0xED24FBC1, 0xED25FBC1, 0xED26FBC1, 0xED27FBC1, 0xED28FBC1, 0xED29FBC1, 0xED2AFBC1, 0xED2BFBC1, 0xED2CFBC1, 0xED2DFBC1, 0xED2EFBC1, 0xED2FFBC1, 0xED30FBC1, 0xED31FBC1, 0xED32FBC1, 0xED33FBC1, 0xED34FBC1, 0xED35FBC1, 0xED36FBC1, 0xED37FBC1, 0xED38FBC1, 0xED39FBC1, 0xED3AFBC1, 0xED3BFBC1, 0xED3CFBC1, 0xED3DFBC1, 0xED3EFBC1, 0xED3FFBC1, 0xED40FBC1, 0xED41FBC1, 0xED42FBC1, 0xED43FBC1, 0xED44FBC1, 0xED45FBC1, 0xED46FBC1, 0xED47FBC1, 0xED48FBC1, 0xED49FBC1, 0xED4AFBC1, 0xED4BFBC1, 0xED4CFBC1, 0xED4DFBC1, 0xED4EFBC1, 0xED4FFBC1, 0xED50FBC1, 0xED51FBC1, 0xED52FBC1, 0xED53FBC1, 0xED54FBC1, 0xED55FBC1, 0xED56FBC1, 0xED57FBC1, 0xED58FBC1, 0xED59FBC1, 0xED5AFBC1, 0xED5BFBC1, 0xED5CFBC1, 0xED5DFBC1, 0xED5EFBC1, 0xED5FFBC1, 0xED60FBC1, 0xED61FBC1, 0xED62FBC1, 0xED63FBC1, 0xED64FBC1, 0xED65FBC1, 0xED66FBC1, 0xED67FBC1, 0xED68FBC1, 0xED69FBC1, 0xED6AFBC1, 0xED6BFBC1, 0xED6CFBC1, 0xED6DFBC1, 0xED6EFBC1, 0xED6FFBC1, 0xED70FBC1, 0xED71FBC1, 0xED72FBC1, 0xED73FBC1, 0xED74FBC1, 0xED75FBC1, 0xED76FBC1, 0xED77FBC1, 0xED78FBC1, 0xED79FBC1, 0xED7AFBC1, 0xED7BFBC1, 0xED7CFBC1, 0xED7DFBC1, 0xED7EFBC1, 0xED7FFBC1, 0xED80FBC1, 0xED81FBC1, 0xED82FBC1, 0xED83FBC1, 0xED84FBC1, 0xED85FBC1, 0xED86FBC1, 0xED87FBC1, 0xED88FBC1, 0xED89FBC1, 0xED8AFBC1, 0xED8BFBC1, 0xED8CFBC1, 0xED8DFBC1, 0xED8EFBC1, 0xED8FFBC1, 0xED90FBC1, 0xED91FBC1, 0xED92FBC1, 0xED93FBC1, 0xED94FBC1, 0xED95FBC1, 0xED96FBC1, 0xED97FBC1, 0xED98FBC1, 0xED99FBC1, 0xED9AFBC1, 0xED9BFBC1, 0xED9CFBC1, 0xED9DFBC1, 0xED9EFBC1, 0xED9FFBC1, 0xEDA0FBC1, 0xEDA1FBC1, 0xEDA2FBC1, 0xEDA3FBC1, 0xEDA4FBC1, 0xEDA5FBC1, 0xEDA6FBC1, 0xEDA7FBC1, 0xEDA8FBC1, 0xEDA9FBC1, 0xEDAAFBC1, 0xEDABFBC1, 0xEDACFBC1, 0xEDADFBC1, 0xEDAEFBC1, 0xEDAFFBC1, 0xEDB0FBC1, 0xEDB1FBC1, 0xEDB2FBC1, 0xEDB3FBC1, 0xEDB4FBC1, 0xEDB5FBC1, 0xEDB6FBC1, 0xEDB7FBC1, 0xEDB8FBC1, 0xEDB9FBC1, 0xEDBAFBC1, 0xEDBBFBC1, 0xEDBCFBC1, 0xEDBDFBC1, 0xEDBEFBC1, 0xEDBFFBC1, 0xEDC0FBC1, 0xEDC1FBC1, 0xEDC2FBC1, 0xEDC3FBC1, 0xEDC4FBC1, 0xEDC5FBC1, /* ED1C */
+ 0xEDC6FBC1, 0xEDC7FBC1, 0xEDC8FBC1, 0xEDC9FBC1, 0xEDCAFBC1, 0xEDCBFBC1, 0xEDCCFBC1, 0xEDCDFBC1, 0xEDCEFBC1, 0xEDCFFBC1, 0xEDD0FBC1, 0xEDD1FBC1, 0xEDD2FBC1, 0xEDD3FBC1, 0xEDD4FBC1, 0xEDD5FBC1, 0xEDD6FBC1, 0xEDD7FBC1, 0xEDD8FBC1, 0xEDD9FBC1, 0xEDDAFBC1, 0xEDDBFBC1, 0xEDDCFBC1, 0xEDDDFBC1, 0xEDDEFBC1, 0xEDDFFBC1, 0xEDE0FBC1, 0xEDE1FBC1, 0xEDE2FBC1, 0xEDE3FBC1, 0xEDE4FBC1, 0xEDE5FBC1, 0xEDE6FBC1, 0xEDE7FBC1, 0xEDE8FBC1, 0xEDE9FBC1, 0xEDEAFBC1, 0xEDEBFBC1, 0xEDECFBC1, 0xEDEDFBC1, 0xEDEEFBC1, 0xEDEFFBC1, 0xEDF0FBC1, 0xEDF1FBC1, 0xEDF2FBC1, 0xEDF3FBC1, 0xEDF4FBC1, 0xEDF5FBC1, 0xEDF6FBC1, 0xEDF7FBC1, 0xEDF8FBC1, 0xEDF9FBC1, 0xEDFAFBC1, 0xEDFBFBC1, 0xEDFCFBC1, 0xEDFDFBC1, 0xEDFEFBC1, 0xEDFFFBC1, 0xEE00FBC1, 0xEE01FBC1, 0xEE02FBC1, 0xEE03FBC1, 0xEE04FBC1, 0xEE05FBC1, 0xEE06FBC1, 0xEE07FBC1, 0xEE08FBC1, 0xEE09FBC1, 0xEE0AFBC1, 0xEE0BFBC1, 0xEE0CFBC1, 0xEE0DFBC1, 0xEE0EFBC1, 0xEE0FFBC1, 0xEE10FBC1, 0xEE11FBC1, 0xEE12FBC1, 0xEE13FBC1, 0xEE14FBC1, 0xEE15FBC1, 0xEE16FBC1, 0xEE17FBC1, 0xEE18FBC1, 0xEE19FBC1, 0xEE1AFBC1, 0xEE1BFBC1, 0xEE1CFBC1, 0xEE1DFBC1, 0xEE1EFBC1, 0xEE1FFBC1, 0xEE20FBC1, 0xEE21FBC1, 0xEE22FBC1, 0xEE23FBC1, 0xEE24FBC1, 0xEE25FBC1, 0xEE26FBC1, 0xEE27FBC1, 0xEE28FBC1, 0xEE29FBC1, 0xEE2AFBC1, 0xEE2BFBC1, 0xEE2CFBC1, 0xEE2DFBC1, 0xEE2EFBC1, 0xEE2FFBC1, 0xEE30FBC1, 0xEE31FBC1, 0xEE32FBC1, 0xEE33FBC1, 0xEE34FBC1, 0xEE35FBC1, 0xEE36FBC1, 0xEE37FBC1, 0xEE38FBC1, 0xEE39FBC1, 0xEE3AFBC1, 0xEE3BFBC1, 0xEE3CFBC1, 0xEE3DFBC1, 0xEE3EFBC1, 0xEE3FFBC1, 0xEE40FBC1, 0xEE41FBC1, 0xEE42FBC1, 0xEE43FBC1, 0xEE44FBC1, 0xEE45FBC1, 0xEE46FBC1, 0xEE47FBC1, 0xEE48FBC1, 0xEE49FBC1, 0xEE4AFBC1, 0xEE4BFBC1, 0xEE4CFBC1, 0xEE4DFBC1, 0xEE4EFBC1, 0xEE4FFBC1, 0xEE50FBC1, 0xEE51FBC1, 0xEE52FBC1, 0xEE53FBC1, 0xEE54FBC1, 0xEE55FBC1, 0xEE56FBC1, 0xEE57FBC1, 0xEE58FBC1, 0xEE59FBC1, 0xEE5AFBC1, 0xEE5BFBC1, 0xEE5CFBC1, 0xEE5DFBC1, 0xEE5EFBC1, 0xEE5FFBC1, 0xEE60FBC1, 0xEE61FBC1, 0xEE62FBC1, 0xEE63FBC1, 0xEE64FBC1, 0xEE65FBC1, 0xEE66FBC1, 0xEE67FBC1, 0xEE68FBC1, 0xEE69FBC1, 0xEE6AFBC1, 0xEE6BFBC1, 0xEE6CFBC1, 0xEE6DFBC1, 0xEE6EFBC1, 0xEE6FFBC1, /* EDC6 */
+ 0xEE70FBC1, 0xEE71FBC1, 0xEE72FBC1, 0xEE73FBC1, 0xEE74FBC1, 0xEE75FBC1, 0xEE76FBC1, 0xEE77FBC1, 0xEE78FBC1, 0xEE79FBC1, 0xEE7AFBC1, 0xEE7BFBC1, 0xEE7CFBC1, 0xEE7DFBC1, 0xEE7EFBC1, 0xEE7FFBC1, 0xEE80FBC1, 0xEE81FBC1, 0xEE82FBC1, 0xEE83FBC1, 0xEE84FBC1, 0xEE85FBC1, 0xEE86FBC1, 0xEE87FBC1, 0xEE88FBC1, 0xEE89FBC1, 0xEE8AFBC1, 0xEE8BFBC1, 0xEE8CFBC1, 0xEE8DFBC1, 0xEE8EFBC1, 0xEE8FFBC1, 0xEE90FBC1, 0xEE91FBC1, 0xEE92FBC1, 0xEE93FBC1, 0xEE94FBC1, 0xEE95FBC1, 0xEE96FBC1, 0xEE97FBC1, 0xEE98FBC1, 0xEE99FBC1, 0xEE9AFBC1, 0xEE9BFBC1, 0xEE9CFBC1, 0xEE9DFBC1, 0xEE9EFBC1, 0xEE9FFBC1, 0xEEA0FBC1, 0xEEA1FBC1, 0xEEA2FBC1, 0xEEA3FBC1, 0xEEA4FBC1, 0xEEA5FBC1, 0xEEA6FBC1, 0xEEA7FBC1, 0xEEA8FBC1, 0xEEA9FBC1, 0xEEAAFBC1, 0xEEABFBC1, 0xEEACFBC1, 0xEEADFBC1, 0xEEAEFBC1, 0xEEAFFBC1, 0xEEB0FBC1, 0xEEB1FBC1, 0xEEB2FBC1, 0xEEB3FBC1, 0xEEB4FBC1, 0xEEB5FBC1, 0xEEB6FBC1, 0xEEB7FBC1, 0xEEB8FBC1, 0xEEB9FBC1, 0xEEBAFBC1, 0xEEBBFBC1, 0xEEBCFBC1, 0xEEBDFBC1, 0xEEBEFBC1, 0xEEBFFBC1, 0xEEC0FBC1, 0xEEC1FBC1, 0xEEC2FBC1, 0xEEC3FBC1, 0xEEC4FBC1, 0xEEC5FBC1, 0xEEC6FBC1, 0xEEC7FBC1, 0xEEC8FBC1, 0xEEC9FBC1, 0xEECAFBC1, 0xEECBFBC1, 0xEECCFBC1, 0xEECDFBC1, 0xEECEFBC1, 0xEECFFBC1, 0xEED0FBC1, 0xEED1FBC1, 0xEED2FBC1, 0xEED3FBC1, 0xEED4FBC1, 0xEED5FBC1, 0xEED6FBC1, 0xEED7FBC1, 0xEED8FBC1, 0xEED9FBC1, 0xEEDAFBC1, 0xEEDBFBC1, 0xEEDCFBC1, 0xEEDDFBC1, 0xEEDEFBC1, 0xEEDFFBC1, 0xEEE0FBC1, 0xEEE1FBC1, 0xEEE2FBC1, 0xEEE3FBC1, 0xEEE4FBC1, 0xEEE5FBC1, 0xEEE6FBC1, 0xEEE7FBC1, 0xEEE8FBC1, 0xEEE9FBC1, 0xEEEAFBC1, 0xEEEBFBC1, 0xEEECFBC1, 0xEEEDFBC1, 0xEEEEFBC1, 0xEEEFFBC1, 0xEEF0FBC1, 0xEEF1FBC1, 0xEEF2FBC1, 0xEEF3FBC1, 0xEEF4FBC1, 0xEEF5FBC1, 0xEEF6FBC1, 0xEEF7FBC1, 0xEEF8FBC1, 0xEEF9FBC1, 0xEEFAFBC1, 0xEEFBFBC1, 0xEEFCFBC1, 0xEEFDFBC1, 0xEEFEFBC1, 0xEEFFFBC1, 0xEF00FBC1, 0xEF01FBC1, 0xEF02FBC1, 0xEF03FBC1, 0xEF04FBC1, 0xEF05FBC1, 0xEF06FBC1, 0xEF07FBC1, 0xEF08FBC1, 0xEF09FBC1, 0xEF0AFBC1, 0xEF0BFBC1, 0xEF0CFBC1, 0xEF0DFBC1, 0xEF0EFBC1, 0xEF0FFBC1, 0xEF10FBC1, 0xEF11FBC1, 0xEF12FBC1, 0xEF13FBC1, 0xEF14FBC1, 0xEF15FBC1, 0xEF16FBC1, 0xEF17FBC1, 0xEF18FBC1, 0xEF19FBC1, /* EE70 */
+ 0xEF1AFBC1, 0xEF1BFBC1, 0xEF1CFBC1, 0xEF1DFBC1, 0xEF1EFBC1, 0xEF1FFBC1, 0xEF20FBC1, 0xEF21FBC1, 0xEF22FBC1, 0xEF23FBC1, 0xEF24FBC1, 0xEF25FBC1, 0xEF26FBC1, 0xEF27FBC1, 0xEF28FBC1, 0xEF29FBC1, 0xEF2AFBC1, 0xEF2BFBC1, 0xEF2CFBC1, 0xEF2DFBC1, 0xEF2EFBC1, 0xEF2FFBC1, 0xEF30FBC1, 0xEF31FBC1, 0xEF32FBC1, 0xEF33FBC1, 0xEF34FBC1, 0xEF35FBC1, 0xEF36FBC1, 0xEF37FBC1, 0xEF38FBC1, 0xEF39FBC1, 0xEF3AFBC1, 0xEF3BFBC1, 0xEF3CFBC1, 0xEF3DFBC1, 0xEF3EFBC1, 0xEF3FFBC1, 0xEF40FBC1, 0xEF41FBC1, 0xEF42FBC1, 0xEF43FBC1, 0xEF44FBC1, 0xEF45FBC1, 0xEF46FBC1, 0xEF47FBC1, 0xEF48FBC1, 0xEF49FBC1, 0xEF4AFBC1, 0xEF4BFBC1, 0xEF4CFBC1, 0xEF4DFBC1, 0xEF4EFBC1, 0xEF4FFBC1, 0xEF50FBC1, 0xEF51FBC1, 0xEF52FBC1, 0xEF53FBC1, 0xEF54FBC1, 0xEF55FBC1, 0xEF56FBC1, 0xEF57FBC1, 0xEF58FBC1, 0xEF59FBC1, 0xEF5AFBC1, 0xEF5BFBC1, 0xEF5CFBC1, 0xEF5DFBC1, 0xEF5EFBC1, 0xEF5FFBC1, 0xEF60FBC1, 0xEF61FBC1, 0xEF62FBC1, 0xEF63FBC1, 0xEF64FBC1, 0xEF65FBC1, 0xEF66FBC1, 0xEF67FBC1, 0xEF68FBC1, 0xEF69FBC1, 0xEF6AFBC1, 0xEF6BFBC1, 0xEF6CFBC1, 0xEF6DFBC1, 0xEF6EFBC1, 0xEF6FFBC1, 0xEF70FBC1, 0xEF71FBC1, 0xEF72FBC1, 0xEF73FBC1, 0xEF74FBC1, 0xEF75FBC1, 0xEF76FBC1, 0xEF77FBC1, 0xEF78FBC1, 0xEF79FBC1, 0xEF7AFBC1, 0xEF7BFBC1, 0xEF7CFBC1, 0xEF7DFBC1, 0xEF7EFBC1, 0xEF7FFBC1, 0xEF80FBC1, 0xEF81FBC1, 0xEF82FBC1, 0xEF83FBC1, 0xEF84FBC1, 0xEF85FBC1, 0xEF86FBC1, 0xEF87FBC1, 0xEF88FBC1, 0xEF89FBC1, 0xEF8AFBC1, 0xEF8BFBC1, 0xEF8CFBC1, 0xEF8DFBC1, 0xEF8EFBC1, 0xEF8FFBC1, 0xEF90FBC1, 0xEF91FBC1, 0xEF92FBC1, 0xEF93FBC1, 0xEF94FBC1, 0xEF95FBC1, 0xEF96FBC1, 0xEF97FBC1, 0xEF98FBC1, 0xEF99FBC1, 0xEF9AFBC1, 0xEF9BFBC1, 0xEF9CFBC1, 0xEF9DFBC1, 0xEF9EFBC1, 0xEF9FFBC1, 0xEFA0FBC1, 0xEFA1FBC1, 0xEFA2FBC1, 0xEFA3FBC1, 0xEFA4FBC1, 0xEFA5FBC1, 0xEFA6FBC1, 0xEFA7FBC1, 0xEFA8FBC1, 0xEFA9FBC1, 0xEFAAFBC1, 0xEFABFBC1, 0xEFACFBC1, 0xEFADFBC1, 0xEFAEFBC1, 0xEFAFFBC1, 0xEFB0FBC1, 0xEFB1FBC1, 0xEFB2FBC1, 0xEFB3FBC1, 0xEFB4FBC1, 0xEFB5FBC1, 0xEFB6FBC1, 0xEFB7FBC1, 0xEFB8FBC1, 0xEFB9FBC1, 0xEFBAFBC1, 0xEFBBFBC1, 0xEFBCFBC1, 0xEFBDFBC1, 0xEFBEFBC1, 0xEFBFFBC1, 0xEFC0FBC1, 0xEFC1FBC1, 0xEFC2FBC1, 0xEFC3FBC1, /* EF1A */
+ 0xEFC4FBC1, 0xEFC5FBC1, 0xEFC6FBC1, 0xEFC7FBC1, 0xEFC8FBC1, 0xEFC9FBC1, 0xEFCAFBC1, 0xEFCBFBC1, 0xEFCCFBC1, 0xEFCDFBC1, 0xEFCEFBC1, 0xEFCFFBC1, 0xEFD0FBC1, 0xEFD1FBC1, 0xEFD2FBC1, 0xEFD3FBC1, 0xEFD4FBC1, 0xEFD5FBC1, 0xEFD6FBC1, 0xEFD7FBC1, 0xEFD8FBC1, 0xEFD9FBC1, 0xEFDAFBC1, 0xEFDBFBC1, 0xEFDCFBC1, 0xEFDDFBC1, 0xEFDEFBC1, 0xEFDFFBC1, 0xEFE0FBC1, 0xEFE1FBC1, 0xEFE2FBC1, 0xEFE3FBC1, 0xEFE4FBC1, 0xEFE5FBC1, 0xEFE6FBC1, 0xEFE7FBC1, 0xEFE8FBC1, 0xEFE9FBC1, 0xEFEAFBC1, 0xEFEBFBC1, 0xEFECFBC1, 0xEFEDFBC1, 0xEFEEFBC1, 0xEFEFFBC1, 0xEFF0FBC1, 0xEFF1FBC1, 0xEFF2FBC1, 0xEFF3FBC1, 0xEFF4FBC1, 0xEFF5FBC1, 0xEFF6FBC1, 0xEFF7FBC1, 0xEFF8FBC1, 0xEFF9FBC1, 0xEFFAFBC1, 0xEFFBFBC1, 0xEFFCFBC1, 0xEFFDFBC1, 0xEFFEFBC1, 0xEFFFFBC1, 0xF000FBC1, 0xF001FBC1, 0xF002FBC1, 0xF003FBC1, 0xF004FBC1, 0xF005FBC1, 0xF006FBC1, 0xF007FBC1, 0xF008FBC1, 0xF009FBC1, 0xF00AFBC1, 0xF00BFBC1, 0xF00CFBC1, 0xF00DFBC1, 0xF00EFBC1, 0xF00FFBC1, 0xF010FBC1, 0xF011FBC1, 0xF012FBC1, 0xF013FBC1, 0xF014FBC1, 0xF015FBC1, 0xF016FBC1, 0xF017FBC1, 0xF018FBC1, 0xF019FBC1, 0xF01AFBC1, 0xF01BFBC1, 0xF01CFBC1, 0xF01DFBC1, 0xF01EFBC1, 0xF01FFBC1, 0xF020FBC1, 0xF021FBC1, 0xF022FBC1, 0xF023FBC1, 0xF024FBC1, 0xF025FBC1, 0xF026FBC1, 0xF027FBC1, 0xF028FBC1, 0xF029FBC1, 0xF02AFBC1, 0xF02BFBC1, 0xF02CFBC1, 0xF02DFBC1, 0xF02EFBC1, 0xF02FFBC1, 0xF030FBC1, 0xF031FBC1, 0xF032FBC1, 0xF033FBC1, 0xF034FBC1, 0xF035FBC1, 0xF036FBC1, 0xF037FBC1, 0xF038FBC1, 0xF039FBC1, 0xF03AFBC1, 0xF03BFBC1, 0xF03CFBC1, 0xF03DFBC1, 0xF03EFBC1, 0xF03FFBC1, 0xF040FBC1, 0xF041FBC1, 0xF042FBC1, 0xF043FBC1, 0xF044FBC1, 0xF045FBC1, 0xF046FBC1, 0xF047FBC1, 0xF048FBC1, 0xF049FBC1, 0xF04AFBC1, 0xF04BFBC1, 0xF04CFBC1, 0xF04DFBC1, 0xF04EFBC1, 0xF04FFBC1, 0xF050FBC1, 0xF051FBC1, 0xF052FBC1, 0xF053FBC1, 0xF054FBC1, 0xF055FBC1, 0xF056FBC1, 0xF057FBC1, 0xF058FBC1, 0xF059FBC1, 0xF05AFBC1, 0xF05BFBC1, 0xF05CFBC1, 0xF05DFBC1, 0xF05EFBC1, 0xF05FFBC1, 0xF060FBC1, 0xF061FBC1, 0xF062FBC1, 0xF063FBC1, 0xF064FBC1, 0xF065FBC1, 0xF066FBC1, 0xF067FBC1, 0xF068FBC1, 0xF069FBC1, 0xF06AFBC1, 0xF06BFBC1, 0xF06CFBC1, 0xF06DFBC1, /* EFC4 */
+ 0xF06EFBC1, 0xF06FFBC1, 0xF070FBC1, 0xF071FBC1, 0xF072FBC1, 0xF073FBC1, 0xF074FBC1, 0xF075FBC1, 0xF076FBC1, 0xF077FBC1, 0xF078FBC1, 0xF079FBC1, 0xF07AFBC1, 0xF07BFBC1, 0xF07CFBC1, 0xF07DFBC1, 0xF07EFBC1, 0xF07FFBC1, 0xF080FBC1, 0xF081FBC1, 0xF082FBC1, 0xF083FBC1, 0xF084FBC1, 0xF085FBC1, 0xF086FBC1, 0xF087FBC1, 0xF088FBC1, 0xF089FBC1, 0xF08AFBC1, 0xF08BFBC1, 0xF08CFBC1, 0xF08DFBC1, 0xF08EFBC1, 0xF08FFBC1, 0xF090FBC1, 0xF091FBC1, 0xF092FBC1, 0xF093FBC1, 0xF094FBC1, 0xF095FBC1, 0xF096FBC1, 0xF097FBC1, 0xF098FBC1, 0xF099FBC1, 0xF09AFBC1, 0xF09BFBC1, 0xF09CFBC1, 0xF09DFBC1, 0xF09EFBC1, 0xF09FFBC1, 0xF0A0FBC1, 0xF0A1FBC1, 0xF0A2FBC1, 0xF0A3FBC1, 0xF0A4FBC1, 0xF0A5FBC1, 0xF0A6FBC1, 0xF0A7FBC1, 0xF0A8FBC1, 0xF0A9FBC1, 0xF0AAFBC1, 0xF0ABFBC1, 0xF0ACFBC1, 0xF0ADFBC1, 0xF0AEFBC1, 0xF0AFFBC1, 0xF0B0FBC1, 0xF0B1FBC1, 0xF0B2FBC1, 0xF0B3FBC1, 0xF0B4FBC1, 0xF0B5FBC1, 0xF0B6FBC1, 0xF0B7FBC1, 0xF0B8FBC1, 0xF0B9FBC1, 0xF0BAFBC1, 0xF0BBFBC1, 0xF0BCFBC1, 0xF0BDFBC1, 0xF0BEFBC1, 0xF0BFFBC1, 0xF0C0FBC1, 0xF0C1FBC1, 0xF0C2FBC1, 0xF0C3FBC1, 0xF0C4FBC1, 0xF0C5FBC1, 0xF0C6FBC1, 0xF0C7FBC1, 0xF0C8FBC1, 0xF0C9FBC1, 0xF0CAFBC1, 0xF0CBFBC1, 0xF0CCFBC1, 0xF0CDFBC1, 0xF0CEFBC1, 0xF0CFFBC1, 0xF0D0FBC1, 0xF0D1FBC1, 0xF0D2FBC1, 0xF0D3FBC1, 0xF0D4FBC1, 0xF0D5FBC1, 0xF0D6FBC1, 0xF0D7FBC1, 0xF0D8FBC1, 0xF0D9FBC1, 0xF0DAFBC1, 0xF0DBFBC1, 0xF0DCFBC1, 0xF0DDFBC1, 0xF0DEFBC1, 0xF0DFFBC1, 0xF0E0FBC1, 0xF0E1FBC1, 0xF0E2FBC1, 0xF0E3FBC1, 0xF0E4FBC1, 0xF0E5FBC1, 0xF0E6FBC1, 0xF0E7FBC1, 0xF0E8FBC1, 0xF0E9FBC1, 0xF0EAFBC1, 0xF0EBFBC1, 0xF0ECFBC1, 0xF0EDFBC1, 0xF0EEFBC1, 0xF0EFFBC1, 0xF0F0FBC1, 0xF0F1FBC1, 0xF0F2FBC1, 0xF0F3FBC1, 0xF0F4FBC1, 0xF0F5FBC1, 0xF0F6FBC1, 0xF0F7FBC1, 0xF0F8FBC1, 0xF0F9FBC1, 0xF0FAFBC1, 0xF0FBFBC1, 0xF0FCFBC1, 0xF0FDFBC1, 0xF0FEFBC1, 0xF0FFFBC1, 0xF100FBC1, 0xF101FBC1, 0xF102FBC1, 0xF103FBC1, 0xF104FBC1, 0xF105FBC1, 0xF106FBC1, 0xF107FBC1, 0xF108FBC1, 0xF109FBC1, 0xF10AFBC1, 0xF10BFBC1, 0xF10CFBC1, 0xF10DFBC1, 0xF10EFBC1, 0xF10FFBC1, 0xF110FBC1, 0xF111FBC1, 0xF112FBC1, 0xF113FBC1, 0xF114FBC1, 0xF115FBC1, 0xF116FBC1, 0xF117FBC1, /* F06E */
+ 0xF118FBC1, 0xF119FBC1, 0xF11AFBC1, 0xF11BFBC1, 0xF11CFBC1, 0xF11DFBC1, 0xF11EFBC1, 0xF11FFBC1, 0xF120FBC1, 0xF121FBC1, 0xF122FBC1, 0xF123FBC1, 0xF124FBC1, 0xF125FBC1, 0xF126FBC1, 0xF127FBC1, 0xF128FBC1, 0xF129FBC1, 0xF12AFBC1, 0xF12BFBC1, 0xF12CFBC1, 0xF12DFBC1, 0xF12EFBC1, 0xF12FFBC1, 0xF130FBC1, 0xF131FBC1, 0xF132FBC1, 0xF133FBC1, 0xF134FBC1, 0xF135FBC1, 0xF136FBC1, 0xF137FBC1, 0xF138FBC1, 0xF139FBC1, 0xF13AFBC1, 0xF13BFBC1, 0xF13CFBC1, 0xF13DFBC1, 0xF13EFBC1, 0xF13FFBC1, 0xF140FBC1, 0xF141FBC1, 0xF142FBC1, 0xF143FBC1, 0xF144FBC1, 0xF145FBC1, 0xF146FBC1, 0xF147FBC1, 0xF148FBC1, 0xF149FBC1, 0xF14AFBC1, 0xF14BFBC1, 0xF14CFBC1, 0xF14DFBC1, 0xF14EFBC1, 0xF14FFBC1, 0xF150FBC1, 0xF151FBC1, 0xF152FBC1, 0xF153FBC1, 0xF154FBC1, 0xF155FBC1, 0xF156FBC1, 0xF157FBC1, 0xF158FBC1, 0xF159FBC1, 0xF15AFBC1, 0xF15BFBC1, 0xF15CFBC1, 0xF15DFBC1, 0xF15EFBC1, 0xF15FFBC1, 0xF160FBC1, 0xF161FBC1, 0xF162FBC1, 0xF163FBC1, 0xF164FBC1, 0xF165FBC1, 0xF166FBC1, 0xF167FBC1, 0xF168FBC1, 0xF169FBC1, 0xF16AFBC1, 0xF16BFBC1, 0xF16CFBC1, 0xF16DFBC1, 0xF16EFBC1, 0xF16FFBC1, 0xF170FBC1, 0xF171FBC1, 0xF172FBC1, 0xF173FBC1, 0xF174FBC1, 0xF175FBC1, 0xF176FBC1, 0xF177FBC1, 0xF178FBC1, 0xF179FBC1, 0xF17AFBC1, 0xF17BFBC1, 0xF17CFBC1, 0xF17DFBC1, 0xF17EFBC1, 0xF17FFBC1, 0xF180FBC1, 0xF181FBC1, 0xF182FBC1, 0xF183FBC1, 0xF184FBC1, 0xF185FBC1, 0xF186FBC1, 0xF187FBC1, 0xF188FBC1, 0xF189FBC1, 0xF18AFBC1, 0xF18BFBC1, 0xF18CFBC1, 0xF18DFBC1, 0xF18EFBC1, 0xF18FFBC1, 0xF190FBC1, 0xF191FBC1, 0xF192FBC1, 0xF193FBC1, 0xF194FBC1, 0xF195FBC1, 0xF196FBC1, 0xF197FBC1, 0xF198FBC1, 0xF199FBC1, 0xF19AFBC1, 0xF19BFBC1, 0xF19CFBC1, 0xF19DFBC1, 0xF19EFBC1, 0xF19FFBC1, 0xF1A0FBC1, 0xF1A1FBC1, 0xF1A2FBC1, 0xF1A3FBC1, 0xF1A4FBC1, 0xF1A5FBC1, 0xF1A6FBC1, 0xF1A7FBC1, 0xF1A8FBC1, 0xF1A9FBC1, 0xF1AAFBC1, 0xF1ABFBC1, 0xF1ACFBC1, 0xF1ADFBC1, 0xF1AEFBC1, 0xF1AFFBC1, 0xF1B0FBC1, 0xF1B1FBC1, 0xF1B2FBC1, 0xF1B3FBC1, 0xF1B4FBC1, 0xF1B5FBC1, 0xF1B6FBC1, 0xF1B7FBC1, 0xF1B8FBC1, 0xF1B9FBC1, 0xF1BAFBC1, 0xF1BBFBC1, 0xF1BCFBC1, 0xF1BDFBC1, 0xF1BEFBC1, 0xF1BFFBC1, 0xF1C0FBC1, 0xF1C1FBC1, /* F118 */
+ 0xF1C2FBC1, 0xF1C3FBC1, 0xF1C4FBC1, 0xF1C5FBC1, 0xF1C6FBC1, 0xF1C7FBC1, 0xF1C8FBC1, 0xF1C9FBC1, 0xF1CAFBC1, 0xF1CBFBC1, 0xF1CCFBC1, 0xF1CDFBC1, 0xF1CEFBC1, 0xF1CFFBC1, 0xF1D0FBC1, 0xF1D1FBC1, 0xF1D2FBC1, 0xF1D3FBC1, 0xF1D4FBC1, 0xF1D5FBC1, 0xF1D6FBC1, 0xF1D7FBC1, 0xF1D8FBC1, 0xF1D9FBC1, 0xF1DAFBC1, 0xF1DBFBC1, 0xF1DCFBC1, 0xF1DDFBC1, 0xF1DEFBC1, 0xF1DFFBC1, 0xF1E0FBC1, 0xF1E1FBC1, 0xF1E2FBC1, 0xF1E3FBC1, 0xF1E4FBC1, 0xF1E5FBC1, 0xF1E6FBC1, 0xF1E7FBC1, 0xF1E8FBC1, 0xF1E9FBC1, 0xF1EAFBC1, 0xF1EBFBC1, 0xF1ECFBC1, 0xF1EDFBC1, 0xF1EEFBC1, 0xF1EFFBC1, 0xF1F0FBC1, 0xF1F1FBC1, 0xF1F2FBC1, 0xF1F3FBC1, 0xF1F4FBC1, 0xF1F5FBC1, 0xF1F6FBC1, 0xF1F7FBC1, 0xF1F8FBC1, 0xF1F9FBC1, 0xF1FAFBC1, 0xF1FBFBC1, 0xF1FCFBC1, 0xF1FDFBC1, 0xF1FEFBC1, 0xF1FFFBC1, 0xF200FBC1, 0xF201FBC1, 0xF202FBC1, 0xF203FBC1, 0xF204FBC1, 0xF205FBC1, 0xF206FBC1, 0xF207FBC1, 0xF208FBC1, 0xF209FBC1, 0xF20AFBC1, 0xF20BFBC1, 0xF20CFBC1, 0xF20DFBC1, 0xF20EFBC1, 0xF20FFBC1, 0xF210FBC1, 0xF211FBC1, 0xF212FBC1, 0xF213FBC1, 0xF214FBC1, 0xF215FBC1, 0xF216FBC1, 0xF217FBC1, 0xF218FBC1, 0xF219FBC1, 0xF21AFBC1, 0xF21BFBC1, 0xF21CFBC1, 0xF21DFBC1, 0xF21EFBC1, 0xF21FFBC1, 0xF220FBC1, 0xF221FBC1, 0xF222FBC1, 0xF223FBC1, 0xF224FBC1, 0xF225FBC1, 0xF226FBC1, 0xF227FBC1, 0xF228FBC1, 0xF229FBC1, 0xF22AFBC1, 0xF22BFBC1, 0xF22CFBC1, 0xF22DFBC1, 0xF22EFBC1, 0xF22FFBC1, 0xF230FBC1, 0xF231FBC1, 0xF232FBC1, 0xF233FBC1, 0xF234FBC1, 0xF235FBC1, 0xF236FBC1, 0xF237FBC1, 0xF238FBC1, 0xF239FBC1, 0xF23AFBC1, 0xF23BFBC1, 0xF23CFBC1, 0xF23DFBC1, 0xF23EFBC1, 0xF23FFBC1, 0xF240FBC1, 0xF241FBC1, 0xF242FBC1, 0xF243FBC1, 0xF244FBC1, 0xF245FBC1, 0xF246FBC1, 0xF247FBC1, 0xF248FBC1, 0xF249FBC1, 0xF24AFBC1, 0xF24BFBC1, 0xF24CFBC1, 0xF24DFBC1, 0xF24EFBC1, 0xF24FFBC1, 0xF250FBC1, 0xF251FBC1, 0xF252FBC1, 0xF253FBC1, 0xF254FBC1, 0xF255FBC1, 0xF256FBC1, 0xF257FBC1, 0xF258FBC1, 0xF259FBC1, 0xF25AFBC1, 0xF25BFBC1, 0xF25CFBC1, 0xF25DFBC1, 0xF25EFBC1, 0xF25FFBC1, 0xF260FBC1, 0xF261FBC1, 0xF262FBC1, 0xF263FBC1, 0xF264FBC1, 0xF265FBC1, 0xF266FBC1, 0xF267FBC1, 0xF268FBC1, 0xF269FBC1, 0xF26AFBC1, 0xF26BFBC1, /* F1C2 */
+ 0xF26CFBC1, 0xF26DFBC1, 0xF26EFBC1, 0xF26FFBC1, 0xF270FBC1, 0xF271FBC1, 0xF272FBC1, 0xF273FBC1, 0xF274FBC1, 0xF275FBC1, 0xF276FBC1, 0xF277FBC1, 0xF278FBC1, 0xF279FBC1, 0xF27AFBC1, 0xF27BFBC1, 0xF27CFBC1, 0xF27DFBC1, 0xF27EFBC1, 0xF27FFBC1, 0xF280FBC1, 0xF281FBC1, 0xF282FBC1, 0xF283FBC1, 0xF284FBC1, 0xF285FBC1, 0xF286FBC1, 0xF287FBC1, 0xF288FBC1, 0xF289FBC1, 0xF28AFBC1, 0xF28BFBC1, 0xF28CFBC1, 0xF28DFBC1, 0xF28EFBC1, 0xF28FFBC1, 0xF290FBC1, 0xF291FBC1, 0xF292FBC1, 0xF293FBC1, 0xF294FBC1, 0xF295FBC1, 0xF296FBC1, 0xF297FBC1, 0xF298FBC1, 0xF299FBC1, 0xF29AFBC1, 0xF29BFBC1, 0xF29CFBC1, 0xF29DFBC1, 0xF29EFBC1, 0xF29FFBC1, 0xF2A0FBC1, 0xF2A1FBC1, 0xF2A2FBC1, 0xF2A3FBC1, 0xF2A4FBC1, 0xF2A5FBC1, 0xF2A6FBC1, 0xF2A7FBC1, 0xF2A8FBC1, 0xF2A9FBC1, 0xF2AAFBC1, 0xF2ABFBC1, 0xF2ACFBC1, 0xF2ADFBC1, 0xF2AEFBC1, 0xF2AFFBC1, 0xF2B0FBC1, 0xF2B1FBC1, 0xF2B2FBC1, 0xF2B3FBC1, 0xF2B4FBC1, 0xF2B5FBC1, 0xF2B6FBC1, 0xF2B7FBC1, 0xF2B8FBC1, 0xF2B9FBC1, 0xF2BAFBC1, 0xF2BBFBC1, 0xF2BCFBC1, 0xF2BDFBC1, 0xF2BEFBC1, 0xF2BFFBC1, 0xF2C0FBC1, 0xF2C1FBC1, 0xF2C2FBC1, 0xF2C3FBC1, 0xF2C4FBC1, 0xF2C5FBC1, 0xF2C6FBC1, 0xF2C7FBC1, 0xF2C8FBC1, 0xF2C9FBC1, 0xF2CAFBC1, 0xF2CBFBC1, 0xF2CCFBC1, 0xF2CDFBC1, 0xF2CEFBC1, 0xF2CFFBC1, 0xF2D0FBC1, 0xF2D1FBC1, 0xF2D2FBC1, 0xF2D3FBC1, 0xF2D4FBC1, 0xF2D5FBC1, 0xF2D6FBC1, 0xF2D7FBC1, 0xF2D8FBC1, 0xF2D9FBC1, 0xF2DAFBC1, 0xF2DBFBC1, 0xF2DCFBC1, 0xF2DDFBC1, 0xF2DEFBC1, 0xF2DFFBC1, 0xF2E0FBC1, 0xF2E1FBC1, 0xF2E2FBC1, 0xF2E3FBC1, 0xF2E4FBC1, 0xF2E5FBC1, 0xF2E6FBC1, 0xF2E7FBC1, 0xF2E8FBC1, 0xF2E9FBC1, 0xF2EAFBC1, 0xF2EBFBC1, 0xF2ECFBC1, 0xF2EDFBC1, 0xF2EEFBC1, 0xF2EFFBC1, 0xF2F0FBC1, 0xF2F1FBC1, 0xF2F2FBC1, 0xF2F3FBC1, 0xF2F4FBC1, 0xF2F5FBC1, 0xF2F6FBC1, 0xF2F7FBC1, 0xF2F8FBC1, 0xF2F9FBC1, 0xF2FAFBC1, 0xF2FBFBC1, 0xF2FCFBC1, 0xF2FDFBC1, 0xF2FEFBC1, 0xF2FFFBC1, 0xF300FBC1, 0xF301FBC1, 0xF302FBC1, 0xF303FBC1, 0xF304FBC1, 0xF305FBC1, 0xF306FBC1, 0xF307FBC1, 0xF308FBC1, 0xF309FBC1, 0xF30AFBC1, 0xF30BFBC1, 0xF30CFBC1, 0xF30DFBC1, 0xF30EFBC1, 0xF30FFBC1, 0xF310FBC1, 0xF311FBC1, 0xF312FBC1, 0xF313FBC1, 0xF314FBC1, 0xF315FBC1, /* F26C */
+ 0xF316FBC1, 0xF317FBC1, 0xF318FBC1, 0xF319FBC1, 0xF31AFBC1, 0xF31BFBC1, 0xF31CFBC1, 0xF31DFBC1, 0xF31EFBC1, 0xF31FFBC1, 0xF320FBC1, 0xF321FBC1, 0xF322FBC1, 0xF323FBC1, 0xF324FBC1, 0xF325FBC1, 0xF326FBC1, 0xF327FBC1, 0xF328FBC1, 0xF329FBC1, 0xF32AFBC1, 0xF32BFBC1, 0xF32CFBC1, 0xF32DFBC1, 0xF32EFBC1, 0xF32FFBC1, 0xF330FBC1, 0xF331FBC1, 0xF332FBC1, 0xF333FBC1, 0xF334FBC1, 0xF335FBC1, 0xF336FBC1, 0xF337FBC1, 0xF338FBC1, 0xF339FBC1, 0xF33AFBC1, 0xF33BFBC1, 0xF33CFBC1, 0xF33DFBC1, 0xF33EFBC1, 0xF33FFBC1, 0xF340FBC1, 0xF341FBC1, 0xF342FBC1, 0xF343FBC1, 0xF344FBC1, 0xF345FBC1, 0xF346FBC1, 0xF347FBC1, 0xF348FBC1, 0xF349FBC1, 0xF34AFBC1, 0xF34BFBC1, 0xF34CFBC1, 0xF34DFBC1, 0xF34EFBC1, 0xF34FFBC1, 0xF350FBC1, 0xF351FBC1, 0xF352FBC1, 0xF353FBC1, 0xF354FBC1, 0xF355FBC1, 0xF356FBC1, 0xF357FBC1, 0xF358FBC1, 0xF359FBC1, 0xF35AFBC1, 0xF35BFBC1, 0xF35CFBC1, 0xF35DFBC1, 0xF35EFBC1, 0xF35FFBC1, 0xF360FBC1, 0xF361FBC1, 0xF362FBC1, 0xF363FBC1, 0xF364FBC1, 0xF365FBC1, 0xF366FBC1, 0xF367FBC1, 0xF368FBC1, 0xF369FBC1, 0xF36AFBC1, 0xF36BFBC1, 0xF36CFBC1, 0xF36DFBC1, 0xF36EFBC1, 0xF36FFBC1, 0xF370FBC1, 0xF371FBC1, 0xF372FBC1, 0xF373FBC1, 0xF374FBC1, 0xF375FBC1, 0xF376FBC1, 0xF377FBC1, 0xF378FBC1, 0xF379FBC1, 0xF37AFBC1, 0xF37BFBC1, 0xF37CFBC1, 0xF37DFBC1, 0xF37EFBC1, 0xF37FFBC1, 0xF380FBC1, 0xF381FBC1, 0xF382FBC1, 0xF383FBC1, 0xF384FBC1, 0xF385FBC1, 0xF386FBC1, 0xF387FBC1, 0xF388FBC1, 0xF389FBC1, 0xF38AFBC1, 0xF38BFBC1, 0xF38CFBC1, 0xF38DFBC1, 0xF38EFBC1, 0xF38FFBC1, 0xF390FBC1, 0xF391FBC1, 0xF392FBC1, 0xF393FBC1, 0xF394FBC1, 0xF395FBC1, 0xF396FBC1, 0xF397FBC1, 0xF398FBC1, 0xF399FBC1, 0xF39AFBC1, 0xF39BFBC1, 0xF39CFBC1, 0xF39DFBC1, 0xF39EFBC1, 0xF39FFBC1, 0xF3A0FBC1, 0xF3A1FBC1, 0xF3A2FBC1, 0xF3A3FBC1, 0xF3A4FBC1, 0xF3A5FBC1, 0xF3A6FBC1, 0xF3A7FBC1, 0xF3A8FBC1, 0xF3A9FBC1, 0xF3AAFBC1, 0xF3ABFBC1, 0xF3ACFBC1, 0xF3ADFBC1, 0xF3AEFBC1, 0xF3AFFBC1, 0xF3B0FBC1, 0xF3B1FBC1, 0xF3B2FBC1, 0xF3B3FBC1, 0xF3B4FBC1, 0xF3B5FBC1, 0xF3B6FBC1, 0xF3B7FBC1, 0xF3B8FBC1, 0xF3B9FBC1, 0xF3BAFBC1, 0xF3BBFBC1, 0xF3BCFBC1, 0xF3BDFBC1, 0xF3BEFBC1, 0xF3BFFBC1, /* F316 */
+ 0xF3C0FBC1, 0xF3C1FBC1, 0xF3C2FBC1, 0xF3C3FBC1, 0xF3C4FBC1, 0xF3C5FBC1, 0xF3C6FBC1, 0xF3C7FBC1, 0xF3C8FBC1, 0xF3C9FBC1, 0xF3CAFBC1, 0xF3CBFBC1, 0xF3CCFBC1, 0xF3CDFBC1, 0xF3CEFBC1, 0xF3CFFBC1, 0xF3D0FBC1, 0xF3D1FBC1, 0xF3D2FBC1, 0xF3D3FBC1, 0xF3D4FBC1, 0xF3D5FBC1, 0xF3D6FBC1, 0xF3D7FBC1, 0xF3D8FBC1, 0xF3D9FBC1, 0xF3DAFBC1, 0xF3DBFBC1, 0xF3DCFBC1, 0xF3DDFBC1, 0xF3DEFBC1, 0xF3DFFBC1, 0xF3E0FBC1, 0xF3E1FBC1, 0xF3E2FBC1, 0xF3E3FBC1, 0xF3E4FBC1, 0xF3E5FBC1, 0xF3E6FBC1, 0xF3E7FBC1, 0xF3E8FBC1, 0xF3E9FBC1, 0xF3EAFBC1, 0xF3EBFBC1, 0xF3ECFBC1, 0xF3EDFBC1, 0xF3EEFBC1, 0xF3EFFBC1, 0xF3F0FBC1, 0xF3F1FBC1, 0xF3F2FBC1, 0xF3F3FBC1, 0xF3F4FBC1, 0xF3F5FBC1, 0xF3F6FBC1, 0xF3F7FBC1, 0xF3F8FBC1, 0xF3F9FBC1, 0xF3FAFBC1, 0xF3FBFBC1, 0xF3FCFBC1, 0xF3FDFBC1, 0xF3FEFBC1, 0xF3FFFBC1, 0xF400FBC1, 0xF401FBC1, 0xF402FBC1, 0xF403FBC1, 0xF404FBC1, 0xF405FBC1, 0xF406FBC1, 0xF407FBC1, 0xF408FBC1, 0xF409FBC1, 0xF40AFBC1, 0xF40BFBC1, 0xF40CFBC1, 0xF40DFBC1, 0xF40EFBC1, 0xF40FFBC1, 0xF410FBC1, 0xF411FBC1, 0xF412FBC1, 0xF413FBC1, 0xF414FBC1, 0xF415FBC1, 0xF416FBC1, 0xF417FBC1, 0xF418FBC1, 0xF419FBC1, 0xF41AFBC1, 0xF41BFBC1, 0xF41CFBC1, 0xF41DFBC1, 0xF41EFBC1, 0xF41FFBC1, 0xF420FBC1, 0xF421FBC1, 0xF422FBC1, 0xF423FBC1, 0xF424FBC1, 0xF425FBC1, 0xF426FBC1, 0xF427FBC1, 0xF428FBC1, 0xF429FBC1, 0xF42AFBC1, 0xF42BFBC1, 0xF42CFBC1, 0xF42DFBC1, 0xF42EFBC1, 0xF42FFBC1, 0xF430FBC1, 0xF431FBC1, 0xF432FBC1, 0xF433FBC1, 0xF434FBC1, 0xF435FBC1, 0xF436FBC1, 0xF437FBC1, 0xF438FBC1, 0xF439FBC1, 0xF43AFBC1, 0xF43BFBC1, 0xF43CFBC1, 0xF43DFBC1, 0xF43EFBC1, 0xF43FFBC1, 0xF440FBC1, 0xF441FBC1, 0xF442FBC1, 0xF443FBC1, 0xF444FBC1, 0xF445FBC1, 0xF446FBC1, 0xF447FBC1, 0xF448FBC1, 0xF449FBC1, 0xF44AFBC1, 0xF44BFBC1, 0xF44CFBC1, 0xF44DFBC1, 0xF44EFBC1, 0xF44FFBC1, 0xF450FBC1, 0xF451FBC1, 0xF452FBC1, 0xF453FBC1, 0xF454FBC1, 0xF455FBC1, 0xF456FBC1, 0xF457FBC1, 0xF458FBC1, 0xF459FBC1, 0xF45AFBC1, 0xF45BFBC1, 0xF45CFBC1, 0xF45DFBC1, 0xF45EFBC1, 0xF45FFBC1, 0xF460FBC1, 0xF461FBC1, 0xF462FBC1, 0xF463FBC1, 0xF464FBC1, 0xF465FBC1, 0xF466FBC1, 0xF467FBC1, 0xF468FBC1, 0xF469FBC1, /* F3C0 */
+ 0xF46AFBC1, 0xF46BFBC1, 0xF46CFBC1, 0xF46DFBC1, 0xF46EFBC1, 0xF46FFBC1, 0xF470FBC1, 0xF471FBC1, 0xF472FBC1, 0xF473FBC1, 0xF474FBC1, 0xF475FBC1, 0xF476FBC1, 0xF477FBC1, 0xF478FBC1, 0xF479FBC1, 0xF47AFBC1, 0xF47BFBC1, 0xF47CFBC1, 0xF47DFBC1, 0xF47EFBC1, 0xF47FFBC1, 0xF480FBC1, 0xF481FBC1, 0xF482FBC1, 0xF483FBC1, 0xF484FBC1, 0xF485FBC1, 0xF486FBC1, 0xF487FBC1, 0xF488FBC1, 0xF489FBC1, 0xF48AFBC1, 0xF48BFBC1, 0xF48CFBC1, 0xF48DFBC1, 0xF48EFBC1, 0xF48FFBC1, 0xF490FBC1, 0xF491FBC1, 0xF492FBC1, 0xF493FBC1, 0xF494FBC1, 0xF495FBC1, 0xF496FBC1, 0xF497FBC1, 0xF498FBC1, 0xF499FBC1, 0xF49AFBC1, 0xF49BFBC1, 0xF49CFBC1, 0xF49DFBC1, 0xF49EFBC1, 0xF49FFBC1, 0xF4A0FBC1, 0xF4A1FBC1, 0xF4A2FBC1, 0xF4A3FBC1, 0xF4A4FBC1, 0xF4A5FBC1, 0xF4A6FBC1, 0xF4A7FBC1, 0xF4A8FBC1, 0xF4A9FBC1, 0xF4AAFBC1, 0xF4ABFBC1, 0xF4ACFBC1, 0xF4ADFBC1, 0xF4AEFBC1, 0xF4AFFBC1, 0xF4B0FBC1, 0xF4B1FBC1, 0xF4B2FBC1, 0xF4B3FBC1, 0xF4B4FBC1, 0xF4B5FBC1, 0xF4B6FBC1, 0xF4B7FBC1, 0xF4B8FBC1, 0xF4B9FBC1, 0xF4BAFBC1, 0xF4BBFBC1, 0xF4BCFBC1, 0xF4BDFBC1, 0xF4BEFBC1, 0xF4BFFBC1, 0xF4C0FBC1, 0xF4C1FBC1, 0xF4C2FBC1, 0xF4C3FBC1, 0xF4C4FBC1, 0xF4C5FBC1, 0xF4C6FBC1, 0xF4C7FBC1, 0xF4C8FBC1, 0xF4C9FBC1, 0xF4CAFBC1, 0xF4CBFBC1, 0xF4CCFBC1, 0xF4CDFBC1, 0xF4CEFBC1, 0xF4CFFBC1, 0xF4D0FBC1, 0xF4D1FBC1, 0xF4D2FBC1, 0xF4D3FBC1, 0xF4D4FBC1, 0xF4D5FBC1, 0xF4D6FBC1, 0xF4D7FBC1, 0xF4D8FBC1, 0xF4D9FBC1, 0xF4DAFBC1, 0xF4DBFBC1, 0xF4DCFBC1, 0xF4DDFBC1, 0xF4DEFBC1, 0xF4DFFBC1, 0xF4E0FBC1, 0xF4E1FBC1, 0xF4E2FBC1, 0xF4E3FBC1, 0xF4E4FBC1, 0xF4E5FBC1, 0xF4E6FBC1, 0xF4E7FBC1, 0xF4E8FBC1, 0xF4E9FBC1, 0xF4EAFBC1, 0xF4EBFBC1, 0xF4ECFBC1, 0xF4EDFBC1, 0xF4EEFBC1, 0xF4EFFBC1, 0xF4F0FBC1, 0xF4F1FBC1, 0xF4F2FBC1, 0xF4F3FBC1, 0xF4F4FBC1, 0xF4F5FBC1, 0xF4F6FBC1, 0xF4F7FBC1, 0xF4F8FBC1, 0xF4F9FBC1, 0xF4FAFBC1, 0xF4FBFBC1, 0xF4FCFBC1, 0xF4FDFBC1, 0xF4FEFBC1, 0xF4FFFBC1, 0xF500FBC1, 0xF501FBC1, 0xF502FBC1, 0xF503FBC1, 0xF504FBC1, 0xF505FBC1, 0xF506FBC1, 0xF507FBC1, 0xF508FBC1, 0xF509FBC1, 0xF50AFBC1, 0xF50BFBC1, 0xF50CFBC1, 0xF50DFBC1, 0xF50EFBC1, 0xF50FFBC1, 0xF510FBC1, 0xF511FBC1, 0xF512FBC1, 0xF513FBC1, /* F46A */
+ 0xF514FBC1, 0xF515FBC1, 0xF516FBC1, 0xF517FBC1, 0xF518FBC1, 0xF519FBC1, 0xF51AFBC1, 0xF51BFBC1, 0xF51CFBC1, 0xF51DFBC1, 0xF51EFBC1, 0xF51FFBC1, 0xF520FBC1, 0xF521FBC1, 0xF522FBC1, 0xF523FBC1, 0xF524FBC1, 0xF525FBC1, 0xF526FBC1, 0xF527FBC1, 0xF528FBC1, 0xF529FBC1, 0xF52AFBC1, 0xF52BFBC1, 0xF52CFBC1, 0xF52DFBC1, 0xF52EFBC1, 0xF52FFBC1, 0xF530FBC1, 0xF531FBC1, 0xF532FBC1, 0xF533FBC1, 0xF534FBC1, 0xF535FBC1, 0xF536FBC1, 0xF537FBC1, 0xF538FBC1, 0xF539FBC1, 0xF53AFBC1, 0xF53BFBC1, 0xF53CFBC1, 0xF53DFBC1, 0xF53EFBC1, 0xF53FFBC1, 0xF540FBC1, 0xF541FBC1, 0xF542FBC1, 0xF543FBC1, 0xF544FBC1, 0xF545FBC1, 0xF546FBC1, 0xF547FBC1, 0xF548FBC1, 0xF549FBC1, 0xF54AFBC1, 0xF54BFBC1, 0xF54CFBC1, 0xF54DFBC1, 0xF54EFBC1, 0xF54FFBC1, 0xF550FBC1, 0xF551FBC1, 0xF552FBC1, 0xF553FBC1, 0xF554FBC1, 0xF555FBC1, 0xF556FBC1, 0xF557FBC1, 0xF558FBC1, 0xF559FBC1, 0xF55AFBC1, 0xF55BFBC1, 0xF55CFBC1, 0xF55DFBC1, 0xF55EFBC1, 0xF55FFBC1, 0xF560FBC1, 0xF561FBC1, 0xF562FBC1, 0xF563FBC1, 0xF564FBC1, 0xF565FBC1, 0xF566FBC1, 0xF567FBC1, 0xF568FBC1, 0xF569FBC1, 0xF56AFBC1, 0xF56BFBC1, 0xF56CFBC1, 0xF56DFBC1, 0xF56EFBC1, 0xF56FFBC1, 0xF570FBC1, 0xF571FBC1, 0xF572FBC1, 0xF573FBC1, 0xF574FBC1, 0xF575FBC1, 0xF576FBC1, 0xF577FBC1, 0xF578FBC1, 0xF579FBC1, 0xF57AFBC1, 0xF57BFBC1, 0xF57CFBC1, 0xF57DFBC1, 0xF57EFBC1, 0xF57FFBC1, 0xF580FBC1, 0xF581FBC1, 0xF582FBC1, 0xF583FBC1, 0xF584FBC1, 0xF585FBC1, 0xF586FBC1, 0xF587FBC1, 0xF588FBC1, 0xF589FBC1, 0xF58AFBC1, 0xF58BFBC1, 0xF58CFBC1, 0xF58DFBC1, 0xF58EFBC1, 0xF58FFBC1, 0xF590FBC1, 0xF591FBC1, 0xF592FBC1, 0xF593FBC1, 0xF594FBC1, 0xF595FBC1, 0xF596FBC1, 0xF597FBC1, 0xF598FBC1, 0xF599FBC1, 0xF59AFBC1, 0xF59BFBC1, 0xF59CFBC1, 0xF59DFBC1, 0xF59EFBC1, 0xF59FFBC1, 0xF5A0FBC1, 0xF5A1FBC1, 0xF5A2FBC1, 0xF5A3FBC1, 0xF5A4FBC1, 0xF5A5FBC1, 0xF5A6FBC1, 0xF5A7FBC1, 0xF5A8FBC1, 0xF5A9FBC1, 0xF5AAFBC1, 0xF5ABFBC1, 0xF5ACFBC1, 0xF5ADFBC1, 0xF5AEFBC1, 0xF5AFFBC1, 0xF5B0FBC1, 0xF5B1FBC1, 0xF5B2FBC1, 0xF5B3FBC1, 0xF5B4FBC1, 0xF5B5FBC1, 0xF5B6FBC1, 0xF5B7FBC1, 0xF5B8FBC1, 0xF5B9FBC1, 0xF5BAFBC1, 0xF5BBFBC1, 0xF5BCFBC1, 0xF5BDFBC1, /* F514 */
+ 0xF5BEFBC1, 0xF5BFFBC1, 0xF5C0FBC1, 0xF5C1FBC1, 0xF5C2FBC1, 0xF5C3FBC1, 0xF5C4FBC1, 0xF5C5FBC1, 0xF5C6FBC1, 0xF5C7FBC1, 0xF5C8FBC1, 0xF5C9FBC1, 0xF5CAFBC1, 0xF5CBFBC1, 0xF5CCFBC1, 0xF5CDFBC1, 0xF5CEFBC1, 0xF5CFFBC1, 0xF5D0FBC1, 0xF5D1FBC1, 0xF5D2FBC1, 0xF5D3FBC1, 0xF5D4FBC1, 0xF5D5FBC1, 0xF5D6FBC1, 0xF5D7FBC1, 0xF5D8FBC1, 0xF5D9FBC1, 0xF5DAFBC1, 0xF5DBFBC1, 0xF5DCFBC1, 0xF5DDFBC1, 0xF5DEFBC1, 0xF5DFFBC1, 0xF5E0FBC1, 0xF5E1FBC1, 0xF5E2FBC1, 0xF5E3FBC1, 0xF5E4FBC1, 0xF5E5FBC1, 0xF5E6FBC1, 0xF5E7FBC1, 0xF5E8FBC1, 0xF5E9FBC1, 0xF5EAFBC1, 0xF5EBFBC1, 0xF5ECFBC1, 0xF5EDFBC1, 0xF5EEFBC1, 0xF5EFFBC1, 0xF5F0FBC1, 0xF5F1FBC1, 0xF5F2FBC1, 0xF5F3FBC1, 0xF5F4FBC1, 0xF5F5FBC1, 0xF5F6FBC1, 0xF5F7FBC1, 0xF5F8FBC1, 0xF5F9FBC1, 0xF5FAFBC1, 0xF5FBFBC1, 0xF5FCFBC1, 0xF5FDFBC1, 0xF5FEFBC1, 0xF5FFFBC1, 0xF600FBC1, 0xF601FBC1, 0xF602FBC1, 0xF603FBC1, 0xF604FBC1, 0xF605FBC1, 0xF606FBC1, 0xF607FBC1, 0xF608FBC1, 0xF609FBC1, 0xF60AFBC1, 0xF60BFBC1, 0xF60CFBC1, 0xF60DFBC1, 0xF60EFBC1, 0xF60FFBC1, 0xF610FBC1, 0xF611FBC1, 0xF612FBC1, 0xF613FBC1, 0xF614FBC1, 0xF615FBC1, 0xF616FBC1, 0xF617FBC1, 0xF618FBC1, 0xF619FBC1, 0xF61AFBC1, 0xF61BFBC1, 0xF61CFBC1, 0xF61DFBC1, 0xF61EFBC1, 0xF61FFBC1, 0xF620FBC1, 0xF621FBC1, 0xF622FBC1, 0xF623FBC1, 0xF624FBC1, 0xF625FBC1, 0xF626FBC1, 0xF627FBC1, 0xF628FBC1, 0xF629FBC1, 0xF62AFBC1, 0xF62BFBC1, 0xF62CFBC1, 0xF62DFBC1, 0xF62EFBC1, 0xF62FFBC1, 0xF630FBC1, 0xF631FBC1, 0xF632FBC1, 0xF633FBC1, 0xF634FBC1, 0xF635FBC1, 0xF636FBC1, 0xF637FBC1, 0xF638FBC1, 0xF639FBC1, 0xF63AFBC1, 0xF63BFBC1, 0xF63CFBC1, 0xF63DFBC1, 0xF63EFBC1, 0xF63FFBC1, 0xF640FBC1, 0xF641FBC1, 0xF642FBC1, 0xF643FBC1, 0xF644FBC1, 0xF645FBC1, 0xF646FBC1, 0xF647FBC1, 0xF648FBC1, 0xF649FBC1, 0xF64AFBC1, 0xF64BFBC1, 0xF64CFBC1, 0xF64DFBC1, 0xF64EFBC1, 0xF64FFBC1, 0xF650FBC1, 0xF651FBC1, 0xF652FBC1, 0xF653FBC1, 0xF654FBC1, 0xF655FBC1, 0xF656FBC1, 0xF657FBC1, 0xF658FBC1, 0xF659FBC1, 0xF65AFBC1, 0xF65BFBC1, 0xF65CFBC1, 0xF65DFBC1, 0xF65EFBC1, 0xF65FFBC1, 0xF660FBC1, 0xF661FBC1, 0xF662FBC1, 0xF663FBC1, 0xF664FBC1, 0xF665FBC1, 0xF666FBC1, 0xF667FBC1, /* F5BE */
+ 0xF668FBC1, 0xF669FBC1, 0xF66AFBC1, 0xF66BFBC1, 0xF66CFBC1, 0xF66DFBC1, 0xF66EFBC1, 0xF66FFBC1, 0xF670FBC1, 0xF671FBC1, 0xF672FBC1, 0xF673FBC1, 0xF674FBC1, 0xF675FBC1, 0xF676FBC1, 0xF677FBC1, 0xF678FBC1, 0xF679FBC1, 0xF67AFBC1, 0xF67BFBC1, 0xF67CFBC1, 0xF67DFBC1, 0xF67EFBC1, 0xF67FFBC1, 0xF680FBC1, 0xF681FBC1, 0xF682FBC1, 0xF683FBC1, 0xF684FBC1, 0xF685FBC1, 0xF686FBC1, 0xF687FBC1, 0xF688FBC1, 0xF689FBC1, 0xF68AFBC1, 0xF68BFBC1, 0xF68CFBC1, 0xF68DFBC1, 0xF68EFBC1, 0xF68FFBC1, 0xF690FBC1, 0xF691FBC1, 0xF692FBC1, 0xF693FBC1, 0xF694FBC1, 0xF695FBC1, 0xF696FBC1, 0xF697FBC1, 0xF698FBC1, 0xF699FBC1, 0xF69AFBC1, 0xF69BFBC1, 0xF69CFBC1, 0xF69DFBC1, 0xF69EFBC1, 0xF69FFBC1, 0xF6A0FBC1, 0xF6A1FBC1, 0xF6A2FBC1, 0xF6A3FBC1, 0xF6A4FBC1, 0xF6A5FBC1, 0xF6A6FBC1, 0xF6A7FBC1, 0xF6A8FBC1, 0xF6A9FBC1, 0xF6AAFBC1, 0xF6ABFBC1, 0xF6ACFBC1, 0xF6ADFBC1, 0xF6AEFBC1, 0xF6AFFBC1, 0xF6B0FBC1, 0xF6B1FBC1, 0xF6B2FBC1, 0xF6B3FBC1, 0xF6B4FBC1, 0xF6B5FBC1, 0xF6B6FBC1, 0xF6B7FBC1, 0xF6B8FBC1, 0xF6B9FBC1, 0xF6BAFBC1, 0xF6BBFBC1, 0xF6BCFBC1, 0xF6BDFBC1, 0xF6BEFBC1, 0xF6BFFBC1, 0xF6C0FBC1, 0xF6C1FBC1, 0xF6C2FBC1, 0xF6C3FBC1, 0xF6C4FBC1, 0xF6C5FBC1, 0xF6C6FBC1, 0xF6C7FBC1, 0xF6C8FBC1, 0xF6C9FBC1, 0xF6CAFBC1, 0xF6CBFBC1, 0xF6CCFBC1, 0xF6CDFBC1, 0xF6CEFBC1, 0xF6CFFBC1, 0xF6D0FBC1, 0xF6D1FBC1, 0xF6D2FBC1, 0xF6D3FBC1, 0xF6D4FBC1, 0xF6D5FBC1, 0xF6D6FBC1, 0xF6D7FBC1, 0xF6D8FBC1, 0xF6D9FBC1, 0xF6DAFBC1, 0xF6DBFBC1, 0xF6DCFBC1, 0xF6DDFBC1, 0xF6DEFBC1, 0xF6DFFBC1, 0xF6E0FBC1, 0xF6E1FBC1, 0xF6E2FBC1, 0xF6E3FBC1, 0xF6E4FBC1, 0xF6E5FBC1, 0xF6E6FBC1, 0xF6E7FBC1, 0xF6E8FBC1, 0xF6E9FBC1, 0xF6EAFBC1, 0xF6EBFBC1, 0xF6ECFBC1, 0xF6EDFBC1, 0xF6EEFBC1, 0xF6EFFBC1, 0xF6F0FBC1, 0xF6F1FBC1, 0xF6F2FBC1, 0xF6F3FBC1, 0xF6F4FBC1, 0xF6F5FBC1, 0xF6F6FBC1, 0xF6F7FBC1, 0xF6F8FBC1, 0xF6F9FBC1, 0xF6FAFBC1, 0xF6FBFBC1, 0xF6FCFBC1, 0xF6FDFBC1, 0xF6FEFBC1, 0xF6FFFBC1, 0xF700FBC1, 0xF701FBC1, 0xF702FBC1, 0xF703FBC1, 0xF704FBC1, 0xF705FBC1, 0xF706FBC1, 0xF707FBC1, 0xF708FBC1, 0xF709FBC1, 0xF70AFBC1, 0xF70BFBC1, 0xF70CFBC1, 0xF70DFBC1, 0xF70EFBC1, 0xF70FFBC1, 0xF710FBC1, 0xF711FBC1, /* F668 */
+ 0xF712FBC1, 0xF713FBC1, 0xF714FBC1, 0xF715FBC1, 0xF716FBC1, 0xF717FBC1, 0xF718FBC1, 0xF719FBC1, 0xF71AFBC1, 0xF71BFBC1, 0xF71CFBC1, 0xF71DFBC1, 0xF71EFBC1, 0xF71FFBC1, 0xF720FBC1, 0xF721FBC1, 0xF722FBC1, 0xF723FBC1, 0xF724FBC1, 0xF725FBC1, 0xF726FBC1, 0xF727FBC1, 0xF728FBC1, 0xF729FBC1, 0xF72AFBC1, 0xF72BFBC1, 0xF72CFBC1, 0xF72DFBC1, 0xF72EFBC1, 0xF72FFBC1, 0xF730FBC1, 0xF731FBC1, 0xF732FBC1, 0xF733FBC1, 0xF734FBC1, 0xF735FBC1, 0xF736FBC1, 0xF737FBC1, 0xF738FBC1, 0xF739FBC1, 0xF73AFBC1, 0xF73BFBC1, 0xF73CFBC1, 0xF73DFBC1, 0xF73EFBC1, 0xF73FFBC1, 0xF740FBC1, 0xF741FBC1, 0xF742FBC1, 0xF743FBC1, 0xF744FBC1, 0xF745FBC1, 0xF746FBC1, 0xF747FBC1, 0xF748FBC1, 0xF749FBC1, 0xF74AFBC1, 0xF74BFBC1, 0xF74CFBC1, 0xF74DFBC1, 0xF74EFBC1, 0xF74FFBC1, 0xF750FBC1, 0xF751FBC1, 0xF752FBC1, 0xF753FBC1, 0xF754FBC1, 0xF755FBC1, 0xF756FBC1, 0xF757FBC1, 0xF758FBC1, 0xF759FBC1, 0xF75AFBC1, 0xF75BFBC1, 0xF75CFBC1, 0xF75DFBC1, 0xF75EFBC1, 0xF75FFBC1, 0xF760FBC1, 0xF761FBC1, 0xF762FBC1, 0xF763FBC1, 0xF764FBC1, 0xF765FBC1, 0xF766FBC1, 0xF767FBC1, 0xF768FBC1, 0xF769FBC1, 0xF76AFBC1, 0xF76BFBC1, 0xF76CFBC1, 0xF76DFBC1, 0xF76EFBC1, 0xF76FFBC1, 0xF770FBC1, 0xF771FBC1, 0xF772FBC1, 0xF773FBC1, 0xF774FBC1, 0xF775FBC1, 0xF776FBC1, 0xF777FBC1, 0xF778FBC1, 0xF779FBC1, 0xF77AFBC1, 0xF77BFBC1, 0xF77CFBC1, 0xF77DFBC1, 0xF77EFBC1, 0xF77FFBC1, 0xF780FBC1, 0xF781FBC1, 0xF782FBC1, 0xF783FBC1, 0xF784FBC1, 0xF785FBC1, 0xF786FBC1, 0xF787FBC1, 0xF788FBC1, 0xF789FBC1, 0xF78AFBC1, 0xF78BFBC1, 0xF78CFBC1, 0xF78DFBC1, 0xF78EFBC1, 0xF78FFBC1, 0xF790FBC1, 0xF791FBC1, 0xF792FBC1, 0xF793FBC1, 0xF794FBC1, 0xF795FBC1, 0xF796FBC1, 0xF797FBC1, 0xF798FBC1, 0xF799FBC1, 0xF79AFBC1, 0xF79BFBC1, 0xF79CFBC1, 0xF79DFBC1, 0xF79EFBC1, 0xF79FFBC1, 0xF7A0FBC1, 0xF7A1FBC1, 0xF7A2FBC1, 0xF7A3FBC1, 0xF7A4FBC1, 0xF7A5FBC1, 0xF7A6FBC1, 0xF7A7FBC1, 0xF7A8FBC1, 0xF7A9FBC1, 0xF7AAFBC1, 0xF7ABFBC1, 0xF7ACFBC1, 0xF7ADFBC1, 0xF7AEFBC1, 0xF7AFFBC1, 0xF7B0FBC1, 0xF7B1FBC1, 0xF7B2FBC1, 0xF7B3FBC1, 0xF7B4FBC1, 0xF7B5FBC1, 0xF7B6FBC1, 0xF7B7FBC1, 0xF7B8FBC1, 0xF7B9FBC1, 0xF7BAFBC1, 0xF7BBFBC1, /* F712 */
+ 0xF7BCFBC1, 0xF7BDFBC1, 0xF7BEFBC1, 0xF7BFFBC1, 0xF7C0FBC1, 0xF7C1FBC1, 0xF7C2FBC1, 0xF7C3FBC1, 0xF7C4FBC1, 0xF7C5FBC1, 0xF7C6FBC1, 0xF7C7FBC1, 0xF7C8FBC1, 0xF7C9FBC1, 0xF7CAFBC1, 0xF7CBFBC1, 0xF7CCFBC1, 0xF7CDFBC1, 0xF7CEFBC1, 0xF7CFFBC1, 0xF7D0FBC1, 0xF7D1FBC1, 0xF7D2FBC1, 0xF7D3FBC1, 0xF7D4FBC1, 0xF7D5FBC1, 0xF7D6FBC1, 0xF7D7FBC1, 0xF7D8FBC1, 0xF7D9FBC1, 0xF7DAFBC1, 0xF7DBFBC1, 0xF7DCFBC1, 0xF7DDFBC1, 0xF7DEFBC1, 0xF7DFFBC1, 0xF7E0FBC1, 0xF7E1FBC1, 0xF7E2FBC1, 0xF7E3FBC1, 0xF7E4FBC1, 0xF7E5FBC1, 0xF7E6FBC1, 0xF7E7FBC1, 0xF7E8FBC1, 0xF7E9FBC1, 0xF7EAFBC1, 0xF7EBFBC1, 0xF7ECFBC1, 0xF7EDFBC1, 0xF7EEFBC1, 0xF7EFFBC1, 0xF7F0FBC1, 0xF7F1FBC1, 0xF7F2FBC1, 0xF7F3FBC1, 0xF7F4FBC1, 0xF7F5FBC1, 0xF7F6FBC1, 0xF7F7FBC1, 0xF7F8FBC1, 0xF7F9FBC1, 0xF7FAFBC1, 0xF7FBFBC1, 0xF7FCFBC1, 0xF7FDFBC1, 0xF7FEFBC1, 0xF7FFFBC1, 0xF800FBC1, 0xF801FBC1, 0xF802FBC1, 0xF803FBC1, 0xF804FBC1, 0xF805FBC1, 0xF806FBC1, 0xF807FBC1, 0xF808FBC1, 0xF809FBC1, 0xF80AFBC1, 0xF80BFBC1, 0xF80CFBC1, 0xF80DFBC1, 0xF80EFBC1, 0xF80FFBC1, 0xF810FBC1, 0xF811FBC1, 0xF812FBC1, 0xF813FBC1, 0xF814FBC1, 0xF815FBC1, 0xF816FBC1, 0xF817FBC1, 0xF818FBC1, 0xF819FBC1, 0xF81AFBC1, 0xF81BFBC1, 0xF81CFBC1, 0xF81DFBC1, 0xF81EFBC1, 0xF81FFBC1, 0xF820FBC1, 0xF821FBC1, 0xF822FBC1, 0xF823FBC1, 0xF824FBC1, 0xF825FBC1, 0xF826FBC1, 0xF827FBC1, 0xF828FBC1, 0xF829FBC1, 0xF82AFBC1, 0xF82BFBC1, 0xF82CFBC1, 0xF82DFBC1, 0xF82EFBC1, 0xF82FFBC1, 0xF830FBC1, 0xF831FBC1, 0xF832FBC1, 0xF833FBC1, 0xF834FBC1, 0xF835FBC1, 0xF836FBC1, 0xF837FBC1, 0xF838FBC1, 0xF839FBC1, 0xF83AFBC1, 0xF83BFBC1, 0xF83CFBC1, 0xF83DFBC1, 0xF83EFBC1, 0xF83FFBC1, 0xF840FBC1, 0xF841FBC1, 0xF842FBC1, 0xF843FBC1, 0xF844FBC1, 0xF845FBC1, 0xF846FBC1, 0xF847FBC1, 0xF848FBC1, 0xF849FBC1, 0xF84AFBC1, 0xF84BFBC1, 0xF84CFBC1, 0xF84DFBC1, 0xF84EFBC1, 0xF84FFBC1, 0xF850FBC1, 0xF851FBC1, 0xF852FBC1, 0xF853FBC1, 0xF854FBC1, 0xF855FBC1, 0xF856FBC1, 0xF857FBC1, 0xF858FBC1, 0xF859FBC1, 0xF85AFBC1, 0xF85BFBC1, 0xF85CFBC1, 0xF85DFBC1, 0xF85EFBC1, 0xF85FFBC1, 0xF860FBC1, 0xF861FBC1, 0xF862FBC1, 0xF863FBC1, 0xF864FBC1, 0xF865FBC1, /* F7BC */
+ 0xF866FBC1, 0xF867FBC1, 0xF868FBC1, 0xF869FBC1, 0xF86AFBC1, 0xF86BFBC1, 0xF86CFBC1, 0xF86DFBC1, 0xF86EFBC1, 0xF86FFBC1, 0xF870FBC1, 0xF871FBC1, 0xF872FBC1, 0xF873FBC1, 0xF874FBC1, 0xF875FBC1, 0xF876FBC1, 0xF877FBC1, 0xF878FBC1, 0xF879FBC1, 0xF87AFBC1, 0xF87BFBC1, 0xF87CFBC1, 0xF87DFBC1, 0xF87EFBC1, 0xF87FFBC1, 0xF880FBC1, 0xF881FBC1, 0xF882FBC1, 0xF883FBC1, 0xF884FBC1, 0xF885FBC1, 0xF886FBC1, 0xF887FBC1, 0xF888FBC1, 0xF889FBC1, 0xF88AFBC1, 0xF88BFBC1, 0xF88CFBC1, 0xF88DFBC1, 0xF88EFBC1, 0xF88FFBC1, 0xF890FBC1, 0xF891FBC1, 0xF892FBC1, 0xF893FBC1, 0xF894FBC1, 0xF895FBC1, 0xF896FBC1, 0xF897FBC1, 0xF898FBC1, 0xF899FBC1, 0xF89AFBC1, 0xF89BFBC1, 0xF89CFBC1, 0xF89DFBC1, 0xF89EFBC1, 0xF89FFBC1, 0xF8A0FBC1, 0xF8A1FBC1, 0xF8A2FBC1, 0xF8A3FBC1, 0xF8A4FBC1, 0xF8A5FBC1, 0xF8A6FBC1, 0xF8A7FBC1, 0xF8A8FBC1, 0xF8A9FBC1, 0xF8AAFBC1, 0xF8ABFBC1, 0xF8ACFBC1, 0xF8ADFBC1, 0xF8AEFBC1, 0xF8AFFBC1, 0xF8B0FBC1, 0xF8B1FBC1, 0xF8B2FBC1, 0xF8B3FBC1, 0xF8B4FBC1, 0xF8B5FBC1, 0xF8B6FBC1, 0xF8B7FBC1, 0xF8B8FBC1, 0xF8B9FBC1, 0xF8BAFBC1, 0xF8BBFBC1, 0xF8BCFBC1, 0xF8BDFBC1, 0xF8BEFBC1, 0xF8BFFBC1, 0xF8C0FBC1, 0xF8C1FBC1, 0xF8C2FBC1, 0xF8C3FBC1, 0xF8C4FBC1, 0xF8C5FBC1, 0xF8C6FBC1, 0xF8C7FBC1, 0xF8C8FBC1, 0xF8C9FBC1, 0xF8CAFBC1, 0xF8CBFBC1, 0xF8CCFBC1, 0xF8CDFBC1, 0xF8CEFBC1, 0xF8CFFBC1, 0xF8D0FBC1, 0xF8D1FBC1, 0xF8D2FBC1, 0xF8D3FBC1, 0xF8D4FBC1, 0xF8D5FBC1, 0xF8D6FBC1, 0xF8D7FBC1, 0xF8D8FBC1, 0xF8D9FBC1, 0xF8DAFBC1, 0xF8DBFBC1, 0xF8DCFBC1, 0xF8DDFBC1, 0xF8DEFBC1, 0xF8DFFBC1, 0xF8E0FBC1, 0xF8E1FBC1, 0xF8E2FBC1, 0xF8E3FBC1, 0xF8E4FBC1, 0xF8E5FBC1, 0xF8E6FBC1, 0xF8E7FBC1, 0xF8E8FBC1, 0xF8E9FBC1, 0xF8EAFBC1, 0xF8EBFBC1, 0xF8ECFBC1, 0xF8EDFBC1, 0xF8EEFBC1, 0xF8EFFBC1, 0xF8F0FBC1, 0xF8F1FBC1, 0xF8F2FBC1, 0xF8F3FBC1, 0xF8F4FBC1, 0xF8F5FBC1, 0xF8F6FBC1, 0xF8F7FBC1, 0xF8F8FBC1, 0xF8F9FBC1, 0xF8FAFBC1, 0xF8FBFBC1, 0xF8FCFBC1, 0xF8FDFBC1, 0xF8FEFBC1, 0xF8FFFBC1, 0x8C48FB41, 0xE6F4FB40, 0x8ECAFB41, 0x8CC8FB41, 0xEED1FB40, 0xCE32FB40, 0xD3E5FB40, 0x9F9CFB41, 0x9F9CFB41, 0xD951FB40, 0x91D1FB41, 0xD587FB40, 0xD948FB40, 0xE1F6FB40, 0xF669FB40, 0xFF85FB40, /* F866 */
+ 0x863FFB41, 0x87BAFB41, 0x88F8FB41, 0x908FFB41, 0xEA02FB40, 0xED1BFB40, 0xF0D9FB40, 0xF3DEFB40, 0x843DFB41, 0x916AFB41, 0x99F1FB41, 0xCE82FB40, 0xD375FB40, 0xEB04FB40, 0xF21BFB40, 0x862DFB41, 0x9E1EFB41, 0xDD50FB40, 0xEFEBFB40, 0x85CDFB41, 0x8964FB41, 0xE2C9FB40, 0x81D8FB41, 0x881FFB41, 0xDECAFB40, 0xE717FB40, 0xED6AFB40, 0xF2FCFB40, 0x90CEFB41, 0xCF86FB40, 0xD1B7FB40, 0xD2DEFB40, 0xE4C4FB40, 0xEAD3FB40, 0xF210FB40, 0xF6E7FB40, 0x8001FB41, 0x8606FB41, 0x865CFB41, 0x8DEFFB41, 0x9732FB41, 0x9B6FFB41, 0x9DFAFB41, 0xF88CFB40, 0xF97FFB40, 0xFDA0FB40, 0x83C9FB41, 0x9304FB41, 0x9E7FFB41, 0x8AD6FB41, 0xD8DFFB40, 0xDF04FB40, 0xFC60FB40, 0x807EFB41, 0xF262FB40, 0xF8CAFB40, 0x8CC2FB41, 0x96F7FB41, 0xD8D8FB40, 0xDC62FB40, 0xEA13FB40, 0xEDDAFB40, 0xEF0FFB40, 0xFD2FFB40, 0xFE37FB40, 0x964BFB41, 0xD2D2FB40, 0x808BFB41, 0xD1DCFB40, 0xD1CCFB40, 0xFA1CFB40, 0xFDBEFB40, 0x83F1FB41, 0x9675FB41, 0x8B80FB41, 0xE2CFFB40, 0xEA02FB40, 0x8AFEFB41, 0xCE39FB40, 0xDBE7FB40, 0xE012FB40, 0xF387FB40, 0xF570FB40, 0xD317FB40, 0xF8FBFB40, 0xCFBFFB40, 0xDFA9FB40, 0xCE0DFB40, 0xECCCFB40, 0xE578FB40, 0xFD22FB40, 0xD3C3FB40, 0xD85EFB40, 0xF701FB40, 0x8449FB41, 0x8AAAFB41, 0xEBBAFB40, 0x8FB0FB41, 0xEC88FB40, 0xE2FEFB40, 0x82E5FB41, 0xE3A0FB40, 0xF565FB40, 0xCEAEFB40, 0xD169FB40, 0xD1C9FB40, 0xE881FB40, 0xFCE7FB40, 0x826FFB41, 0x8AD2FB41, 0x91CFFB41, 0xD2F5FB40, 0xD442FB40, 0xD973FB40, 0xDEECFB40, 0xE5C5FB40, 0xEFFEFB40, 0xF92AFB40, 0x95ADFB41, 0x9A6AFB41, 0x9E97FB41, 0x9ECEFB41, 0xD29BFB40, 0xE6C6FB40, 0xEB77FB40, 0x8F62FB41, 0xDE74FB40, 0xE190FB40, 0xE200FB40, 0xE49AFB40, 0xEF23FB40, 0xF149FB40, 0xF489FB40, 0xF9CAFB40, 0xFDF4FB40, 0x806FFB41, 0x8F26FB41, 0x84EEFB41, 0x9023FB41, 0x934AFB41, 0xD217FB40, 0xD2A3FB40, 0xD4BDFB40, 0xF0C8FB40, 0x88C2FB41, 0x8AAAFB41, 0xDEC9FB40, 0xDFF5FB40, 0xE37BFB40, 0xEBAEFB40, 0xFC3EFB40, 0xF375FB40, 0xCEE4FB40, 0xD6F9FB40, 0xDBE7FB40, 0xDDBAFB40, 0xE01CFB40, 0xF3B2FB40, 0xF469FB40, 0xFF9AFB40, 0x8046FB41, 0x9234FB41, 0x96F6FB41, 0x9748FB41, 0x9818FB41, 0xCF8BFB40, 0xF9AEFB40, 0x91B4FB41, 0x96B8FB41, 0xE0E1FB40, /* F910 */
+ 0xCE86FB40, 0xD0DAFB40, 0xDBEEFB40, 0xDC3FFB40, 0xE599FB40, 0xEA02FB40, 0xF1CEFB40, 0xF642FB40, 0x84FCFB41, 0x907CFB41, 0x9F8DFB41, 0xE688FB40, 0x962EFB41, 0xD289FB40, 0xE77BFB40, 0xE7F3FB40, 0xED41FB40, 0xEE9CFB40, 0xF409FB40, 0xF559FB40, 0xF86BFB40, 0xFD10FB40, 0x985EFB41, 0xD16DFB40, 0xE22EFB40, 0x9678FB41, 0xD02BFB40, 0xDD19FB40, 0xEDEAFB40, 0x8F2AFB41, 0xDF8BFB40, 0xE144FB40, 0xE817FB40, 0xF387FB40, 0x9686FB41, 0xD229FB40, 0xD40FFB40, 0xDC65FB40, 0xE613FB40, 0xE74EFB40, 0xE8A8FB40, 0xECE5FB40, 0xF406FB40, 0xF5E2FB40, 0xFF79FB40, 0x88CFFB41, 0x88E1FB41, 0x91CCFB41, 0x96E2FB41, 0xD33FFB40, 0xEEBAFB40, 0xD41DFB40, 0xF1D0FB40, 0xF498FB40, 0x85FAFB41, 0x96A3FB41, 0x9C57FB41, 0x9E9FFB41, 0xE797FB40, 0xEDCBFB40, 0x81E8FB41, 0xFACBFB40, 0xFB20FB40, 0xFC92FB40, 0xF2C0FB40, 0xF099FB40, 0x8B58FB41, 0xCEC0FB40, 0x8336FB41, 0xD23AFB40, 0xD207FB40, 0xDEA6FB40, 0xE2D3FB40, 0xFCD6FB40, 0xDB85FB40, 0xED1EFB40, 0xE6B4FB40, 0x8F3BFB41, 0x884CFB41, 0x964DFB41, 0x898BFB41, 0xDED3FB40, 0xD140FB40, 0xD5C0FB40, 0xFA0EFB41, 0xFA0FFB41, 0xD85AFB40, 0xFA11FB41, 0xE674FB40, 0xFA13FB41, 0xFA14FB41, 0xD1DEFB40, 0xF32AFB40, 0xF6CAFB40, 0xF93CFB40, 0xF95EFB40, 0xF965FB40, 0xF98FFB40, 0x9756FB41, 0xFCBEFB40, 0xFFBDFB40, 0xFA1FFB41, 0x8612FB41, 0xFA21FB41, 0x8AF8FB41, 0xFA23FB41, 0xFA24FB41, 0x9038FB41, 0x90FDFB41, 0xFA27FB41, 0xFA28FB41, 0xFA29FB41, 0x98EFFB41, 0x98FCFB41, 0x9928FB41, 0x9DB4FB41, 0xFA2EFBC1, 0xFA2FFBC1, 0xCFAEFB40, 0xD0E7FB40, 0xD14DFB40, 0xD2C9FB40, 0xD2E4FB40, 0xD351FB40, 0xD59DFB40, 0xD606FB40, 0xD668FB40, 0xD840FB40, 0xD8A8FB40, 0xDC64FB40, 0xDC6EFB40, 0xE094FB40, 0xE168FB40, 0xE18EFB40, 0xE1F2FB40, 0xE54FFB40, 0xE5E2FB40, 0xE691FB40, 0xE885FB40, 0xED77FB40, 0xEE1AFB40, 0xEF22FB40, 0xF16EFB40, 0xF22BFB40, 0xF422FB40, 0xF891FB40, 0xF93EFB40, 0xF949FB40, 0xF948FB40, 0xF950FB40, 0xF956FB40, 0xF95DFB40, 0xF98DFB40, 0xF98EFB40, 0xFA40FB40, 0xFA81FB40, 0xFBC0FB40, 0xFDF4FB40, 0xFE09FB40, 0xFE41FB40, 0xFF72FB40, 0x8005FB41, 0x81EDFB41, 0x8279FB41, 0x8279FB41, 0x8457FB41, 0x8910FB41, 0x8996FB41, 0x8B01FB41, 0x8B39FB41, /* F9BA */
+ 0x8CD3FB41, 0x8D08FB41, 0x8FB6FB41, 0x9038FB41, 0x96E3FB41, 0x97FFFB41, 0x983BFB41, 0xFA6BFBC1, 0xFA6CFBC1, 0xFA6DFBC1, 0xFA6EFBC1, 0xFA6FFBC1, 0xFA70FBC1, 0xFA71FBC1, 0xFA72FBC1, 0xFA73FBC1, 0xFA74FBC1, 0xFA75FBC1, 0xFA76FBC1, 0xFA77FBC1, 0xFA78FBC1, 0xFA79FBC1, 0xFA7AFBC1, 0xFA7BFBC1, 0xFA7CFBC1, 0xFA7DFBC1, 0xFA7EFBC1, 0xFA7FFBC1, 0xFA80FBC1, 0xFA81FBC1, 0xFA82FBC1, 0xFA83FBC1, 0xFA84FBC1, 0xFA85FBC1, 0xFA86FBC1, 0xFA87FBC1, 0xFA88FBC1, 0xFA89FBC1, 0xFA8AFBC1, 0xFA8BFBC1, 0xFA8CFBC1, 0xFA8DFBC1, 0xFA8EFBC1, 0xFA8FFBC1, 0xFA90FBC1, 0xFA91FBC1, 0xFA92FBC1, 0xFA93FBC1, 0xFA94FBC1, 0xFA95FBC1, 0xFA96FBC1, 0xFA97FBC1, 0xFA98FBC1, 0xFA99FBC1, 0xFA9AFBC1, 0xFA9BFBC1, 0xFA9CFBC1, 0xFA9DFBC1, 0xFA9EFBC1, 0xFA9FFBC1, 0xFAA0FBC1, 0xFAA1FBC1, 0xFAA2FBC1, 0xFAA3FBC1, 0xFAA4FBC1, 0xFAA5FBC1, 0xFAA6FBC1, 0xFAA7FBC1, 0xFAA8FBC1, 0xFAA9FBC1, 0xFAAAFBC1, 0xFAABFBC1, 0xFAACFBC1, 0xFAADFBC1, 0xFAAEFBC1, 0xFAAFFBC1, 0xFAB0FBC1, 0xFAB1FBC1, 0xFAB2FBC1, 0xFAB3FBC1, 0xFAB4FBC1, 0xFAB5FBC1, 0xFAB6FBC1, 0xFAB7FBC1, 0xFAB8FBC1, 0xFAB9FBC1, 0xFABAFBC1, 0xFABBFBC1, 0xFABCFBC1, 0xFABDFBC1, 0xFABEFBC1, 0xFABFFBC1, 0xFAC0FBC1, 0xFAC1FBC1, 0xFAC2FBC1, 0xFAC3FBC1, 0xFAC4FBC1, 0xFAC5FBC1, 0xFAC6FBC1, 0xFAC7FBC1, 0xFAC8FBC1, 0xFAC9FBC1, 0xFACAFBC1, 0xFACBFBC1, 0xFACCFBC1, 0xFACDFBC1, 0xFACEFBC1, 0xFACFFBC1, 0xFAD0FBC1, 0xFAD1FBC1, 0xFAD2FBC1, 0xFAD3FBC1, 0xFAD4FBC1, 0xFAD5FBC1, 0xFAD6FBC1, 0xFAD7FBC1, 0xFAD8FBC1, 0xFAD9FBC1, 0xFADAFBC1, 0xFADBFBC1, 0xFADCFBC1, 0xFADDFBC1, 0xFADEFBC1, 0xFADFFBC1, 0xFAE0FBC1, 0xFAE1FBC1, 0xFAE2FBC1, 0xFAE3FBC1, 0xFAE4FBC1, 0xFAE5FBC1, 0xFAE6FBC1, 0xFAE7FBC1, 0xFAE8FBC1, 0xFAE9FBC1, 0xFAEAFBC1, 0xFAEBFBC1, 0xFAECFBC1, 0xFAEDFBC1, 0xFAEEFBC1, 0xFAEFFBC1, 0xFAF0FBC1, 0xFAF1FBC1, 0xFAF2FBC1, 0xFAF3FBC1, 0xFAF4FBC1, 0xFAF5FBC1, 0xFAF6FBC1, 0xFAF7FBC1, 0xFAF8FBC1, 0xFAF9FBC1, 0xFAFAFBC1, 0xFAFBFBC1, 0xFAFCFBC1, 0xFAFDFBC1, 0xFAFEFBC1, 0xFAFFFBC1, 0xEB90EB9, 0xEFB0EB9, 0xF2E0EB9, 0xEFB0EB90EB9, 0xF2E0EB90EB9, 0x10020FEA, 0x10020FEA, 0xFB07FBC1, 0xFB08FBC1, 0xFB09FBC1, 0xFB0AFBC1, 0xFB0BFBC1, 0xFB0CFBC1, 0xFB0DFBC1, /* FA64 */
+ 0xFB0EFBC1, 0xFB0FFBC1, 0xFB10FBC1, 0xFB11FBC1, 0xFB12FBC1, 0x131F131D, 0x130E131D, 0x1314131D, 0x131F1327, 0x1316131D, 0xFB18FBC1, 0xFB19FBC1, 0xFB1AFBC1, 0xFB1BFBC1, 0xFB1CFBC1, 0x133A, 0, 0x133A133A, 0x1340, 0x1331, 0x1334, 0x1335, 0x133B, 0x133C, 0x133D, 0x1344, 0x1346, 0x428, 0x1345, 0x1345, 0x1345, 0x1345, 0x1331, 0x1331, 0x1331, 0x1332, 0x1333, 0x1334, 0x1335, 0x1336, 0x1337, 0xFB37FBC1, 0x1339, 0x133A, 0x133B, 0x133B, 0x133C, 0xFB3DFBC1, 0x133D, 0xFB3FFBC1, 0x133E, 0x133F, 0xFB42FBC1, 0x1341, 0x1341, 0xFB45FBC1, 0x1342, 0x1343, 0x1344, 0x1345, 0x1346, 0x1336, 0x1332, 0x133B, 0x1341, 0x133C1331, 0x134B, 0x134B, 0x1353, 0x1353, 0x1353, 0x1353, 0x1354, 0x1354, 0x1354, 0x1354, 0x1355, 0x1355, 0x1355, 0x1355, 0x135A, 0x135A, 0x135A, 0x135A, 0x135D, 0x135D, 0x135D, 0x135D, 0x1359, 0x1359, 0x1359, 0x1359, 0x1397, 0x1397, 0x1397, 0x1397, 0x1399, 0x1399, 0x1399, 0x1399, 0x1360, 0x1360, 0x1360, 0x1360, 0x135F, 0x135F, 0x135F, 0x135F, 0x1361, 0x1361, 0x1361, 0x1361, 0x1363, 0x1363, 0x1363, 0x1363, 0x1370, 0x1370, 0x136F, 0x136F, 0x1371, 0x1371, 0x136B, 0x136B, 0x137E, 0x137E, 0x1377, 0x1377, 0x139F, 0x139F, 0x139F, 0x139F, 0x13A5, 0x13A5, 0x13A5, 0x13A5, 0x13A9, 0x13A9, 0x13A9, 0x13A9, 0x13A7, 0x13A7, 0x13A7, 0x13A7, 0x13B2, 0x13B2, 0x13B3, 0x13B3, 0x13B3, 0x13B3, 0x13BC, 0x13BC, 0x13B9, 0x13B9, 0x13B9, 0x13B9, 0x13B8, 0x13B8, 0x13B8, 0x13B8, 0x13CE, 0x13CE, 0x13CE, 0x13CE, 0xFBB2FBC1, 0xFBB3FBC1, 0xFBB4FBC1, 0xFBB5FBC1, 0xFBB6FBC1, 0xFBB7FBC1, 0xFBB8FBC1, 0xFBB9FBC1, 0xFBBAFBC1, 0xFBBBFBC1, 0xFBBCFBC1, 0xFBBDFBC1, 0xFBBEFBC1, 0xFBBFFBC1, 0xFBC0FBC1, 0xFBC1FBC1, 0xFBC2FBC1, 0xFBC3FBC1, 0xFBC4FBC1, 0xFBC5FBC1, 0xFBC6FBC1, 0xFBC7FBC1, 0xFBC8FBC1, 0xFBC9FBC1, 0xFBCAFBC1, 0xFBCBFBC1, 0xFBCCFBC1, 0xFBCDFBC1, 0xFBCEFBC1, 0xFBCFFBC1, 0xFBD0FBC1, 0xFBD1FBC1, 0xFBD2FBC1, 0x13A3, 0x13A3, 0x13A3, 0x13A3, 0x13C1, 0x13C1, 0x13C0, 0x13C0, 0x13C2, 0x13C2, 0x134713C1, 0x13C5, 0x13C5, 0x13BF, 0x13BF, 0x13C3, 0x13C3, 0x13CC, 0x13CC, 0x13CC, 0x13CC, 0x13C7, 0x13C7, 0x1350134F, 0x1350134F, 0x13BC134F, 0x13BC134F, 0x13BD134F, /* FB0E */
+ 0x13BD134F, 0x13C1134F, 0x13C1134F, 0x13C0134F, 0x13C0134F, 0x13C2134F, 0x13C2134F, 0x13CC134F, 0x13CC134F, 0x13CC134F, 0x13C7134F, 0x13C7134F, 0x13C7134F, 0x13C9, 0x13C9, 0x13C9, 0x13C9, 0x135E134F, 0x1364134F, 0x13B0134F, 0x13C7134F, 0x13C8134F, 0x135E1352, 0x13641352, 0x13651352, 0x13B01352, 0x13C71352, 0x13C81352, 0x135E1357, 0x13641357, 0x13651357, 0x13B01357, 0x13C71357, 0x13C81357, 0x135E1358, 0x13B01358, 0x13C71358, 0x13C81358, 0x1364135E, 0x13B0135E, 0x135E1364, 0x13B01364, 0x135E1365, 0x13641365, 0x13B01365, 0x135E1381, 0x13641381, 0x13651381, 0x13B01381, 0x13641387, 0x13B01387, 0x135E1388, 0x13641388, 0x13651388, 0x13B01388, 0x1364138C, 0x13B0138C, 0x13B0138D, 0x135E138F, 0x13B0138F, 0x135E1390, 0x13B01390, 0x135E1393, 0x13641393, 0x13651393, 0x13B01393, 0x13C71393, 0x13C81393, 0x1364139B, 0x13B0139B, 0x13C7139B, 0x13C8139B, 0x1350139E, 0x135E139E, 0x1364139E, 0x1365139E, 0x13AB139E, 0x13B0139E, 0x13C7139E, 0x13C8139E, 0x135E13AB, 0x136413AB, 0x136513AB, 0x13B013AB, 0x13C713AB, 0x13C813AB, 0x135E13B0, 0x136413B0, 0x136513B0, 0x13B013B0, 0x13C713B0, 0x13C813B0, 0x135E13B1, 0x136413B1, 0x136513B1, 0x13B013B1, 0x13C713B1, 0x13C813B1, 0x135E13B7, 0x13B013B7, 0x13C713B7, 0x13C813B7, 0x135E13C8, 0x136413C8, 0x136513C8, 0x13B013C8, 0x13C713C8, 0x13C813C8, 0x136A, 0x1375, 0x13C7, 0, 0, 0, 0, 0, 0, 0x1375134F, 0x1376134F, 0x13B0134F, 0x13B1134F, 0x13C7134F, 0x13C8134F, 0x13751352, 0x13761352, 0x13B01352, 0x13B11352, 0x13C71352, 0x13C81352, 0x13751357, 0x13761357, 0x13B01357, 0x13B11357, 0x13C71357, 0x13C81357, 0x13751358, 0x13761358, 0x13B01358, 0x13B11358, 0x13C71358, 0x13C81358, 0x13C71393, 0x13C81393, 0x13C7139B, 0x13C8139B, 0x1350139E, 0x13AB139E, 0x13B0139E, 0x13C7139E, 0x13C8139E, 0x13B013AB, 0x13C713AB, 0x13C813AB, 0x135013B0, 0x13B013B0, 0x137513B1, 0x137613B1, 0x13B013B1, 0x13B113B1, 0x13C713B1, 0x13C813B1, 0x13C7, 0x137513C8, 0x137613C8, 0x13B013C8, 0x13B113C8, 0x13C713C8, 0x13C813C8, 0x135E134F, 0x1364134F, 0x1365134F, 0x13B0134F, 0x13B7134F, 0x135E1352, 0x13641352, 0x13651352, 0x13B01352, /* FBEF */
+ 0x13B71352, 0x135E1357, 0x13641357, 0x13651357, 0x13B01357, 0x13B71357, 0x13B01358, 0x1364135E, 0x13B0135E, 0x135E1364, 0x13B01364, 0x135E1365, 0x13B01365, 0x135E1381, 0x13641381, 0x13651381, 0x13B01381, 0x13641387, 0x13651387, 0x13B01387, 0x135E1388, 0x13641388, 0x13651388, 0x13B01388, 0x1364138C, 0x13B0138D, 0x135E138F, 0x13B0138F, 0x135E1390, 0x13B01390, 0x135E1393, 0x13641393, 0x13651393, 0x13B01393, 0x1364139B, 0x13B0139B, 0x135E139E, 0x1364139E, 0x1365139E, 0x13AB139E, 0x13B0139E, 0x135E13AB, 0x136413AB, 0x136513AB, 0x13B013AB, 0x13B713AB, 0x135E13B0, 0x136413B0, 0x136513B0, 0x13B013B0, 0x135E13B1, 0x136413B1, 0x136513B1, 0x13B013B1, 0x13B713B1, 0x135E13B7, 0x13B013B7, 0x13B7, 0x135E13C8, 0x136413C8, 0x136513C8, 0x13B013C8, 0x13B713C8, 0x13B0134F, 0x13B7134F, 0x13B01352, 0x13B71352, 0x13B01357, 0x13B71357, 0x13B01358, 0x13B71358, 0x13B01381, 0x13B71381, 0x13B01382, 0x13B71382, 0x13AB139E, 0x13B0139E, 0x13B013AB, 0x13B013B1, 0x13B713B1, 0x13B013C8, 0x13B713C8, 0, 0, 0, 0x13C7138C, 0x13C8138C, 0x13C7138F, 0x13C8138F, 0x13C71390, 0x13C81390, 0x13C71381, 0x13C81381, 0x13C71382, 0x13C81382, 0x13C71364, 0x13C81364, 0x13C7135E, 0x13C8135E, 0x13C71365, 0x13C81365, 0x13C71387, 0x13C81387, 0x13C71388, 0x13C81388, 0x135E1382, 0x13641382, 0x13651382, 0x13B01382, 0x13751382, 0x13751381, 0x13751387, 0x13751388, 0x13C7138C, 0x13C8138C, 0x13C7138F, 0x13C8138F, 0x13C71390, 0x13C81390, 0x13C71381, 0x13C81381, 0x13C71382, 0x13C81382, 0x13C71364, 0x13C81364, 0x13C7135E, 0x13C8135E, 0x13C71365, 0x13C81365, 0x13C71387, 0x13C81387, 0x13C71388, 0x13C81388, 0x135E1382, 0x13641382, 0x13651382, 0x13B01382, 0x13751382, 0x13751381, 0x13751387, 0x13751388, 0x135E1382, 0x13641382, 0x13651382, 0x13B01382, 0x13B71381, 0x13B71382, 0x13B0138C, 0x135E1381, 0x13641381, 0x13651381, 0x135E1382, 0x13641382, 0x13651382, 0x13B0138C, 0x13B0138D, 0x1350, 0x1350, 0x2C0, 0x2C1, 0xFD40FBC1, 0xFD41FBC1, 0xFD42FBC1, 0xFD43FBC1, 0xFD44FBC1, 0xFD45FBC1, 0xFD46FBC1, 0xFD47FBC1, 0xFD48FBC1, 0xFD49FBC1, 0xFD4AFBC1, 0xFD4BFBC1, 0xFD4CFBC1, 0xFD4DFBC1, /* FCA0 */
+ 0xFD4EFBC1, 0xFD4FFBC1, 0x13B0135E1357, 0x135E13641357, 0x135E13641357, 0x13B013641357, 0x13B013651357, 0x135E13B01357, 0x136413B01357, 0x136513B01357, 0x136413B0135E, 0x136413B0135E, 0x13C813B01364, 0x13C713B01364, 0x135E13641381, 0x1364135E1381, 0x13C7135E1381, 0x136413B01381, 0x136413B01381, 0x135E13B01381, 0x13B013B01381, 0x13B013B01381, 0x136413641387, 0x136413641387, 0x13B013B01387, 0x13B013641382, 0x13B013641382, 0x13C8135E1382, 0x136513B01382, 0x136513B01382, 0x13B013B01382, 0x13B013B01382, 0x13C713641388, 0x13B013651388, 0x13B013651388, 0x136413B0138C, 0x136413B0138C, 0x13B013B0138C, 0x13C813B0138C, 0x13B0135E138F, 0x13B013B0138F, 0x13B013B0138F, 0x13C713B0138F, 0x13B013B01390, 0x13C813B01390, 0x13C713B01390, 0x13B013651393, 0x13B013651393, 0x136413B0139B, 0x13B013B0139B, 0x13B0136413AB, 0x13C8136413AB, 0x13C7136413AB, 0x135E135E13AB, 0x135E135E13AB, 0x13B0136513AB, 0x13B0136513AB, 0x136413B013AB, 0x136413B013AB, 0x135E136413B0, 0x13B0136413B0, 0x13C8136413B0, 0x1364135E13B0, 0x13B0135E13B0, 0x135E136513B0, 0x13B0136513B0, 0xFD90FBC1, 0xFD91FBC1, 0x1365135E13B0, 0x135E13B013B7, 0x13B013B013B7, 0x13B0136413B1, 0x13C7136413B1, 0x13B0135E13B1, 0x13B0135E13B1, 0x13C7135E13B1, 0x13C813B013B1, 0x13C713B013B1, 0x13B013B013C8, 0x13B013B013C8, 0x13C813651352, 0x13C8135E1357, 0x13C7135E1357, 0x13C813651357, 0x13C713651357, 0x13C813B01357, 0x13C713B01357, 0x13C813B0135E, 0x13C71364135E, 0x13C713B0135E, 0x13C713651381, 0x13C813641387, 0x13C813641382, 0x13C813641388, 0x13C8135E13AB, 0x13C813B013AB, 0x13C8136413C8, 0x13C8135E13C8, 0x13C813B013C8, 0x13C813B013B0, 0x13C813B0139B, 0x13C8136413B1, 0x136413B0139B, 0x13B0136413AB, 0x13C813B0138F, 0x13C813B0139E, 0x1364135E13B1, 0x13C8136513B0, 0x13B0135E13AB, 0x13B013B0139E, 0x13B0135E13AB, 0x1364135E13B1, 0x13C81364135E, 0x13C8135E1364, 0x13C8135E13B0, 0x13C813B01393, 0x13C813641352, 0x13B013B0139E, 0x13B0135E138F, 0x13B013B01387, 0x13C813651381, 0x13C8135E13B1, 0xFDC8FBC1, 0xFDC9FBC1, 0xFDCAFBC1, 0xFDCBFBC1, 0xFDCCFBC1, 0xFDCDFBC1, 0xFDCEFBC1, 0xFDCFFBC1, 0xFDD0FBC1, /* FD4E */
+ 0xFDD1FBC1, 0xFDD2FBC1, 0xFDD3FBC1, 0xFDD4FBC1, 0xFDD5FBC1, 0xFDD6FBC1, 0xFDD7FBC1, 0xFDD8FBC1, 0xFDD9FBC1, 0xFDDAFBC1, 0xFDDBFBC1, 0xFDDCFBC1, 0xFDDDFBC1, 0xFDDEFBC1, 0xFDDFFBC1, 0xFDE0FBC1, 0xFDE1FBC1, 0xFDE2FBC1, 0xFDE3FBC1, 0xFDE4FBC1, 0xFDE5FBC1, 0xFDE6FBC1, 0xFDE7FBC1, 0xFDE8FBC1, 0xFDE9FBC1, 0xFDEAFBC1, 0xFDEBFBC1, 0xFDECFBC1, 0xFDEDFBC1, 0xFDEEFBC1, 0xFDEFFBC1, 0x13CE13AB1387, 0x13CE13AB139B, 0x13B713AB13AB1350, 0x13751352139E1350, 0x136913B0136413B0, 0x13B0138F13AB1387, 0x13AB13BD13811375, 0x13B713C813AB138F, 0x13B013AB138113BD, 0x13C713AB1387, 0xFDFAFBC1, 0xFFFD, 0x13AB135013C91375, 0x34F, 0xFDFEFBC1, 0xFDFFFBC1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFE10FBC1, 0xFE11FBC1, 0xFE12FBC1, 0xFE13FBC1, 0xFE14FBC1, 0xFE15FBC1, 0xFE16FBC1, 0xFE17FBC1, 0xFE18FBC1, 0xFE19FBC1, 0xFE1AFBC1, 0xFE1BFBC1, 0xFE1CFBC1, 0xFE1DFBC1, 0xFE1EFBC1, 0xFE1FFBC1, 0, 0, 0, 0, 0xFE24FBC1, 0xFE25FBC1, 0xFE26FBC1, 0xFE27FBC1, 0xFE28FBC1, 0xFE29FBC1, 0xFE2AFBC1, 0xFE2BFBC1, 0xFE2CFBC1, 0xFE2DFBC1, 0xFE2EFBC1, 0xFE2FFBC1, 0x25D025D, 0x228, 0x227, 0x21B, 0x21B, 0x288, 0x289, 0x28C, 0x28D, 0x2B8, 0x2B9, 0x2B6, 0x2B7, 0x2B0, 0x2B1, 0x2AE, 0x2AF, 0x2B2, 0x2B3, 0x2B4, 0x2B5, 0x238, 0x239, 0x28A, 0x28B, 0x211, 0x211, 0x211, 0x211, 0x21B, 0x21B, 0x21B, 0x22F, 0x237, 0x25D, 0xFE53FBC1, 0x23A, 0x23D, 0x255, 0x251, 0x228, 0x288, 0x289, 0x28C, 0x28D, 0x2B8, 0x2B9, 0x2D2, 0x2CF, 0x2C8, 0x428, 0x221, 0x42C, 0x42E, 0x42D, 0xFE67FBC1, 0x2CE, 0xE0F, 0x2D3, 0x2C7, 0xFE6CFBC1, 0xFE6DFBC1, 0xFE6EFBC1, 0xFE6FFBC1, 0, 0, 0, 0, 0, 0xFE75FBC1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1347, 0x1348, 0x1348, 0x1349, 0x1349, 0x134C, 0x134C, 0x134D, 0x134D, 0x134F, 0x134F, 0x134F, 0x134F, 0x1350, 0x1350, 0x1352, 0x1352, 0x1352, 0x1352, 0x1356, 0x1356, 0x1357, 0x1357, 0x1357, 0x1357, 0x1358, 0x1358, 0x1358, 0x1358, 0x135E, 0x135E, 0x135E, 0x135E, 0x1364, 0x1364, 0x1364, 0x1364, 0x1365, 0x1365, 0x1365, 0x1365, 0x1369, 0x1369, 0x136A, 0x136A, 0x1375, 0x1375, 0x1376, 0x1376, 0x1381, 0x1381, 0x1381, 0x1381, 0x1382, 0x1382, 0x1382, 0x1382, 0x1387, 0x1387, 0x1387, /* FDD1 */
+ 0x1387, 0x1388, 0x1388, 0x1388, 0x1388, 0x138C, 0x138C, 0x138C, 0x138C, 0x138D, 0x138D, 0x138D, 0x138D, 0x138F, 0x138F, 0x138F, 0x138F, 0x1390, 0x1390, 0x1390, 0x1390, 0x1393, 0x1393, 0x1393, 0x1393, 0x139B, 0x139B, 0x139B, 0x139B, 0x139E, 0x139E, 0x139E, 0x139E, 0x13AB, 0x13AB, 0x13AB, 0x13AB, 0x13B0, 0x13B0, 0x13B0, 0x13B0, 0x13B1, 0x13B1, 0x13B1, 0x13B1, 0x13B7, 0x13B7, 0x13B7, 0x13B7, 0x13BD, 0x13BD, 0x13C7, 0x13C7, 0x13C8, 0x13C8, 0x13C8, 0x13C8, 0x134813AB, 0x134813AB, 0x134913AB, 0x134913AB, 0x134D13AB, 0x134D13AB, 0x135013AB, 0x135013AB, 0xFEFDFBC1, 0xFEFEFBC1, 0, 0xFF00FBC1, 0x251, 0x27E, 0x2D2, 0xE0F, 0x2D3, 0x2CF, 0x277, 0x288, 0x289, 0x2C8, 0x428, 0x22F, 0x221, 0x25D, 0x2CC, 0xE29, 0xE2A, 0xE2B, 0xE2C, 0xE2D, 0xE2E, 0xE2F, 0xE30, 0xE31, 0xE32, 0x23D, 0x23A, 0x42C, 0x42D, 0x42E, 0x255, 0x2C7, 0xE33, 0xE4A, 0xE60, 0xE6D, 0xE8B, 0xEB9, 0xEC1, 0xEE1, 0xEFB, 0xF10, 0xF21, 0xF2E, 0xF5B, 0xF64, 0xF82, 0xFA7, 0xFB4, 0xFC0, 0xFEA, 0x1002, 0x101F, 0x1044, 0x1051, 0x105A, 0x105E, 0x106A, 0x28A, 0x2CE, 0x28B, 0x20F, 0x21B, 0x20C, 0xE33, 0xE4A, 0xE60, 0xE6D, 0xE8B, 0xEB9, 0xEC1, 0xEE1, 0xEFB, 0xF10, 0xF21, 0xF2E, 0xF5B, 0xF64, 0xF82, 0xFA7, 0xFB4, 0xFC0, 0xFEA, 0x1002, 0x101F, 0x1044, 0x1051, 0x105A, 0x105E, 0x106A, 0x28C, 0x430, 0x28D, 0x433, 0x29A, 0x29B, 0x266, 0x2B2, 0x2B3, 0x237, 0x22E, 0x1E80, 0x1E52, 0x1E53, 0x1E54, 0x1E55, 0x1E56, 0x1E75, 0x1E76, 0x1E77, 0x1E63, 0xE0B, 0x1E52, 0x1E53, 0x1E54, 0x1E55, 0x1E56, 0x1E57, 0x1E58, 0x1E59, 0x1E5A, 0x1E5B, 0x1E5C, 0x1E5D, 0x1E5E, 0x1E5F, 0x1E60, 0x1E61, 0x1E62, 0x1E63, 0x1E64, 0x1E65, 0x1E66, 0x1E67, 0x1E68, 0x1E69, 0x1E6A, 0x1E6B, 0x1E6C, 0x1E6D, 0x1E6E, 0x1E6F, 0x1E70, 0x1E71, 0x1E72, 0x1E73, 0x1E74, 0x1E75, 0x1E76, 0x1E77, 0x1E78, 0x1E79, 0x1E7A, 0x1E7B, 0x1E7C, 0x1E7D, 0x1E81, 0, 0, 0x1DBD, 0x1D62, 0x1D63, 0x1E02, 0x1D64, 0x1E04, 0x1E05, 0x1D65, 0x1D66, 0x1D67, 0x1E08, 0x1E09, 0x1E0A, 0x1E0B, 0x1E0C, 0x1E0D, 0x1D7C, 0x1D68, 0x1D69, 0x1D6A, 0x1D83, 0x1D6B, 0x1D6C, 0x1D6D, 0x1D6E, 0x1D6F, 0x1D70, 0x1D71, 0x1D72, 0x1D73, 0x1D74, 0xFFBFFBC1, 0xFFC0FBC1, /* FEBC */
+ 0xFFC1FBC1, 0x1DBE, 0x1DBF, 0x1DC0, 0x1DC1, 0x1DC2, 0x1DC3, 0xFFC8FBC1, 0xFFC9FBC1, 0x1DC4, 0x1DC5, 0x1DC6, 0x1DC7, 0x1DC8, 0x1DC9, 0xFFD0FBC1, 0xFFD1FBC1, 0x1DCA, 0x1DCB, 0x1DCC, 0x1DCD, 0x1DCE, 0x1DCF, 0xFFD8FBC1, 0xFFD9FBC1, 0x1DD0, 0x1DD1, 0x1DD2, 0xFFDDFBC1, 0xFFDEFBC1, 0xFFDFFBC1, 0xE0E, 0xE10, 0x42F, 0x210, 0x431, 0xE11, 0xE20, 0xFFE7FBC1, 0x5FE, 0x3AE, 0x3B0, 0x3AF, 0x3B1, 0x69C, 0x6C7, 0xFFEFFBC1, 0xFFF0FBC1, 0xFFF1FBC1, 0xFFF2FBC1, 0xFFF3FBC1, 0xFFF4FBC1, 0xFFF5FBC1, 0xFFF6FBC1, 0xFFF7FBC1, 0xFFF8FBC1, 0, 0, 0, 0xDC5, 0xDC6, 0xFFFEFBC1, 0xFFFFFBC1,
+ }
+ longRuneMap = map[rune][]uint64{
+ 0x321D: {0x1D6E1DC61D6D0288, 0x2891E031DC2}, 0x321E: {0x1D741DC61D6D0288, 0x2891DCB},
+ 0x327C: {0x1D621E0F1DBE1D70, 0x1DC6}, 0x3307: {0xE0B1E591E5E1E55, 0x1E65}, 0x3315: {0x1E781E591E7C1E58, 0x1E72},
+ 0x3316: {0xE0B1E731E7C1E58, 0x1E7A1E65}, 0x3317: {0x1E631E7D1E7C1E58, 0x1E65}, 0x3319: {0x1E651E721E781E59, 0x1E81},
+ 0x331A: {0x1E531E5F1E7A1E59, 0x1E7C}, 0x3320: {0xE0B1E621E811E5C, 0x1E72}, 0x332B: {0x1E811E5F0E0B1E6B, 0x1E65},
+ 0x332E: {0x1E651E5E1E521E6C, 0x1E7A}, 0x3332: {0x1E631E781E521E6D, 0x1E65}, 0x3334: {0x1E551E5D1E631E6D, 0x1E7A},
+ 0x3336: {0xE0B1E611E591E6E, 0x1E7A}, 0x3347: {0x1E771E5D1E811E70, 0x1E81}, 0x334A: {0xE0B1E6B1E791E71, 0x1E7A},
+ 0x3356: {0x1E5A1E651E811E7B, 0x1E81}, 0x337F: {0xDF0FFB40E82AFB40, 0xF93EFB40CF1AFB40}, 0x33AE: {0x4370E6D0E330FC0, 0xFEA},
+ 0x33AF: {0x4370E6D0E330FC0, 0xE2B0FEA}, 0xFDFB: {0x135E020913AB135E, 0x13B713AB135013AB},
+ }
+)
diff --git a/pkg/util/dbterror/terror.go b/pkg/util/dbterror/terror.go
new file mode 100644
index 0000000000000000000000000000000000000000..430bfbe7ede28b41876bd8660cd2d5d09e5a8d59
--- /dev/null
+++ b/pkg/util/dbterror/terror.go
@@ -0,0 +1,43 @@
+package dbterror
+
+import (
+ "github.com/pingcap/parser/terror"
+ "matrixbase/pkg/errno"
+)
+
+// ErrClass represents a class of errors.
+type ErrClass struct{ terror.ErrClass }
+
+// Error classes.
+var (
+ ClassAutoid = ErrClass{terror.ClassAutoid}
+ ClassDDL = ErrClass{terror.ClassDDL}
+ ClassDomain = ErrClass{terror.ClassDomain}
+ ClassExecutor = ErrClass{terror.ClassExecutor}
+ ClassExpression = ErrClass{terror.ClassExpression}
+ ClassAdmin = ErrClass{terror.ClassAdmin}
+ ClassKV = ErrClass{terror.ClassKV}
+ ClassMeta = ErrClass{terror.ClassMeta}
+ ClassOptimizer = ErrClass{terror.ClassOptimizer}
+ ClassPrivilege = ErrClass{terror.ClassPrivilege}
+ ClassSchema = ErrClass{terror.ClassSchema}
+ ClassServer = ErrClass{terror.ClassServer}
+ ClassStructure = ErrClass{terror.ClassStructure}
+ ClassVariable = ErrClass{terror.ClassVariable}
+ ClassXEval = ErrClass{terror.ClassXEval}
+ ClassTable = ErrClass{terror.ClassTable}
+ ClassTypes = ErrClass{terror.ClassTypes}
+ ClassJSON = ErrClass{terror.ClassJSON}
+ ClassTiKV = ErrClass{terror.ClassTiKV}
+ ClassSession = ErrClass{terror.ClassSession}
+ ClassPlugin = ErrClass{terror.ClassPlugin}
+ ClassUtil = ErrClass{terror.ClassUtil}
+)
+
+// NewStd calls New using the standard message for the error code
+// Attention:
+// this method is not goroutine-safe and
+// usually be used in global variable initializer
+func (ec ErrClass) NewStd(code terror.ErrCode) *terror.Error {
+ return ec.NewStdErr(code, errno.MySQLErrName[uint16(code)])
+}
diff --git a/pkg/util/hack/hack.go b/pkg/util/hack/hack.go
new file mode 100644
index 0000000000000000000000000000000000000000..849b64e8c0e4e5831d0dbdba15d4ecdde022c399
--- /dev/null
+++ b/pkg/util/hack/hack.go
@@ -0,0 +1,57 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package hack
+
+import (
+ "reflect"
+ "unsafe"
+)
+
+// MutableString can be used as string via string(MutableString) without performance loss.
+type MutableString string
+
+// String converts slice to MutableString without copy.
+// The MutableString can be converts to string without copy.
+// Use it at your own risk.
+func String(b []byte) (s MutableString) {
+ if len(b) == 0 {
+ return ""
+ }
+ pbytes := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+ pstring := (*reflect.StringHeader)(unsafe.Pointer(&s))
+ pstring.Data = pbytes.Data
+ pstring.Len = pbytes.Len
+ return
+}
+
+// Slice converts string to slice without copy.
+// Use at your own risk.
+func Slice(s string) (b []byte) {
+ pbytes := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+ pstring := (*reflect.StringHeader)(unsafe.Pointer(&s))
+ pbytes.Data = pstring.Data
+ pbytes.Len = pstring.Len
+ pbytes.Cap = pstring.Len
+ return
+}
+
+// LoadFactor is the maximum average load of a bucket that triggers growth is 6.5 in Golang Map.
+// Represent as LoadFactorNum/LoadFactorDen, to allow integer math.
+// They are from the golang definition. ref: https://github.com/golang/go/blob/go1.13.15/src/runtime/map.go#L68-L71
+const (
+ // LoadFactorNum is the numerator of load factor
+ LoadFactorNum = 13
+ // LoadFactorDen is the denominator of load factor
+ LoadFactorDen = 2
+)
diff --git a/pkg/util/hack/hack_test.go b/pkg/util/hack/hack_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9025a0a745898dbd72bfb6b355ea0f606e3b5a38
--- /dev/null
+++ b/pkg/util/hack/hack_test.go
@@ -0,0 +1,70 @@
+// Copyright 2015 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package hack
+
+import (
+ "bytes"
+ "testing"
+
+ . "github.com/pingcap/check"
+)
+
+func TestT(t *testing.T) {
+ TestingT(t)
+}
+
+func TestString(t *testing.T) {
+ b := []byte("hello world")
+ a := String(b)
+
+ if a != "hello world" {
+ t.Fatal(a)
+ }
+
+ b[0] = 'a'
+
+ if a != "aello world" {
+ t.Fatal(a)
+ }
+
+ b = append(b, "abc"...)
+ if a != "aello world" {
+ t.Fatalf("a:%v, b:%v", a, b)
+ }
+}
+
+func TestByte(t *testing.T) {
+ a := "hello world"
+
+ b := Slice(a)
+
+ if !bytes.Equal(b, []byte("hello world")) {
+ t.Fatal(string(b))
+ }
+}
+
+func TestMutable(t *testing.T) {
+ a := []byte{'a', 'b', 'c'}
+ b := String(a) // b is a mutable string.
+ c := string(b) // Warn, c is a mutable string
+ if c != "abc" {
+ t.Fatalf("assert fail")
+ }
+
+ // c changed after a is modified
+ a[0] = 's'
+ if c != "sbc" {
+ t.Fatal("test mutable string fail")
+ }
+}
diff --git a/pkg/util/math/math.go b/pkg/util/math/math.go
new file mode 100644
index 0000000000000000000000000000000000000000..3a2517832626119e08330978a760e77fab579438
--- /dev/null
+++ b/pkg/util/math/math.go
@@ -0,0 +1,50 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package math
+
+import "math"
+
+// Abs implement the abs function according to http://cavaliercoder.com/blog/optimized-abs-for-int64-in-go.html
+func Abs(n int64) int64 {
+ y := n >> 63
+ return (n ^ y) - y
+}
+
+// uintSizeTable is used as a table to do comparison to get uint length is faster than doing loop on division with 10
+var uintSizeTable = [21]uint64{
+ 0, // redundant 0 here, so to make function StrLenOfUint64Fast to count from 1 and return i directly
+ 9, 99, 999, 9999, 99999,
+ 999999, 9999999, 99999999, 999999999, 9999999999,
+ 99999999999, 999999999999, 9999999999999, 99999999999999, 999999999999999,
+ 9999999999999999, 99999999999999999, 999999999999999999, 9999999999999999999,
+ math.MaxUint64,
+} // math.MaxUint64 is 18446744073709551615 and it has 20 digits
+
+// StrLenOfUint64Fast efficiently calculate the string character lengths of an uint64 as input
+func StrLenOfUint64Fast(x uint64) int {
+ for i := 1; ; i++ {
+ if x <= uintSizeTable[i] {
+ return i
+ }
+ }
+}
+
+// StrLenOfInt64Fast efficiently calculate the string character lengths of an int64 as input
+func StrLenOfInt64Fast(x int64) int {
+ size := 0
+ if x < 0 {
+ size = 1 // add "-" sign on the length count
+ }
+ return size + StrLenOfUint64Fast(uint64(Abs(x)))
+}
diff --git a/pkg/util/math/math_test.go b/pkg/util/math/math_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1b34d285337118eb48491eb492c0bfd399f4766b
--- /dev/null
+++ b/pkg/util/math/math_test.go
@@ -0,0 +1,56 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package math
+
+import (
+ "math/rand"
+ "strconv"
+ "testing"
+
+ . "github.com/pingcap/check"
+)
+
+func TestT(t *testing.T) {
+ TestingT(t)
+}
+
+var _ = Suite(&testMath{})
+
+type testMath struct{}
+
+func (s *testMath) TestStrLenOfUint64Fast_RandomTestCases(c *C) {
+ for i := 0; i < 1000000; i++ {
+ num := rand.Uint64()
+ expected := len(strconv.FormatUint(num, 10))
+ actual := StrLenOfUint64Fast(num)
+ c.Assert(actual, Equals, expected)
+ }
+}
+
+func (s *testMath) TestStrLenOfUint64Fast_ManualTestCases(c *C) {
+ nums := [22]uint64{0,
+ 1, 12, 123, 1234, 12345,
+ 123456, 1234567, 12345678, 123456789, 1234567890,
+ 1234567891, 12345678912, 123456789123, 1234567891234, 12345678912345,
+ 123456789123456, 1234567891234567, 12345678912345678, 123456789123456789,
+ 123456789123457890,
+ ^uint64(0),
+ }
+
+ for _, num := range nums {
+ expected := len(strconv.FormatUint(num, 10))
+ actual := StrLenOfUint64Fast(num)
+ c.Assert(actual, Equals, expected)
+ }
+}
diff --git a/pkg/util/misc.go b/pkg/util/misc.go
new file mode 100644
index 0000000000000000000000000000000000000000..349ab7daee84c273cec0fbac64164198b266a96b
--- /dev/null
+++ b/pkg/util/misc.go
@@ -0,0 +1,97 @@
+package util
+
+import (
+ "crypto/tls"
+ "crypto/x509"
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser"
+ "github.com/pingcap/parser/terror"
+ "io/ioutil"
+ "matrixbase/pkg/config"
+)
+
+const (
+ // syntaxErrorPrefix is the common prefix for SQL syntax error in TiDB.
+ syntaxErrorPrefix = "You have an error in your SQL syntax; check the manual that corresponds to your DB version for the right syntax to use"
+)
+
+// SyntaxError converts parser error to syntax error.
+func SyntaxError(err error) error {
+ if err == nil {
+ return nil
+ }
+ // logutil.BgLogger().Debug("syntax error", zap.Error(err))
+
+ // If the error is already a terror with stack, pass it through.
+ if errors.HasStack(err) {
+ cause := errors.Cause(err)
+ if _, ok := cause.(*terror.Error); ok {
+ return err
+ }
+ }
+
+ return parser.ErrParse.GenWithStackByArgs(syntaxErrorPrefix, err.Error())
+}
+
+// SyntaxWarn converts parser warn to DB's syntax warn.
+func SyntaxWarn(err error) error {
+ if err == nil {
+ return nil
+ }
+ return parser.ErrParse.GenWithStackByArgs(syntaxErrorPrefix, err.Error())
+}
+
+func LoadTLSCertificates(ca, key, cert string) (tlsConfig *tls.Config, err error) {
+ if len(cert) == 0 || len(key) == 0 {
+ return
+ }
+
+ var tlsCert tls.Certificate
+ tlsCert, err = tls.LoadX509KeyPair(cert, key)
+ if err != nil {
+ // logutil.BgLogger().Warn("load x509 failed", zap.Error(err))
+ err = errors.Trace(err)
+ return
+ }
+
+ requireTLS := config.GetGlobalConfig().Security.RequireSecureTransport
+
+ // Try loading CA cert.
+ clientAuthPolicy := tls.NoClientCert
+ if requireTLS {
+ clientAuthPolicy = tls.RequestClientCert
+ }
+ var certPool *x509.CertPool
+ if len(ca) > 0 {
+ var caCert []byte
+ caCert, err = ioutil.ReadFile(ca)
+ if err != nil {
+ // logutil.BgLogger().Warn("read file failed", zap.Error(err))
+ err = errors.Trace(err)
+ return
+ }
+ certPool = x509.NewCertPool()
+ if certPool.AppendCertsFromPEM(caCert) {
+ if requireTLS {
+ clientAuthPolicy = tls.RequireAndVerifyClientCert
+ } else {
+ clientAuthPolicy = tls.VerifyClientCertIfGiven
+ }
+ }
+ }
+ tlsConfig = &tls.Config{
+ Certificates: []tls.Certificate{tlsCert},
+ ClientCAs: certPool,
+ ClientAuth: clientAuthPolicy,
+ }
+ return
+}
+
+// IsTLSExpiredError checks error is caused by TLS expired.
+func IsTLSExpiredError(err error) bool {
+ err = errors.Cause(err)
+ if inval, ok := err.(x509.CertificateInvalidError); !ok || inval.Reason != x509.Expired {
+ return false
+ }
+ return true
+}
diff --git a/pkg/util/parser/ast.go b/pkg/util/parser/ast.go
new file mode 100644
index 0000000000000000000000000000000000000000..82ffd0c34790a2c732a734e70290f96f330c9995
--- /dev/null
+++ b/pkg/util/parser/ast.go
@@ -0,0 +1,138 @@
+// Copyright 2020 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package parser
+
+import (
+ "strings"
+
+ "github.com/pingcap/parser/ast"
+ "github.com/pingcap/parser/format"
+ // "github.com/pingcap/tidb/util/logutil"
+ // "go.uber.org/zap"
+)
+
+// GetDefaultDB checks if all columns in the AST have explicit DBName. If not, return specified DBName.
+func GetDefaultDB(sel ast.StmtNode, dbName string) string {
+ implicitDB := &implicitDatabase{}
+ sel.Accept(implicitDB)
+ if implicitDB.hasImplicit {
+ return dbName
+ }
+ return ""
+}
+
+type implicitDatabase struct {
+ hasImplicit bool
+}
+
+func (i *implicitDatabase) Enter(in ast.Node) (out ast.Node, skipChildren bool) {
+ switch x := in.(type) {
+ case *ast.TableName:
+ if x.Schema.L == "" {
+ i.hasImplicit = true
+ }
+ return in, true
+ }
+ return in, i.hasImplicit
+}
+
+func (i *implicitDatabase) Leave(in ast.Node) (out ast.Node, ok bool) {
+ return in, true
+}
+
+func findTablePos(s, t string) int {
+ l := 0
+ for i := range s {
+ if s[i] == ' ' || s[i] == ',' {
+ if len(t) == i-l && strings.Compare(s[l:i], t) == 0 {
+ return l
+ }
+ l = i + 1
+ }
+ }
+ if len(t) == len(s)-l && strings.Compare(s[l:], t) == 0 {
+ return l
+ }
+ return -1
+}
+
+// SimpleCases captures simple SQL statements and uses string replacement instead of `restore` to improve performance.
+// See https://github.com/pingcap/tidb/issues/22398.
+func SimpleCases(node ast.StmtNode, defaultDB, origin string) (s string, ok bool) {
+ if len(origin) == 0 {
+ return "", false
+ }
+ insert, ok := node.(*ast.InsertStmt)
+ if !ok {
+ return "", false
+ }
+ if insert.Select != nil || insert.Setlist != nil || insert.OnDuplicate != nil || (insert.TableHints != nil && len(insert.TableHints) != 0) {
+ return "", false
+ }
+ join := insert.Table.TableRefs
+ if join.Tp != 0 || join.Right != nil {
+ return "", false
+ }
+ ts, ok := join.Left.(*ast.TableSource)
+ if !ok {
+ return "", false
+ }
+ tn, ok := ts.Source.(*ast.TableName)
+ if !ok {
+ return "", false
+ }
+ parenPos := strings.Index(origin, "(")
+ if parenPos == -1 {
+ return "", false
+ }
+ if strings.Contains(origin[:parenPos], ".") {
+ return origin, true
+ }
+ lower := strings.ToLower(origin[:parenPos])
+ pos := findTablePos(lower, tn.Name.L)
+ if pos == -1 {
+ return "", false
+ }
+ var builder strings.Builder
+ builder.WriteString(origin[:pos])
+ if tn.Schema.String() != "" {
+ builder.WriteString(tn.Schema.String())
+ } else {
+ builder.WriteString(defaultDB)
+ }
+ builder.WriteString(".")
+ builder.WriteString(origin[pos:])
+ return builder.String(), true
+}
+
+// RestoreWithDefaultDB returns restore strings for StmtNode with defaultDB
+// This function is customized for SQL bind usage.
+func RestoreWithDefaultDB(node ast.StmtNode, defaultDB, origin string) string {
+ if s, ok := SimpleCases(node, defaultDB, origin); ok {
+ return s
+ }
+ var sb strings.Builder
+ // Three flags for restore with default DB:
+ // 1. RestoreStringSingleQuotes specifies to use single quotes to surround the string;
+ // 2. RestoreSpacesAroundBinaryOperation specifies to add space around binary operation;
+ // 3. RestoreStringWithoutCharset specifies to not print charset before string;
+ // 4. RestoreNameBackQuotes specifies to use back quotes to surround the name;
+ ctx := format.NewRestoreCtx(format.RestoreStringSingleQuotes|format.RestoreSpacesAroundBinaryOperation|format.RestoreStringWithoutCharset|format.RestoreNameBackQuotes, &sb)
+ ctx.DefaultDB = defaultDB
+ if err := node.Restore(ctx); err != nil {
+ // logutil.BgLogger().Debug("[sql-bind] restore SQL failed", zap.Error(err))
+ return ""
+ }
+ return sb.String()
+}
diff --git a/pkg/util/parser/parser.go b/pkg/util/parser/parser.go
new file mode 100644
index 0000000000000000000000000000000000000000..101b4bd6f5a7a1442b9b14ed1ab87e6d6cec5390
--- /dev/null
+++ b/pkg/util/parser/parser.go
@@ -0,0 +1,100 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package parser
+
+import (
+ "strconv"
+ "unicode"
+
+ "github.com/pingcap/errors"
+)
+
+var (
+ // ErrPatternNotMatch represents an error that patterns doesn't match.
+ ErrPatternNotMatch = errors.New("Pattern not match")
+)
+
+// Match matches the `pat` at least `times`, and returns the match, the rest and the error
+func Match(buf string, pat func(byte) bool, times int) (string, string, error) {
+ var i int
+ for i = 0; i < len(buf) && pat(buf[i]); i++ {
+ }
+ if i < times {
+ return "", buf, ErrPatternNotMatch
+ }
+ return buf[:i], buf[i:], nil
+}
+
+// MatchOne matches only one time with pat
+func MatchOne(buf string, pat func(byte) bool) (string, error) {
+ if len(buf) == 0 || !pat(buf[0]) {
+ return buf, ErrPatternNotMatch
+ }
+ return buf[1:], nil
+}
+
+// AnyPunct matches an arbitrary punctuation
+func AnyPunct(buf string) (string, error) {
+ return MatchOne(buf, func(b byte) bool {
+ return unicode.IsPunct(rune(b))
+ })
+}
+
+// AnyChar matches an arbitrary character
+func AnyChar(buf string) (string, error) {
+ return MatchOne(buf, func(byte) bool {
+ return true
+ })
+}
+
+// Char matches a character: c
+func Char(buf string, c byte) (string, error) {
+ return MatchOne(buf, func(x byte) bool {
+ return x == c
+ })
+}
+
+// Space matches at least `times` spaces
+func Space(buf string, times int) (string, error) {
+ _, rest, err := Match(buf, func(c byte) bool {
+ return unicode.IsSpace(rune(c))
+ }, times)
+ return rest, err
+}
+
+// Space0 matches at least 0 space.
+func Space0(buf string) string {
+ rest, err := Space(buf, 0)
+ if err != nil {
+ panic(err)
+ }
+ return rest
+}
+
+// Digit matches at least `times` digits
+func Digit(buf string, times int) (string, string, error) {
+ return Match(buf, func(c byte) bool {
+ return unicode.IsDigit(rune(c))
+ }, times)
+}
+
+// Number matches a series of digits and convert it to an int
+func Number(str string) (int, string, error) {
+ digits, rest, err := Digit(str, 1)
+ if err != nil {
+ return 0, str, err
+ }
+ num, err := strconv.Atoi(digits)
+ return num, rest, err
+}
diff --git a/pkg/util/parser/parser_test.go b/pkg/util/parser/parser_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..c92fa76a1162067ad2c240e3609e02588c906437
--- /dev/null
+++ b/pkg/util/parser/parser_test.go
@@ -0,0 +1,169 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package parser
+
+import (
+ "testing"
+
+ . "github.com/pingcap/check"
+)
+
+var _ = Suite(&testParserSuite{})
+
+type testParserSuite struct {
+}
+
+func TestT(t *testing.T) {
+ TestingT(t)
+}
+
+func (s *testParserSuite) TestSpace(c *C) {
+ okTable := []struct {
+ Times int
+ Input string
+ Expected string
+ }{
+ {0, " 1", "1"},
+ {0, "1", "1"},
+ {1, " 1", "1"},
+ {2, " 1", "1"},
+ }
+ for _, test := range okTable {
+ rest, err := Space(test.Input, test.Times)
+ c.Assert(rest, Equals, test.Expected)
+ c.Assert(err, IsNil)
+ }
+
+ errTable := []struct {
+ Times int
+ Input string
+ }{
+ {1, "1"},
+ {2, " 1"},
+ }
+
+ for _, test := range errTable {
+ rest, err := Space(test.Input, test.Times)
+ c.Assert(rest, Equals, test.Input)
+ c.Assert(err, NotNil)
+ }
+}
+
+func (s *testParserSuite) TestDigit(c *C) {
+ okTable := []struct {
+ Times int
+ Input string
+ ExpectedDigits string
+ ExpectedRest string
+ }{
+ {0, "123abc", "123", "abc"},
+ {1, "123abc", "123", "abc"},
+ {2, "123 @)@)", "123", " @)@)"},
+ {3, "456 121", "456", " 121"},
+ }
+
+ for _, test := range okTable {
+ digits, rest, err := Digit(test.Input, test.Times)
+ c.Assert(digits, Equals, test.ExpectedDigits)
+ c.Assert(rest, Equals, test.ExpectedRest)
+ c.Assert(err, IsNil)
+ }
+
+ errTable := []struct {
+ Times int
+ Input string
+ }{
+ {1, "int"},
+ {2, "1int"},
+ {3, "12 int"},
+ }
+
+ for _, test := range errTable {
+ digits, rest, err := Digit(test.Input, test.Times)
+ c.Assert(digits, Equals, "")
+ c.Assert(rest, Equals, test.Input)
+ c.Assert(err, NotNil)
+ }
+}
+
+func (s *testParserSuite) TestNumber(c *C) {
+ okTable := []struct {
+ Input string
+ ExpectedNum int
+ ExpectedRest string
+ }{
+ {"123abc", 123, "abc"},
+ {"123abc", 123, "abc"},
+ {"123 @)@)", 123, " @)@)"},
+ {"456 121", 456, " 121"},
+ }
+ for _, test := range okTable {
+ digits, rest, err := Number(test.Input)
+ c.Assert(digits, Equals, test.ExpectedNum)
+ c.Assert(rest, Equals, test.ExpectedRest)
+ c.Assert(err, IsNil)
+ }
+
+ errTable := []struct {
+ Input string
+ }{
+ {"int"},
+ {"abcint"},
+ {"@)@)int"},
+ }
+
+ for _, test := range errTable {
+ digits, rest, err := Number(test.Input)
+ c.Assert(digits, Equals, 0)
+ c.Assert(rest, Equals, test.Input)
+ c.Assert(err, NotNil)
+ }
+}
+
+func (s *testParserSuite) TestCharAndAnyChar(c *C) {
+ okTable := []struct {
+ Char byte
+ Input string
+ Expected string
+ }{
+ {'i', "int", "nt"},
+ {'1', "1int", "int"},
+ {'1', "12 int", "2 int"},
+ }
+
+ for _, test := range okTable {
+ rest, err := Char(test.Input, test.Char)
+ c.Assert(rest, Equals, test.Expected)
+ c.Assert(err, IsNil)
+
+ rest, err = AnyChar(test.Input)
+ c.Assert(rest, Equals, test.Expected)
+ c.Assert(err, IsNil)
+ }
+
+ errTable := []struct {
+ Char byte
+ Input string
+ }{
+ {'i', "xint"},
+ {'1', "x1int"},
+ {'1', "x12 int"},
+ }
+
+ for _, test := range errTable {
+ rest, err := Char(test.Input, test.Char)
+ c.Assert(rest, Equals, test.Input)
+ c.Assert(err, NotNil)
+ }
+}
diff --git a/pkg/util/processinfo.go b/pkg/util/processinfo.go
new file mode 100644
index 0000000000000000000000000000000000000000..1267c615a203ff7e5325d9822dfe37712336dbe0
--- /dev/null
+++ b/pkg/util/processinfo.go
@@ -0,0 +1,88 @@
+package util
+
+import (
+ "crypto/tls"
+ "sync/atomic"
+ "time"
+)
+
+type GlobalConnID struct {
+ ServerID uint64
+ LocalConnID uint64
+ Is64bits bool
+ ServerIDGetter func() uint64
+}
+
+const (
+ // MaxServerID is maximum serverID.
+ MaxServerID = 1<<22 - 1
+)
+
+// ProcessInfo is a struct used for show processlist statement.
+type ProcessInfo struct {
+ ID uint64
+ User string
+ Host string
+ Port string
+ DB string
+ Digest string
+ Plan interface{}
+ PlanExplainRows [][]string
+ // RuntimeStatsColl *execdetails.RuntimeStatsColl
+ Time time.Time
+ Info string
+ CurTxnStartTS uint64
+ // StmtCtx *stmtctx.StatementContext
+ // StatsInfo func(interface{}) map[string]uint64
+ // MaxExecutionTime is the timeout for select statement, in milliseconds.
+ // If the query takes too long, kill it.
+ MaxExecutionTime uint64
+
+ State uint16
+ Command byte
+ ExceedExpensiveTimeThresh bool
+ RedactSQL bool
+}
+
+// SessionManager is an interface for session manage. Show processlist and
+// kill statement rely on this interface.
+type SessionManager interface {
+ // ShowProcessList() map[uint64]*ProcessInfo
+ // GetProcessInfo(id uint64) (*ProcessInfo, bool)
+ Kill(connectionID uint64, query bool)
+ KillAllConnections()
+ UpdateTLSConfig(cfg *tls.Config)
+ // ServerID() uint64
+}
+
+func (g *GlobalConnID) makeID(localConnID uint64) uint64 {
+ var (
+ id uint64
+ serverID uint64
+ )
+ if g.ServerIDGetter != nil {
+ serverID = g.ServerIDGetter()
+ } else {
+ serverID = g.ServerID
+ }
+ if g.Is64bits {
+ id |= 0x1
+ id |= localConnID & 0xff_ffff_ffff << 1 // 40 bits local connID.
+ id |= serverID & MaxServerID << 41 // 22 bits serverID.
+ } else {
+ // TODO: update after new design for 32 bits version.
+ id |= localConnID & 0x7fff_ffff << 1 // 31 bits local connID.
+ }
+ return id
+}
+
+// ID returns the connection id
+func (g *GlobalConnID) ID() uint64 {
+ return g.makeID(g.LocalConnID)
+}
+
+// NextID returns next connection id
+func (g *GlobalConnID) NextID() uint64 {
+ localConnID := atomic.AddUint64(&g.LocalConnID, 1)
+ return g.makeID(localConnID)
+}
diff --git a/pkg/util/set/float64_set.go b/pkg/util/set/float64_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..31760962317f36497fb885a0ac186a03070383db
--- /dev/null
+++ b/pkg/util/set/float64_set.go
@@ -0,0 +1,42 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package set
+
+// Float64Set is a float64 set.
+type Float64Set map[float64]struct{}
+
+// NewFloat64Set builds a float64 set.
+func NewFloat64Set(fs ...float64) Float64Set {
+ x := make(Float64Set, len(fs))
+ for _, f := range fs {
+ x.Insert(f)
+ }
+ return x
+}
+
+// Exist checks whether `val` exists in `s`.
+func (s Float64Set) Exist(val float64) bool {
+ _, ok := s[val]
+ return ok
+}
+
+// Insert inserts `val` into `s`.
+func (s Float64Set) Insert(val float64) {
+ s[val] = struct{}{}
+}
+
+// Count returns the number in Set s.
+func (s Float64Set) Count() int {
+ return len(s)
+}
diff --git a/pkg/util/set/float64_set_test.go b/pkg/util/set/float64_set_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..a87f77dccd5ec59140c66380fdcc2033b4156542
--- /dev/null
+++ b/pkg/util/set/float64_set_test.go
@@ -0,0 +1,48 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package set
+
+import (
+ "testing"
+
+ "github.com/pingcap/check"
+)
+
+func TestT(t *testing.T) {
+ check.TestingT(t)
+}
+
+var _ = check.Suite(&float64SetTestSuite{})
+
+type float64SetTestSuite struct{}
+
+func (s *float64SetTestSuite) TestFloat64Set(c *check.C) {
+ set := NewFloat64Set()
+ vals := []float64{1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0}
+ for i := range vals {
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ }
+ c.Assert(set.Count(), check.Equals, len(vals))
+
+ c.Assert(len(set), check.Equals, len(vals))
+ for i := range vals {
+ c.Assert(set.Exist(vals[i]), check.IsTrue)
+ }
+
+ c.Assert(set.Exist(3), check.IsFalse)
+}
diff --git a/pkg/util/set/int_set.go b/pkg/util/set/int_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..9fde4ebc06c9d121411fc0c49c4075cf74c1d7c4
--- /dev/null
+++ b/pkg/util/set/int_set.go
@@ -0,0 +1,70 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package set
+
+// IntSet is a int set.
+type IntSet map[int]struct{}
+
+// NewIntSet builds a IntSet.
+func NewIntSet(is ...int) IntSet {
+ set := make(IntSet, len(is))
+ for _, x := range is {
+ set.Insert(x)
+ }
+ return set
+}
+
+// Exist checks whether `val` exists in `s`.
+func (s IntSet) Exist(val int) bool {
+ _, ok := s[val]
+ return ok
+}
+
+// Insert inserts `val` into `s`.
+func (s IntSet) Insert(val int) {
+ s[val] = struct{}{}
+}
+
+// Count returns the number in Set s.
+func (s IntSet) Count() int {
+ return len(s)
+}
+
+// Int64Set is a int64 set.
+type Int64Set map[int64]struct{}
+
+// NewInt64Set builds a Int64Set.
+func NewInt64Set(xs ...int64) Int64Set {
+ set := make(Int64Set, len(xs))
+ for _, x := range xs {
+ set.Insert(x)
+ }
+ return set
+}
+
+// Exist checks whether `val` exists in `s`.
+func (s Int64Set) Exist(val int64) bool {
+ _, ok := s[val]
+ return ok
+}
+
+// Insert inserts `val` into `s`.
+func (s Int64Set) Insert(val int64) {
+ s[val] = struct{}{}
+}
+
+// Count returns the number in Set s.
+func (s Int64Set) Count() int {
+ return len(s)
+}
diff --git a/pkg/util/set/int_set_test.go b/pkg/util/set/int_set_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..dcb50aa0cf61dc9fa95df313051ae3904428b9ff
--- /dev/null
+++ b/pkg/util/set/int_set_test.go
@@ -0,0 +1,67 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package set
+
+import (
+ "github.com/pingcap/check"
+)
+
+var _ = check.Suite(&intSetTestSuite{})
+
+type intSetTestSuite struct{}
+
+func (s *intSetTestSuite) TestIntSet(c *check.C) {
+ set := NewIntSet()
+ vals := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ for i := range vals {
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ }
+ c.Assert(set.Count(), check.Equals, len(vals))
+
+ c.Assert(len(set), check.Equals, len(vals))
+ for i := range vals {
+ c.Assert(set.Exist(vals[i]), check.IsTrue)
+ }
+
+ c.Assert(set.Exist(11), check.IsFalse)
+}
+
+func (s *intSetTestSuite) TestInt64Set(c *check.C) {
+ set := NewInt64Set()
+ vals := []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+ for i := range vals {
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ }
+
+ c.Assert(len(set), check.Equals, len(vals))
+ for i := range vals {
+ c.Assert(set.Exist(vals[i]), check.IsTrue)
+ }
+
+ c.Assert(set.Exist(11), check.IsFalse)
+
+ set = NewInt64Set(1, 2, 3, 4, 5, 6)
+ for i := 1; i < 7; i++ {
+ c.Assert(set.Exist(int64(i)), check.IsTrue)
+ }
+ c.Assert(set.Exist(7), check.IsFalse)
+}
diff --git a/pkg/util/set/set_with_memory_usage.go b/pkg/util/set/set_with_memory_usage.go
new file mode 100644
index 0000000000000000000000000000000000000000..0a5c2107cc86d0e4e2e553907fe6c3932b304d20
--- /dev/null
+++ b/pkg/util/set/set_with_memory_usage.go
@@ -0,0 +1,125 @@
+// Copyright 2021 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package set
+
+import (
+ "unsafe"
+
+ "matrixbase/pkg/util/hack"
+)
+
+const (
+ // DefStringSetBucketMemoryUsage = bucketSize*(1+unsafe.Sizeof(string) + unsafe.Sizeof(struct{}))+2*ptrSize
+ // ref https://github.com/golang/go/blob/go1.15.6/src/reflect/type.go#L2162.
+ DefStringSetBucketMemoryUsage = 8*(1+16+0) + 16
+ // DefFloat64SetBucketMemoryUsage = bucketSize*(1+unsafe.Sizeof(float64) + unsafe.Sizeof(struct{}))+2*ptrSize
+ DefFloat64SetBucketMemoryUsage = 8*(1+8+0) + 16
+ // DefInt64SetBucketMemoryUsage = bucketSize*(1+unsafe.Sizeof(int64) + unsafe.Sizeof(struct{}))+2*ptrSize
+ DefInt64SetBucketMemoryUsage = 8*(1+8+0) + 16
+
+ // DefFloat64Size is the size of float64
+ DefFloat64Size = int64(unsafe.Sizeof(float64(0)))
+ // DefInt64Size is the size of int64
+ DefInt64Size = int64(unsafe.Sizeof(int64(0)))
+)
+
+// StringSetWithMemoryUsage is a string set with memory usage.
+type StringSetWithMemoryUsage struct {
+ StringSet
+ bInMap int64
+}
+
+// NewStringSetWithMemoryUsage builds a string set.
+func NewStringSetWithMemoryUsage(ss ...string) (setWithMemoryUsage StringSetWithMemoryUsage, memDelta int64) {
+ set := make(StringSet, len(ss))
+ setWithMemoryUsage = StringSetWithMemoryUsage{
+ StringSet: set,
+ bInMap: 0,
+ }
+ memDelta = DefStringSetBucketMemoryUsage * (1 << setWithMemoryUsage.bInMap)
+ for _, s := range ss {
+ memDelta += setWithMemoryUsage.Insert(s)
+ }
+ return setWithMemoryUsage, memDelta
+}
+
+// Insert inserts `val` into `s` and return memDelta.
+func (s *StringSetWithMemoryUsage) Insert(val string) (memDelta int64) {
+ s.StringSet.Insert(val)
+ if s.Count() > (1<<s.bInMap)*hack.LoadFactorNum/hack.LoadFactorDen {
+ memDelta = DefStringSetBucketMemoryUsage * (1 << s.bInMap)
+ s.bInMap++
+ }
+ return memDelta + int64(len(val))
+}
+
+// Float64SetWithMemoryUsage is a float64 set with memory usage.
+type Float64SetWithMemoryUsage struct {
+ Float64Set
+ bInMap int64
+}
+
+// NewFloat64SetWithMemoryUsage builds a float64 set.
+func NewFloat64SetWithMemoryUsage(ss ...float64) (setWithMemoryUsage Float64SetWithMemoryUsage, memDelta int64) {
+ set := make(Float64Set, len(ss))
+ setWithMemoryUsage = Float64SetWithMemoryUsage{
+ Float64Set: set,
+ bInMap: 0,
+ }
+ memDelta = DefFloat64SetBucketMemoryUsage * (1 << setWithMemoryUsage.bInMap)
+ for _, s := range ss {
+ memDelta += setWithMemoryUsage.Insert(s)
+ }
+ return setWithMemoryUsage, memDelta
+}
+
+// Insert inserts `val` into `s` and return memDelta.
+func (s *Float64SetWithMemoryUsage) Insert(val float64) (memDelta int64) {
+ s.Float64Set.Insert(val)
+ if s.Count() > (1<<s.bInMap)*hack.LoadFactorNum/hack.LoadFactorDen {
+ memDelta = DefFloat64SetBucketMemoryUsage * (1 << s.bInMap)
+ s.bInMap++
+ }
+ return memDelta + DefFloat64Size
+}
+
+// Int64SetWithMemoryUsage is a int set with memory usage.
+type Int64SetWithMemoryUsage struct {
+ Int64Set
+ bInMap int64
+}
+
+// NewInt64SetWithMemoryUsage builds a int64 set.
+func NewInt64SetWithMemoryUsage(ss ...int64) (setWithMemoryUsage Int64SetWithMemoryUsage, memDelta int64) {
+ set := make(Int64Set, len(ss))
+ setWithMemoryUsage = Int64SetWithMemoryUsage{
+ Int64Set: set,
+ bInMap: 0,
+ }
+ memDelta = DefInt64SetBucketMemoryUsage * (1 << setWithMemoryUsage.bInMap)
+ for _, s := range ss {
+ memDelta += setWithMemoryUsage.Insert(s)
+ }
+ return setWithMemoryUsage, memDelta
+}
+
+// Insert inserts `val` into `s` and return memDelta.
+func (s *Int64SetWithMemoryUsage) Insert(val int64) (memDelta int64) {
+ s.Int64Set.Insert(val)
+ if s.Count() > (1<<s.bInMap)*hack.LoadFactorNum/hack.LoadFactorDen {
+ memDelta = DefInt64SetBucketMemoryUsage * (1 << s.bInMap)
+ s.bInMap++
+ }
+ return memDelta + DefInt64Size
+}
diff --git a/pkg/util/set/set_with_memory_usage_test.go b/pkg/util/set/set_with_memory_usage_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ed437f62f44867e07ecec687222528cb99a7d8f8
--- /dev/null
+++ b/pkg/util/set/set_with_memory_usage_test.go
@@ -0,0 +1,94 @@
+package set
+
+import (
+ "fmt"
+ "strconv"
+ "testing"
+)
+
+func BenchmarkFloat64SetMemoryUsage(b *testing.B) {
+ b.ReportAllocs()
+ type testCase struct {
+ rowNum int
+ }
+ cases := []testCase{
+ {rowNum: 0},
+ {rowNum: 100},
+ {rowNum: 10000},
+ {rowNum: 1000000},
+ {rowNum: 851968}, // 6.5 * (1 << 17)
+ {rowNum: 851969}, // 6.5 * (1 << 17) + 1
+ {rowNum: 425984}, // 6.5 * (1 << 16),
+ {rowNum: 425985}, // 6.5 * (1 << 16) + 1
+ }
+
+ for _, c := range cases {
+ b.Run(fmt.Sprintf("MapRows %v", c.rowNum), func(b *testing.B) {
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ float64Set, _ := NewFloat64SetWithMemoryUsage()
+ for num := 0; num < c.rowNum; num++ {
+ float64Set.Insert(float64(num))
+ }
+ }
+ })
+ }
+}
+
+func BenchmarkInt64SetMemoryUsage(b *testing.B) {
+ b.ReportAllocs()
+ type testCase struct {
+ rowNum int
+ }
+ cases := []testCase{
+ {rowNum: 0},
+ {rowNum: 100},
+ {rowNum: 10000},
+ {rowNum: 1000000},
+ {rowNum: 851968}, // 6.5 * (1 << 17)
+ {rowNum: 851969}, // 6.5 * (1 << 17) + 1
+ {rowNum: 425984}, // 6.5 * (1 << 16)
+ {rowNum: 425985}, // 6.5 * (1 << 16) + 1
+ }
+
+ for _, c := range cases {
+ b.Run(fmt.Sprintf("MapRows %v", c.rowNum), func(b *testing.B) {
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ int64Set, _ := NewInt64SetWithMemoryUsage()
+ for num := 0; num < c.rowNum; num++ {
+ int64Set.Insert(int64(num))
+ }
+ }
+ })
+ }
+}
+
+func BenchmarkStringSetMemoryUsage(b *testing.B) {
+ b.ReportAllocs()
+ type testCase struct {
+ rowNum int
+ }
+ cases := []testCase{
+ {rowNum: 0},
+ {rowNum: 100},
+ {rowNum: 10000},
+ {rowNum: 1000000},
+ {rowNum: 851968}, // 6.5 * (1 << 17)
+ {rowNum: 851969}, // 6.5 * (1 << 17) + 1
+ {rowNum: 425984}, // 6.5 * (1 << 16)
+ {rowNum: 425985}, // 6.5 * (1 << 16) + 1
+ }
+
+ for _, c := range cases {
+ b.Run(fmt.Sprintf("MapRows %v", c.rowNum), func(b *testing.B) {
+ b.ReportAllocs()
+ for i := 0; i < b.N; i++ {
+ stringSet, _ := NewStringSetWithMemoryUsage()
+ for num := 0; num < c.rowNum; num++ {
+ stringSet.Insert(strconv.Itoa(num))
+ }
+ }
+ })
+ }
+}
diff --git a/pkg/util/set/string_set.go b/pkg/util/set/string_set.go
new file mode 100644
index 0000000000000000000000000000000000000000..1bd0dbf77dce5e63bc31c3e9137bed7450b9c804
--- /dev/null
+++ b/pkg/util/set/string_set.go
@@ -0,0 +1,53 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package set
+
+// StringSet is a string set.
+type StringSet map[string]struct{}
+
+// NewStringSet builds a string set.
+func NewStringSet(ss ...string) StringSet {
+ set := make(StringSet, len(ss))
+ for _, s := range ss {
+ set.Insert(s)
+ }
+ return set
+}
+
+// Exist checks whether `val` exists in `s`.
+func (s StringSet) Exist(val string) bool {
+ _, ok := s[val]
+ return ok
+}
+
+// Insert inserts `val` into `s`.
+func (s StringSet) Insert(val string) {
+ s[val] = struct{}{}
+}
+
+// Intersection returns the intersection of two sets
+func (s StringSet) Intersection(rhs StringSet) StringSet {
+ newSet := NewStringSet()
+ for elt := range s {
+ if rhs.Exist(elt) {
+ newSet.Insert(elt)
+ }
+ }
+ return newSet
+}
+
+// Count returns the number in Set s.
+func (s StringSet) Count() int {
+ return len(s)
+}
diff --git a/pkg/util/set/string_set_test.go b/pkg/util/set/string_set_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9d1959b22bb9e3be68bd56365a9fa9d9a5b0fe3b
--- /dev/null
+++ b/pkg/util/set/string_set_test.go
@@ -0,0 +1,64 @@
+// Copyright 2019 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package set
+
+import (
+ "fmt"
+
+ "github.com/pingcap/check"
+)
+
+var _ = check.Suite(&stringSetTestSuite{})
+
+type stringSetTestSuite struct{}
+
+func (s *stringSetTestSuite) TestStringSet(c *check.C) {
+ set := NewStringSet()
+ vals := []string{"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}
+ for i := range vals {
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ set.Insert(vals[i])
+ }
+ c.Assert(set.Count(), check.Equals, len(vals))
+
+ c.Assert(len(set), check.Equals, len(vals))
+ for i := range vals {
+ c.Assert(set.Exist(vals[i]), check.IsTrue)
+ }
+
+ c.Assert(set.Exist("11"), check.IsFalse)
+
+ set = NewStringSet("1", "2", "3", "4", "5", "6")
+ for i := 1; i < 7; i++ {
+ c.Assert(set.Exist(fmt.Sprintf("%d", i)), check.IsTrue)
+ }
+ c.Assert(set.Exist("7"), check.IsFalse)
+
+ s1 := NewStringSet("1", "2", "3")
+ s2 := NewStringSet("4", "2", "3")
+ s3 := s1.Intersection(s2)
+ c.Assert(s3, check.DeepEquals, NewStringSet("2", "3"))
+
+ s4 := NewStringSet("4", "5", "3")
+ c.Assert(s3.Intersection(s4), check.DeepEquals, NewStringSet("3"))
+
+ s5 := NewStringSet("4", "5")
+ c.Assert(s3.Intersection(s5), check.DeepEquals, NewStringSet())
+
+ s6 := NewStringSet()
+ c.Assert(s3.Intersection(s6), check.DeepEquals, NewStringSet())
+}
diff --git a/pkg/util/signal/signal_posix.go b/pkg/util/signal/signal_posix.go
new file mode 100644
index 0000000000000000000000000000000000000000..c67828bb98adc8803c47df952d9c380fee2e1869
--- /dev/null
+++ b/pkg/util/signal/signal_posix.go
@@ -0,0 +1,55 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// +build linux darwin freebsd unix
+
+package signal
+
+import (
+ "log"
+ "os"
+ "os/signal"
+ "runtime"
+ "syscall"
+ // "github.com/pingcap/tidb/util/logutil"
+ // "go.uber.org/zap"
+)
+
+// SetupSignalHandler setup signal handler for TiDB Server
+func SetupSignalHandler(shutdownFunc func(bool)) {
+ usrDefSignalChan := make(chan os.Signal, 1)
+
+ signal.Notify(usrDefSignalChan, syscall.SIGUSR1)
+ go func() {
+ buf := make([]byte, 1<<16)
+ for {
+ sig := <-usrDefSignalChan
+ if sig == syscall.SIGUSR1 {
+ stackLen := runtime.Stack(buf, true)
+ log.Printf("\n=== Got signal [%s] to dump goroutine stack. ===\n%s\n=== Finished dumping goroutine stack. ===\n", sig, buf[:stackLen])
+ }
+ }
+ }()
+
+ closeSignalChan := make(chan os.Signal, 1)
+ signal.Notify(closeSignalChan,
+ syscall.SIGHUP,
+ syscall.SIGINT,
+ syscall.SIGTERM,
+ syscall.SIGQUIT)
+
+ go func() {
+ sig := <-closeSignalChan
+ // logutil.BgLogger().Info("got signal to exit", zap.Stringer("signal", sig))
+ shutdownFunc(sig == syscall.SIGQUIT)
+ }()
+}
diff --git a/pkg/util/signal/signal_wasm.go b/pkg/util/signal/signal_wasm.go
new file mode 100644
index 0000000000000000000000000000000000000000..e177c5ef1845aa1bd5c50026eb6d3a67d146dc7b
--- /dev/null
+++ b/pkg/util/signal/signal_wasm.go
@@ -0,0 +1,18 @@
+// Copyright 2019-present PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package signal
+
+// SetupSignalHandler setup signal handler for TiDB Server
+func SetupSignalHandler(shutdownFunc func(bool)) {
+}
diff --git a/pkg/util/signal/signal_windows.go b/pkg/util/signal/signal_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..a1df4af927c7aa89fc9eaeff59b41f3f5e7c1a0e
--- /dev/null
+++ b/pkg/util/signal/signal_windows.go
@@ -0,0 +1,40 @@
+// Copyright 2018 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// +build windows
+
+package signal
+
+import (
+ "os"
+ "os/signal"
+ "syscall"
+ // "github.com/pingcap/tidb/util/logutil"
+ // "go.uber.org/zap"
+)
+
+// SetupSignalHandler setup signal handler for TiDB Server
+func SetupSignalHandler(shutdownFunc func(bool)) {
+ //todo deal with dump goroutine stack on windows
+ closeSignalChan := make(chan os.Signal, 1)
+ signal.Notify(closeSignalChan,
+ syscall.SIGHUP,
+ syscall.SIGINT,
+ syscall.SIGTERM,
+ syscall.SIGQUIT)
+
+ go func() {
+ sig := <-closeSignalChan
+ // logutil.BgLogger().Info("got signal to exit", zap.Stringer("signal", sig))
+ shutdownFunc(sig == syscall.SIGQUIT)
+ }()
+}
diff --git a/pkg/util/stringutil/string_util.go b/pkg/util/stringutil/string_util.go
new file mode 100644
index 0000000000000000000000000000000000000000..b08d4b19958676d77eb02c2b3996faca0ca30178
--- /dev/null
+++ b/pkg/util/stringutil/string_util.go
@@ -0,0 +1,364 @@
+package stringutil
+
+import (
+ "bytes"
+ "fmt"
+ "sort"
+ "strings"
+ "unicode/utf8"
+
+ "github.com/pingcap/errors"
+ "github.com/pingcap/parser/mysql"
+ "matrixbase/pkg/util/hack"
+)
+
+// ErrSyntax indicates that a value does not have the right syntax for the target type.
+var ErrSyntax = errors.New("invalid syntax")
+
+// UnquoteChar decodes the first character or byte in the escaped string
+// or character literal represented by the string s.
+// It returns four values:
+//
+// 1) value, the decoded Unicode code point or byte value;
+// 2) multibyte, a boolean indicating whether the decoded character requires a multibyte UTF-8 representation;
+// 3) tail, the remainder of the string after the character; and
+// 4) an error that will be nil if the character is syntactically valid.
+//
+// The second argument, quote, specifies the type of literal being parsed
+// and therefore which escaped quote character is permitted.
+// If set to a single quote, it permits the sequence \' and disallows unescaped '.
+// If set to a double quote, it permits \" and disallows unescaped ".
+// If set to zero, it does not permit either escape and allows both quote characters to appear unescaped.
+// Different with strconv.UnquoteChar, it permits unnecessary backslash.
+func UnquoteChar(s string, quote byte) (value []byte, tail string, err error) {
+ // easy cases
+ switch c := s[0]; {
+ case c == quote:
+ err = errors.Trace(ErrSyntax)
+ return
+ case c >= utf8.RuneSelf:
+ r, size := utf8.DecodeRuneInString(s)
+ if r == utf8.RuneError {
+ value = append(value, c)
+ return value, s[1:], nil
+ }
+ value = append(value, string(r)...)
+ return value, s[size:], nil
+ case c != '\\':
+ value = append(value, c)
+ return value, s[1:], nil
+ }
+ // hard case: c is backslash
+ if len(s) <= 1 {
+ err = errors.Trace(ErrSyntax)
+ return
+ }
+ c := s[1]
+ s = s[2:]
+ switch c {
+ case 'b':
+ value = append(value, '\b')
+ case 'n':
+ value = append(value, '\n')
+ case 'r':
+ value = append(value, '\r')
+ case 't':
+ value = append(value, '\t')
+ case 'Z':
+ value = append(value, '\032')
+ case '0':
+ value = append(value, '\000')
+ case '_', '%':
+ value = append(value, '\\')
+ value = append(value, c)
+ case '\\':
+ value = append(value, '\\')
+ case '\'', '"':
+ value = append(value, c)
+ default:
+ value = append(value, c)
+ }
+ tail = s
+ return
+}
+
+// Unquote interprets s as a single-quoted, double-quoted,
+// or backquoted Go string literal, returning the string value
+// that s quotes. For example: test=`"\"\n"` (hex: 22 5c 22 5c 6e 22)
+// should be converted to `"\n` (hex: 22 0a).
+func Unquote(s string) (t string, err error) {
+ n := len(s)
+ if n < 2 {
+ return "", errors.Trace(ErrSyntax)
+ }
+ quote := s[0]
+ if quote != s[n-1] {
+ return "", errors.Trace(ErrSyntax)
+ }
+ s = s[1 : n-1]
+ if quote != '"' && quote != '\'' {
+ return "", errors.Trace(ErrSyntax)
+ }
+ // Avoid allocation. No need to convert if there is no '\'
+ if strings.IndexByte(s, '\\') == -1 && strings.IndexByte(s, quote) == -1 {
+ return s, nil
+ }
+ buf := make([]byte, 0, 3*len(s)/2) // Try to avoid more allocations.
+ for len(s) > 0 {
+ mb, ss, err := UnquoteChar(s, quote)
+ if err != nil {
+ return "", errors.Trace(err)
+ }
+ s = ss
+ buf = append(buf, mb...)
+ }
+ return string(buf), nil
+}
+
+const (
+ // PatMatch is the enumeration value for per-character match.
+ PatMatch = iota + 1
+ // PatOne is the enumeration value for '_' match.
+ PatOne
+ // PatAny is the enumeration value for '%' match.
+ PatAny
+)
+
+// CompilePatternBytes is a adapter for `CompilePatternInner`, `pattern` can only be an ascii string.
+func CompilePatternBytes(pattern string, escape byte) (patChars, patTypes []byte) {
+ patWeights, patTypes := CompilePatternInner(pattern, escape)
+ patChars = []byte(string(patWeights))
+
+ return patChars, patTypes
+}
+
+// CompilePattern is a adapter for `CompilePatternInner`, `pattern` can be any unicode string.
+func CompilePattern(pattern string, escape byte) (patWeights []rune, patTypes []byte) {
+ return CompilePatternInner(pattern, escape)
+}
+
+// CompilePatternInner handles escapes and wild cards convert pattern characters and
+// pattern types.
+func CompilePatternInner(pattern string, escape byte) (patWeights []rune, patTypes []byte) {
+ runes := []rune(pattern)
+ escapeRune := rune(escape)
+ lenRunes := len(runes)
+ patWeights = make([]rune, lenRunes)
+ patTypes = make([]byte, lenRunes)
+ patLen := 0
+ for i := 0; i < lenRunes; i++ {
+ var tp byte
+ var r = runes[i]
+ switch r {
+ case escapeRune:
+ tp = PatMatch
+ if i < lenRunes-1 {
+ i++
+ r = runes[i]
+ if r == escapeRune || r == '_' || r == '%' {
+ // Valid escape.
+ } else {
+ // Invalid escape, fall back to escape byte.
+ // mysql will treat escape character as the origin value even
+ // the escape sequence is invalid in Go or C.
+ // e.g., \m is invalid in Go, but in MySQL we will get "m" for select '\m'.
+ // Following case is correct just for escape \, not for others like +.
+ // TODO: Add more checks for other escapes.
+ i--
+ r = escapeRune
+ }
+ }
+ case '_':
+ // %_ => _%
+ if patLen > 0 && patTypes[patLen-1] == PatAny {
+ tp = PatAny
+ r = '%'
+ patWeights[patLen-1], patTypes[patLen-1] = '_', PatOne
+ } else {
+ tp = PatOne
+ }
+ case '%':
+ // %% => %
+ if patLen > 0 && patTypes[patLen-1] == PatAny {
+ continue
+ }
+ tp = PatAny
+ default:
+ tp = PatMatch
+ }
+ patWeights[patLen] = r
+ patTypes[patLen] = tp
+ patLen++
+ }
+ patWeights = patWeights[:patLen]
+ patTypes = patTypes[:patLen]
+ return
+}
+
+func matchRune(a, b rune) bool {
+ return a == b
+ // We may reuse below code block when like function go back to case insensitive.
+ /*
+ if a == b {
+ return true
+ }
+ if a >= 'a' && a <= 'z' && a-caseDiff == b {
+ return true
+ }
+ return a >= 'A' && a <= 'Z' && a+caseDiff == b
+ */
+}
+
+// CompileLike2Regexp convert a like `lhs` to a regular expression
+func CompileLike2Regexp(str string) string {
+ patChars, patTypes := CompilePattern(str, '\\')
+ var result []rune
+ for i := 0; i < len(patChars); i++ {
+ switch patTypes[i] {
+ case PatMatch:
+ result = append(result, patChars[i])
+ case PatOne:
+ result = append(result, '.')
+ case PatAny:
+ result = append(result, '.', '*')
+ }
+ }
+ return string(result)
+}
+
+// DoMatchBytes is a adapter for `DoMatchInner`, `str` can only be an ascii string.
+func DoMatchBytes(str string, patChars, patTypes []byte) bool {
+ return DoMatchInner(str, []rune(string(patChars)), patTypes, matchRune)
+}
+
+// DoMatch is a adapter for `DoMatchInner`, `str` can be any unicode string.
+func DoMatch(str string, patChars []rune, patTypes []byte) bool {
+ return DoMatchInner(str, patChars, patTypes, matchRune)
+}
+
+// DoMatchInner matches the string with patChars and patTypes.
+// The algorithm has linear time complexity.
+// https://research.swtch.com/glob
+func DoMatchInner(str string, patWeights []rune, patTypes []byte, matcher func(a, b rune) bool) bool {
+ // TODO(bb7133): it is possible to get the rune one by one to avoid the cost of get them as a whole.
+ runes := []rune(str)
+ lenRunes := len(runes)
+ var rIdx, pIdx, nextRIdx, nextPIdx int
+ for pIdx < len(patWeights) || rIdx < lenRunes {
+ if pIdx < len(patWeights) {
+ switch patTypes[pIdx] {
+ case PatMatch:
+ if rIdx < lenRunes && matcher(runes[rIdx], patWeights[pIdx]) {
+ pIdx++
+ rIdx++
+ continue
+ }
+ case PatOne:
+ if rIdx < lenRunes {
+ pIdx++
+ rIdx++
+ continue
+ }
+ case PatAny:
+ // Try to match at sIdx.
+ // If that doesn't work out,
+ // restart at sIdx+1 next.
+ nextPIdx = pIdx
+ nextRIdx = rIdx + 1
+ pIdx++
+ continue
+ }
+ }
+ // Mismatch. Maybe restart.
+ if 0 < nextRIdx && nextRIdx <= lenRunes {
+ pIdx = nextPIdx
+ rIdx = nextRIdx
+ continue
+ }
+ return false
+ }
+ // Matched all of pattern to all of name. Success.
+ return true
+}
+
+// IsExactMatch return true if no wildcard character
+func IsExactMatch(patTypes []byte) bool {
+ for _, pt := range patTypes {
+ if pt != PatMatch {
+ return false
+ }
+ }
+ return true
+}
+
+// Copy deep copies a string.
+func Copy(src string) string {
+ return string(hack.Slice(src))
+}
+
+// StringerFunc defines string func implement fmt.Stringer.
+type StringerFunc func() string
+
+// String implements fmt.Stringer
+func (l StringerFunc) String() string {
+ return l()
+}
+
+// MemoizeStr returns memoized version of stringFunc.
+func MemoizeStr(l func() string) fmt.Stringer {
+ return StringerFunc(func() string {
+ return l()
+ })
+}
+
+// StringerStr defines a alias to normal string.
+// implement fmt.Stringer
+type StringerStr string
+
+// String implements fmt.Stringer
+func (i StringerStr) String() string {
+ return string(i)
+}
+
+// Escape the identifier for pretty-printing.
+// For instance, the identifier "foo `bar`" will become "`foo ``bar```".
+// The sqlMode controls whether to escape with backquotes (`) or double quotes
+// (`"`) depending on whether mysql.ModeANSIQuotes is enabled.
+func Escape(str string, sqlMode mysql.SQLMode) string {
+ var quote string
+ if sqlMode&mysql.ModeANSIQuotes != 0 {
+ quote = `"`
+ } else {
+ quote = "`"
+ }
+ return quote + strings.Replace(str, quote, quote+quote, -1) + quote
+}
+
+// BuildStringFromLabels construct config labels into string by following format:
+// "keyA=valueA,keyB=valueB"
+func BuildStringFromLabels(labels map[string]string) string {
+ if len(labels) < 1 {
+ return ""
+ }
+ s := make([]string, 0, len(labels))
+ for k := range labels {
+ s = append(s, k)
+ }
+ sort.Strings(s)
+ r := new(bytes.Buffer)
+ // visit labels by sorted key in order to make sure that result should be consistency
+ for _, key := range s {
+ r.WriteString(fmt.Sprintf("%s=%s,", key, labels[key]))
+ }
+ returned := r.String()
+ return returned[:len(returned)-1]
+}
+
+// GetTailSpaceCount returns the number of tailed spaces.
+func GetTailSpaceCount(str string) int64 {
+ length := len(str)
+ for length > 0 && str[length-1] == ' ' {
+ length--
+ }
+ return int64(len(str) - length)
+}