diff --git a/auth_object.go b/auth_object.go new file mode 100644 index 00000000..2da33a0f --- /dev/null +++ b/auth_object.go @@ -0,0 +1,387 @@ +package go_ora + +import ( + "bytes" + "crypto/aes" + "crypto/cipher" + "crypto/des" + "crypto/md5" + "crypto/rand" + "crypto/sha1" + "errors" + "fmt" + "go-ora/network" + "strconv" + "strings" + "time" +) + +// E infront of the variable means encrypted +type AuthObject struct { + EServerSessKey string + EClientSessKey string + EPassword string + ServerSessKey []byte + ClientSessKey []byte + KeyHash []byte + Salt string + VerifierType int + tcpNego *TCPNego +} + +func NewAuthObject(username string, password string, tcpNego *TCPNego, session *network.Session) (*AuthObject, error) { + ret := new(AuthObject) + ret.tcpNego = tcpNego + loop := true + for loop { + messageCode, err := session.GetByte() + if err != nil { + return nil, err + } + switch messageCode { + case 4: + session.Summary, err = network.NewSummary(session) + if err != nil { + return nil, err + } + if session.HasError() { + return nil, errors.New(session.GetError()) + } + loop = false + case 8: + dictLen, err := session.GetInt(4, true, true) + if err != nil { + return nil, err + } + for x := 0; x < dictLen; x++ { + key, val, num, err := session.GetKeyVal() + if err != nil { + return nil, err + } + if bytes.Compare(key, []byte("AUTH_SESSKEY")) == 0 { + ret.EServerSessKey = string(val) + } else if bytes.Compare(key, []byte("AUTH_VFR_DATA")) == 0 { + ret.Salt = string(val) + ret.VerifierType = num + } + } + default: + return nil, errors.New(fmt.Sprintf("message code error: received code %d and expected code is 8", messageCode)) + } + } + + var key []byte + padding := false + var err error + if ret.VerifierType == 2361 { + key, err = getKeyFromUserNameAndPassword(username, password) + if err != nil { + return nil, err + } + } else if ret.VerifierType == 6949 { + + if ret.tcpNego.ServerCompileTimeCaps[4]&2 == 0 { + padding = true + } + result, err := HexStringToBytes(ret.Salt) + if err != nil { + return nil, err + } + result = append([]byte(password), result...) + hash := sha1.New() + hash.Write(result) + key = hash.Sum(nil) // 20 byte key + key = append(key, 0, 0, 0, 0) // 24 byte key + + } else { + return nil, errors.New("unsupported verifier type") + } + // get the server session key + ret.ServerSessKey, err = decryptSessionKey(padding, key, ret.EServerSessKey) + if err != nil { + return nil, err + } + + // generate new key for client + ret.ClientSessKey = make([]byte, len(ret.ServerSessKey)) + for { + _, err = rand.Read(ret.ClientSessKey) + if err != nil { + return nil, err + } + if !bytes.Equal(ret.ClientSessKey, ret.ServerSessKey) { + break + } + } + + // encrypt the client key + ret.EClientSessKey, err = EncryptSessionKey(padding, key, ret.ClientSessKey) + if err != nil { + return nil, err + } + + // get the hash key form server and client session key + ret.KeyHash, err = CalculateKeysHash(ret.VerifierType, ret.ServerSessKey[16:], ret.ClientSessKey[16:]) + if err != nil { + return nil, err + } + + // encrypt the password + ret.EPassword, err = EncryptPassword(password, ret.KeyHash) + if err != nil { + return nil, err + } + return ret, nil +} + +func (obj *AuthObject) Write(connOption *network.ConnectionOption, mode LogonMode, session *network.Session) error { + session.ResetBuffer() + keyValSize := 22 + session.PutBytes([]byte{3, 0x73, 0}) + if len(connOption.UserID) > 0 { + session.PutInt(1, 1, false, false) + session.PutInt(len(connOption.UserID), 4, true, true) + } else { + session.PutBytes([]byte{0, 0}) + } + + if len(connOption.UserID) > 0 && len(obj.EPassword) > 0 { + mode |= UserAndPass + } + session.PutUint(int(mode), 4, true, true) + session.PutUint(1, 1, false, false) + session.PutUint(keyValSize, 4, true, true) + session.PutBytes([]byte{1, 1}) + if len(connOption.UserID) > 0 { + session.PutBytes([]byte(connOption.UserID)) + } + index := 0 + if len(obj.EClientSessKey) > 0 { + session.PutKeyValString("AUTH_SESSKEY", obj.EClientSessKey, 1) + index++ + } + if len(obj.EPassword) > 0 { + session.PutKeyValString("AUTH_PASSWORD", obj.EPassword, 0) + index++ + } + // if newpassword encrypt and add { + // session.PutKeyValString("AUTH_NEWPASSWORD", ENewPassword, 0) + // index ++ + //} + session.PutKeyValString("AUTH_TERMINAL", connOption.ClientData.HostName, 0) + index++ + session.PutKeyValString("AUTH_PROGRAM_NM", connOption.ClientData.ProgramName, 0) + index++ + session.PutKeyValString("AUTH_MACHINE", connOption.ClientData.HostName, 0) + index++ + session.PutKeyValString("AUTH_PID", fmt.Sprintf("%d", connOption.ClientData.PID), 0) + index++ + session.PutKeyValString("AUTH_SID", connOption.ClientData.UserName, 0) + index++ + session.PutKeyValString("AUTH_CONNECT_STRING", connOption.ConnectionData(), 0) + index++ + session.PutKeyValString("SESSION_CLIENT_CHARSET", strconv.Itoa(int(obj.tcpNego.ServerCharset)), 0) + index++ + session.PutKeyValString("SESSION_CLIENT_LIB_TYPE", "0", 0) + index++ + session.PutKeyValString("SESSION_CLIENT_DRIVER_NAME", connOption.ClientData.DriverName, 0) + index++ + session.PutKeyValString("SESSION_CLIENT_VERSION", "1.0.0.0", 0) + index++ + session.PutKeyValString("SESSION_CLIENT_LOBATTR", "1", 0) + index++ + tz, _ := time.Now().Zone() + if !strings.Contains(tz, ":") { + tz += ":00" + } + //session.PutKeyValString("AUTH_ALTER_SESSION", + // fmt.Sprintf("ALTER SESSION SET NLS_LANGUAGE='ARABIC' NLS_TERRITORY='SAUDI ARABIA' TIME_ZONE='%s'\x00", tz), 1) + session.PutKeyValString("AUTH_ALTER_SESSION", + fmt.Sprintf("ALTER SESSION SET NLS_LANGUAGE='AMERICAN' NLS_TERRITORY='AMERICA' TIME_ZONE='%s'\x00", tz), 1) + index++ + //if (!string.IsNullOrEmpty(proxyClientName)) + //{ + // keys[index1] = this.m_authProxyClientName; + // values[index1++] = this.m_marshallingEngine.m_dbCharSetConv.ConvertStringToBytes(proxyClientName, 0, proxyClientName.Length, true); + //} + //if (sessionId != -1) + //{ + // keys[index1] = this.m_authSessionId; + // values[index1++] = this.m_marshallingEngine.m_dbCharSetConv.ConvertStringToBytes(sessionId.ToString(), 0, sessionId.ToString().Length, true); + //} + //if (serialNum != -1) + //{ + // keys[index1] = this.m_authSerialNum; + // values[index1++] = this.m_marshallingEngine.m_dbCharSetConv.ConvertStringToBytes(serialNum.ToString(), 0, serialNum.ToString().Length, true); + //} + // fill remaining values with zeros + for index < keyValSize { + session.PutKeyVal(nil, nil, 0) + index++ + } + err := session.Write() + if err != nil { + return err + } + return nil +} + +func getKeyFromUserNameAndPassword(username string, password string) ([]byte, error) { + username = strings.ToUpper(username) + password = strings.ToUpper(password) + extendString := func(str string) []byte { + ret := make([]byte, len(str)*2) + for index, char := range []byte(str) { + ret[index*2] = 0 + ret[index*2+1] = char + } + return ret + } + buffer := append(extendString(username), extendString(password)...) + if len(buffer)%8 > 0 { + buffer = append(buffer, make([]byte, 8-len(buffer)%8)...) + } + key := []byte{1, 35, 69, 103, 137, 171, 205, 239} + + DesEnc := func(input []byte, key []byte) ([]byte, error) { + ret := make([]byte, 8) + enc, err := des.NewCipher(key) + if err != nil { + return nil, err + } + for x := 0; x < len(input)/8; x++ { + for y := 0; y < 8; y++ { + ret[y] = uint8(int(ret[y]) ^ int(input[x*8+y])) + } + output := make([]byte, 8) + enc.Encrypt(output, ret) + copy(ret, output) + } + return ret, nil + } + key1, err := DesEnc(buffer, key) + if err != nil { + return nil, err + } + key2, err := DesEnc(buffer, key1) + if err != nil { + return nil, err + } + // function OSLogonHelper.Method1_bytearray (DecryptSessionKey) + return append(key2, make([]byte, 8)...), nil +} + +func PKCS5Padding(cipherText []byte, blockSize int) []byte { + padding := blockSize - len(cipherText)%blockSize + padtext := bytes.Repeat([]byte{byte(padding)}, padding) + return append(cipherText, padtext...) +} + +func HexStringToBytes(input string) ([]byte, error) { + result := make([]byte, len(input)/2) + for x := 0; x < len(input); x += 2 { + num, err := strconv.ParseUint(input[x:x+2], 16, 8) + if err != nil { + return nil, err + } + result[x/2] = uint8(num) + } + return result, nil +} +func decryptSessionKey(padding bool, encKey []byte, sessionKey string) ([]byte, error) { + result, err := HexStringToBytes(sessionKey) + if err != nil { + return nil, err + } + blk, err := aes.NewCipher(encKey) + if err != nil { + return nil, err + } + //if padding { + // result = PKCS5Padding(result, blk.BlockSize()) + //} + enc := cipher.NewCBCDecrypter(blk, make([]byte, 16)) + output := make([]byte, len(result)) + enc.CryptBlocks(output, result) + cutLen := 0 + if padding { + num := int(output[len(output)-1]) + if num < enc.BlockSize() { + apply := true + for x := len(output) - num; x < len(output); x++ { + if output[x] != uint8(num) { + apply = false + break + } + } + if apply { + cutLen = int(output[len(output)-1]) + } + } + } + return output[:len(output)-cutLen], nil +} + +func EncryptSessionKey(padding bool, encKey []byte, sessionKey []byte) (string, error) { + blk, err := aes.NewCipher(encKey) + if err != nil { + return "", err + } + enc := cipher.NewCBCEncrypter(blk, make([]byte, 16)) + if padding { + sessionKey = PKCS5Padding(sessionKey, blk.BlockSize()) + } + output := make([]byte, len(sessionKey)) + enc.CryptBlocks(output, sessionKey) + return fmt.Sprintf("%X", output), nil +} + +func EncryptPassword(password string, key []byte) (string, error) { + buff1 := make([]byte, 0x10) + _, err := rand.Read(buff1) + //buff_1 = []byte{109, 250, 127, 252, 157, 165, 29, 6, 165, 174, 50, 93, 165, 202, 192, 100} + if err != nil { + return "", nil + } + buffer := append(buff1, []byte(password)...) + return EncryptSessionKey(true, key, buffer) +} + +func CalculateKeysHash(verifierType int, key1 []byte, key2 []byte) ([]byte, error) { + hash := md5.New() + switch verifierType { + case 2361: + buffer := make([]byte, 16) + for x := 0; x < 16; x++ { + buffer[x] = key1[x] ^ key2[x] + } + + hash.Write(buffer) + return hash.Sum(nil), nil + case 6949: + buffer := make([]byte, 24) + for x := 0; x < 24; x++ { + buffer[x] = key1[x] ^ key2[x] + } + hash.Write(buffer[:16]) + ret := hash.Sum(nil) + hash.Reset() + hash.Write(buffer[16:]) + ret = append(ret, hash.Sum(nil)...) + return ret[:24], nil + } + return nil, nil +} + +func (obj *AuthObject) VerifyResponse(response string) bool { + key, err := decryptSessionKey(true, obj.KeyHash, response) + if err != nil { + fmt.Println(err) + return false + } + //fmt.Printf("%#v\n", key) + return bytes.Compare(key[16:], []byte{83, 69, 82, 86, 69, 82, 95, 84, 79, 95, 67, 76, 73, 69, 78, 84}) == 0 + //KZSR_SVR_RESPONSE = new byte[16]{ (byte) 83, (byte) 69, (byte) 82, (byte) 86, (byte) 69, (byte) 82, (byte) 95, (byte) 84, (byte) 79, + //(byte) 95, (byte) 67, (byte) 76, (byte) 73, (byte) 69, (byte) 78, (byte) 84 }; + +} diff --git a/command.go b/command.go new file mode 100644 index 00000000..8cc2b578 --- /dev/null +++ b/command.go @@ -0,0 +1,710 @@ +package go_ora + +import ( + "database/sql/driver" + "encoding/binary" + "errors" + "fmt" + "go-ora/converters" + "go-ora/network" + "math" + "time" + + //charmap "golang.org/x/text/encoding/charmap" + "regexp" + "strings" +) + +type StmtType int + +const ( + SELECT StmtType = 1 + DML StmtType = 2 + PLSQL StmtType = 3 + OTHERS StmtType = 4 +) + +type Stmt struct { + connection *Connection + Text string + stmtType StmtType + Pars []ParameterInfo + hasReturnClause bool + parse bool // means parse the command in the server this occur if the stmt is not cached + execute bool + define bool + exeOption int + cursorID int + noOfRowsToFetch int + noOfDefCols int + al8i4 []byte + arrayBindCount int + queryID uint64 + scnFromExe []int + hasMoreRows bool +} + +type QueryResult struct { + lastInsertedID int64 + rowsAffected int64 +} + +func (rs *QueryResult) LastInsertId() (int64, error) { + return rs.lastInsertedID, nil +} + +func (rs *QueryResult) RowsAffected() (int64, error) { + return rs.rowsAffected, nil +} + +func NewStmt(text string, conn *Connection) *Stmt { + ret := &Stmt{ + connection: conn, + Text: text, + parse: true, + execute: true, + define: false, + al8i4: make([]byte, 13), + scnFromExe: make([]int, 2), + } + + // get stmt type + uCmdText := strings.Trim(strings.ToUpper(text), " ") + if strings.HasPrefix(uCmdText, "SELECT") || strings.HasPrefix(uCmdText, "WITH") { + ret.stmtType = SELECT + } else if strings.HasPrefix(uCmdText, "UPDATE") || + strings.HasPrefix(uCmdText, "INSERT") || + strings.HasPrefix(uCmdText, "DELETE") { + ret.stmtType = DML + } else if strings.HasPrefix(uCmdText, "DECLARE") || strings.HasPrefix(uCmdText, "BEGIN") { + ret.stmtType = PLSQL + } else { + ret.stmtType = OTHERS + } + + // returning cluase + var err error + ret.hasReturnClause, err = regexp.MatchString(`\bRETURNING\b`, uCmdText) + if err != nil { + ret.hasReturnClause = false + } + ret.al8i4[0] = 1 + switch ret.stmtType { + case DML: + fallthrough + case PLSQL: + if ret.arrayBindCount <= 1 { + ret.al8i4[1] = 1 + } else { + ret.al8i4[1] = uint8(ret.arrayBindCount) + } + case OTHERS: + ret.al8i4[1] = 1 + default: + ret.al8i4[1] = 0 + } + if ret.stmtType == SELECT { + ret.al8i4[7] = 1 + } else { + ret.al8i4[7] = 0 + } + return ret +} + +func (stmt *Stmt) write(session *network.Session) error { + exeOp := stmt.getExeOption() + session.PutBytes([]byte{3, 0x5E, 0}) + session.PutUint(exeOp, 4, true, true) + session.PutUint(stmt.cursorID, 2, true, true) + if stmt.cursorID == 0 { + session.PutUint(1, 1, false, false) + } else { + session.PutUint(0, 1, false, false) + } + session.PutUint(len(stmt.Text), 4, true, true) + session.PutUint(1, 1, false, false) + session.PutUint(13, 2, true, true) + session.PutBytes([]byte{0, 0}) + if exeOp&0x40 == 0 && exeOp&0x20 != 0 && exeOp&0x1 != 0 && stmt.stmtType == SELECT { + session.PutUint(0, 1, false, false) + session.PutUint(stmt.noOfRowsToFetch, 4, true, true) + } else { + session.PutUint(0, 4, true, true) + session.PutUint(0, 4, true, true) + } + // longFetchSize == 0 marshal 1 else marshal longFetchSize + session.PutUint(1, 4, true, true) + if len(stmt.Pars) > 0 { + session.PutUint(1, 1, false, false) + session.PutUint(len(stmt.Pars), 2, true, true) + } else { + session.PutUint(0, 1, false, false) + session.PutUint(0, 1, false, false) + } + session.PutBytes([]byte{0, 0, 0, 0, 0}) + if stmt.define { + session.PutUint(1, 1, false, false) + session.PutUint(stmt.noOfDefCols, 2, true, true) + } else { + session.PutUint(0, 1, false, false) + session.PutUint(0, 1, false, false) + } + if session.TTCVersion >= 4 { + session.PutUint(0, 1, false, false) // dbChangeRegisterationId + session.PutUint(0, 1, false, false) + session.PutUint(1, 1, false, false) + } + if session.TTCVersion >= 5 { + session.PutUint(0, 1, false, false) + session.PutUint(0, 1, false, false) + session.PutUint(0, 1, false, false) + session.PutUint(0, 1, false, false) + session.PutUint(0, 1, false, false) + } + + session.PutBytes([]byte(stmt.Text)) + for x := 0; x < len(stmt.al8i4); x++ { + session.PutUint(stmt.al8i4[x], 2, true, true) + } + for _, par := range stmt.Pars { + _ = par.write(session) + } + if len(stmt.Pars) > 0 { + session.PutUint(7, 1, false, false) + for _, par := range stmt.Pars { + session.PutClr(par.Value) + } + } + return session.Write() +} + +//func (stmt *Stmt) NoQuery() error { +// stmt.autoCommit = true +// stmt.connection.session.ResetBuffer() +// err := stmt.write(stmt.connection.session) +// if err != nil { +// return err +// } +// err = stmt.connection.session.write() +// if err != nil { +// return err +// } +// dataSet := new(DataSet) +// return stmt.read(dataSet) +//} + +//func (stmt *Stmt) QueryN() (*DataSet, error) { +// stmt.autoCommit = false +// stmt.noOfRowsToFetch = 25 +// stmt.connection.session.ResetBuffer() +// err := stmt.write(stmt.connection.session) +// if err != nil { +// return nil, err +// } +// err = stmt.connection.session.write() +// if err != nil { +// return nil, err +// } +// dataSet := new(DataSet) +// err = stmt.read(dataSet) +// if err != nil { +// return nil, err +// } +// return dataSet, nil +// +//} + +func (stmt *Stmt) getExeOption() int { + op := 0 + if stmt.stmtType == PLSQL || stmt.hasReturnClause { + op |= 0x40000 + } + + if stmt.connection.autoCommit { + op |= 0x100 + } + if stmt.parse { + op |= 1 + } + if stmt.execute { + op |= 0x20 + } + if len(stmt.Pars) > 0 { + op |= 0x8 + if stmt.stmtType == PLSQL || stmt.hasReturnClause { + op |= 0x400 + } + } + if stmt.stmtType != PLSQL && !stmt.hasReturnClause { + op |= 0x8000 + } + return op + + /* HasReturnClause + if stmt.PLSQL or cmdText == "" return false + Regex.IsMatch(cmdText, "\\bRETURNING\\b" + */ +} +func (stmt *Stmt) fetch(dataSet *DataSet) error { + stmt.connection.session.ResetBuffer() + stmt.connection.session.PutBytes([]byte{3, 5, 0}) + stmt.connection.session.PutInt(stmt.cursorID, 2, true, true) + stmt.connection.session.PutInt(stmt.noOfRowsToFetch, 2, true, true) + err := stmt.connection.session.Write() + if err != nil { + return err + } + return stmt.read(dataSet) +} +func (stmt *Stmt) read(dataSet *DataSet) error { + loop := true + after7 := false + containOutputPars := false + dataSet.parent = stmt + session := stmt.connection.session + for loop { + msg, err := session.GetByte() + if err != nil { + return err + } + switch msg { + case 4: + stmt.connection.session.Summary, err = network.NewSummary(session) + if err != nil { + return err + } + //fmt.Println(stmt.connection.session.Summary) + //fmt.Println(stmt.connection.session.Summary) + stmt.cursorID = stmt.connection.session.Summary.CursorID + if stmt.connection.session.HasError() { + if stmt.connection.session.Summary.RetCode == 1403 { + stmt.hasMoreRows = false + stmt.connection.session.Summary = nil + } else { + return errors.New(stmt.connection.session.GetError()) + } + + } + loop = false + case 6: + //_, err = session.GetByte() + err = dataSet.read(session) + if err != nil { + return err + } + if !after7 { + if stmt.stmtType == SELECT { + + } + } + case 7: + after7 = true + if stmt.hasReturnClause { + //if (bHasReturningParams && bindAccessors != null) + //{ + // int paramLen = bindAccessors.Length; + // this.m_marshallingEngine.m_oraBufRdr.m_bHavingParameterData = true; + // for (int index1 = 0; index1 < paramLen; ++index1) + // { + // if (bindAccessors[index1] != null) + // { + // int num = (int) this.m_marshallingEngine.UnmarshalUB4(false); + // if (num > 1) + // bMoreThanOneRowAffectedByDmlWithRetClause = true; + // if (num == 0) + // { + // bindAccessors[index1].AddNullForData(); + // } + // else + // { + // for (int index2 = 0; index2 < num; ++index2) + // { + // bindAccessors[index1].m_bReceivedOutValueFromServer = true; + // bindAccessors[index1].UnmarshalOneRow(); + // } + // } + // } + // } + // this.m_marshallingEngine.m_oraBufRdr.m_currentOB = (OraBuf) null; + // this.m_marshallingEngine.m_oraBufRdr.m_bHavingParameterData = false; + // ++noOfRowsFetched; + // continue; + //} + } else { + if containOutputPars { + for x := 0; x < dataSet.ColumnCount; x++ { + if stmt.Pars[x].Direction != Input { + stmt.Pars[x].Value, err = session.GetClr() + } else { + _, err = session.GetClr() + } + if err != nil { + return err + } + _, err = session.GetInt(2, true, true) + } + } else { + newRow := make(Row, dataSet.ColumnCount) + for x := 0; x < dataSet.ColumnCount; x++ { + if dataSet.Cols[x].getDataFromServer { + + temp, err := session.GetClr() + if err != nil { + return err + } + if temp == nil { + newRow[x] = nil + } else { + //switch (this.m_definedColumnType) + //{ + //case OraType.ORA_TIMESTAMP_DTY: + //case OraType.ORA_TIMESTAMP: + //case OraType.ORA_TIMESTAMP_LTZ_DTY: + //case OraType.ORA_TIMESTAMP_LTZ: + // this.m_marshallingEngine.UnmarshalCLR_ColData(11); + // break; + //case OraType.ORA_TIMESTAMP_TZ_DTY: + //case OraType.ORA_TIMESTAMP_TZ: + // this.m_marshallingEngine.UnmarshalCLR_ColData(13); + // break; + //case OraType.ORA_INTERVAL_YM_DTY: + //case OraType.ORA_INTERVAL_DS_DTY: + //case OraType.ORA_INTERVAL_YM: + //case OraType.ORA_INTERVAL_DS: + //case OraType.ORA_IBFLOAT: + //case OraType.ORA_IBDOUBLE: + //case OraType.ORA_RAW: + //case OraType.ORA_CHAR: + //case OraType.ORA_CHARN: + //case OraType.ORA_VARCHAR: + // this.m_marshallingEngine.UnmarshalCLR_ColData(this.m_colMetaData.m_maxLength); + // break; + //case OraType.ORA_RESULTSET: + // throw new InvalidOperationException(); + //case OraType.ORA_NUMBER: + //case OraType.ORA_FLOAT: + //case OraType.ORA_VARNUM: + // this.m_marshallingEngine.UnmarshalCLR_ColData(21); + // break; + //case OraType.ORA_DATE: + // this.m_marshallingEngine.UnmarshalCLR_ColData(7); + // break; + //default: + // throw new Exception("UnmarshalColumnData: Unimplemented type"); + //} + switch dataSet.Cols[x].DataType { + case NCHAR: + //fmt.Println("string value:", stmt.connection.strConv.Decode(temp)) + newRow[x] = stmt.connection.strConv.Decode(temp) + case NUMBER: + if dataSet.Cols[x].Scale == 0 { + newRow[x] = int64(converters.DecodeInt(temp)) + } else { + base := math.Pow10(int(dataSet.Cols[x].Scale)) + newRow[x] = math.Round(converters.DecodeDouble(temp)*base) / base + } + case TimeStamp: + fallthrough + case TimeStampDTY: + fallthrough + case TimeStampeLTZ: + fallthrough + case TimeStampLTZ_DTY: + fallthrough + case TimeStampTZ: + fallthrough + case TimeStampTZ_DTY: + fallthrough + case DATE: + dateVal, err := converters.DecodeDate(temp) + if err != nil { + return err + } + newRow[x] = dateVal + default: + newRow[x] = temp + } + } + } else { + // copy from last row + if len(dataSet.Rows) > 0 { + lastRow := dataSet.Rows[len(dataSet.Rows)-1] + newRow[x] = lastRow[x] + } else { + newRow[x] = nil + } + } + + } + dataSet.Rows = append(dataSet.Rows, newRow) + } + } + case 8: + size, err := session.GetInt(2, true, true) + if err != nil { + return err + } + for x := 0; x < 2; x++ { + stmt.scnFromExe[x], err = session.GetInt(4, true, true) + if err != nil { + return err + } + } + for x := 2; x < size; x++ { + _, err = session.GetInt(4, true, true) + if err != nil { + return err + } + } + _, err = session.GetInt(2, true, true) + //fmt.Println(num) + //if (num > 0) + // this.m_marshallingEngine.UnmarshalNBytes_ScanOnly(num); + // get session timezone + size, err = session.GetInt(2, true, true) + for x := 0; x < size; x++ { + _, val, num, err := session.GetKeyVal() + if err != nil { + return err + } + //fmt.Println(key, val, num) + if num == 163 { + session.TimeZone = val + //fmt.Println("session time zone", session.TimeZone) + } + } + if session.TTCVersion >= 4 { + // get queryID + size, err = session.GetInt(4, true, true) + if err != nil { + return err + } + if size > 0 { + bty, err := session.GetBytes(size) + if err != nil { + return err + } + if len(bty) >= 8 { + stmt.queryID = binary.LittleEndian.Uint64(bty[size-8:]) + fmt.Println("query ID: ", stmt.queryID) + } + } + } + + case 11: + err = dataSet.read(session) + if err != nil { + return err + } + //dataSet.BindDirections = make([]byte, dataSet.ColumnCount) + for x := 0; x < dataSet.ColumnCount; x++ { + direction, err := session.GetByte() + switch direction { + case 32: + stmt.Pars[x].Direction = Input + case 16: + stmt.Pars[x].Direction = Output + containOutputPars = true + case 48: + stmt.Pars[x].Direction = InOut + containOutputPars = true + } + if err != nil { + return err + } + } + case 16: + size, err := session.GetInt(1, false, false) + if err != nil { + return err + } + _, err = session.GetBytes(size) + if err != nil { + return err + } + dataSet.MaxRowSize, err = session.GetInt(4, true, true) + if err != nil { + return err + } + noOfColumns, err := session.GetInt(4, true, true) + if err != nil { + return err + } + if noOfColumns > 0 { + _, err = session.GetInt(1, false, false) + } + dataSet.Cols = make([]ParameterInfo, noOfColumns) + for x := 0; x < noOfColumns; x++ { + err = dataSet.Cols[x].read(session) + if err != nil { + return err + } + } + _, err = session.GetDlc() + if session.TTCVersion >= 3 { + _, err = session.GetInt(4, true, true) + _, err = session.GetInt(4, true, true) + } + if session.TTCVersion >= 4 { + _, err = session.GetInt(4, true, true) + _, err = session.GetInt(4, true, true) + } + if session.TTCVersion >= 5 { + _, err = session.GetDlc() + } + case 21: + noOfColumnSent, err := session.GetInt(2, true, true) + if err != nil { + return err + } + bitVectorLen := noOfColumnSent / 8 + if noOfColumnSent%8 > 0 { + bitVectorLen++ + } + bitVector := make([]byte, bitVectorLen) + for x := 0; x < bitVectorLen; x++ { + bitVector[x], err = session.GetByte() + } + dataSet.setBitVector(bitVector) + + default: + loop = false + } + } + return nil +} + +func (stmt *Stmt) Close() error { + session := stmt.connection.session + session.ResetBuffer() + session.PutBytes([]byte{17, 105, 0, 1, 1, 1}) + session.PutInt(stmt.cursorID, 4, true, true) + return (&simpleObject{ + session: session, + operationID: 0x93, + data: nil, + err: nil, + }).write().read() +} + +func (stmt *Stmt) Exec(args []driver.Value) (driver.Result, error) { + session := stmt.connection.session + for x := 0; x < len(args); x++ { + stmt.AddParam("", args[x], 0, Input) + } + session.ResetBuffer() + err := stmt.write(session) + if err != nil { + return nil, err + } + dataSet := new(DataSet) + err = stmt.read(dataSet) + if err != nil { + return nil, err + } + result := new(QueryResult) + if session.Summary != nil { + result.rowsAffected = int64(session.Summary.CurRowNumber) + } + return result, nil +} +func (stmt *Stmt) AddParam(name string, val driver.Value, size int, direction ParameterDirection) { + param := ParameterInfo{ + Name: name, + Direction: direction, + Flag: 3, + CharsetID: 871, + CharsetForm: 1, + } + //if param.Direction == Output { + // if _, ok := val.(string); ok { + // param.MaxCharLen = size + // param.MaxLen = size * converters.MaxBytePerChar(stmt.connection.strConv.LangID) + // } + // stmt.Pars = append(stmt.Pars, param) + // return + //} + switch val := val.(type) { + case int64: + param.Value = converters.EncodeInt64(val) + param.DataType = NUMBER + case int32: + param.Value = converters.EncodeInt(int(val)) + param.DataType = NUMBER + case int16: + param.Value = converters.EncodeInt(int(val)) + param.DataType = NUMBER + case int8: + param.Value = converters.EncodeInt(int(val)) + param.DataType = NUMBER + case int: + param.Value = converters.EncodeInt(val) + param.DataType = NUMBER + case float32: + param.Value, _ = converters.EncodeDouble(float64(val)) + param.DataType = NUMBER + case float64: + param.Value, _ = converters.EncodeDouble(val) + param.DataType = NUMBER + case time.Time: + param.Value = converters.EncodeDate(val) + param.DataType = DATE + param.ContFlag = 0 + param.MaxLen = 11 + param.MaxCharLen = 11 + case string: + param.Value = stmt.connection.strConv.Encode(val) + param.DataType = NCHAR + param.ContFlag = 16 + param.MaxCharLen = len(val) + if size > len(val) { + param.MaxCharLen = size + } + param.MaxLen = param.MaxCharLen * converters.MaxBytePerChar(stmt.connection.strConv.LangID) + param.CharsetForm = 1 + } + if param.DataType == NUMBER { + param.ContFlag = 0 + param.MaxCharLen = 22 + param.MaxLen = 22 + param.CharsetForm = 1 + } + if direction == Output { + param.Value = nil + } + stmt.Pars = append(stmt.Pars, param) +} + +func (stmt *Stmt) Query(args []driver.Value) (driver.Rows, error) { + stmt.noOfRowsToFetch = 25 + stmt.hasMoreRows = true + for x := 0; x < len(args); x++ { + stmt.AddParam("", args[x], 0, Input) + } + stmt.connection.session.ResetBuffer() + err := stmt.write(stmt.connection.session) + if err != nil { + return nil, err + } + //err = stmt.connection.session.Write() + //if err != nil { + // return nil, err + //} + dataSet := new(DataSet) + err = stmt.read(dataSet) + if err != nil { + return nil, err + } + return dataSet, nil +} + +func (stmt *Stmt) NumInput() int { + return -1 +} + +/* +parse = true +execute = true +fetch = true if hasReturn or PLSQL +define = false +*/ diff --git a/connection.go b/connection.go new file mode 100644 index 00000000..bb3825d5 --- /dev/null +++ b/connection.go @@ -0,0 +1,434 @@ +package go_ora + +import ( + "context" + "database/sql" + "database/sql/driver" + "errors" + "fmt" + "go-ora/converters" + "go-ora/network" + "os" + "os/user" + "strconv" + "strings" +) + +type ConnectionState int + +const ( + Closed ConnectionState = 0 + Opened ConnectionState = 1 +) + +type LogonMode int + +const ( + NoNewPass LogonMode = 0x1 + //WithNewPass LogonMode = 0x2 + SysDba LogonMode = 0x20 // no verify response from server + SysOper LogonMode = 0x40 // no verify response from server + UserAndPass LogonMode = 0x100 + //PROXY LogonMode = 0x400 +) + +type NLSData struct { + Calender string + Comp string + LengthSemantics string + NCharConvExcep string + DateLang string + Sort string + Currency string + DateFormat string + IsoCurrency string + NumericChars string + DualCurrency string + Timestamp string + TimestampTZ string +} +type Connection struct { + State ConnectionState + LogonMode LogonMode + autoCommit bool + conStr *ConnectionString + connOption *network.ConnectionOption + session *network.Session + tcpNego *TCPNego + dataNego *DataTypeNego + authObject *AuthObject + SessionProperties map[string]string + dBVersion *DBVersion + sessionID int + serialID int + strConv *converters.StringConverter + NLSData NLSData +} +type oracleDriver struct { +} + +func init() { + sql.Register("oracle", &oracleDriver{}) +} +func (drv *oracleDriver) Open(name string) (driver.Conn, error) { + + conn, err := NewConnection(name) + if err != nil { + return nil, err + } + return conn, conn.Open() +} + +func (conn *Connection) GetNLS() (*NLSData, error) { + cmdText := `DECLARE + err_code VARCHAR2(2000); + err_msg VARCHAR2(2000); + BEGIN + SELECT VALUE into :p_nls_calendar from nls_session_parameters where PARAMETER='NLS_CALENDAR'; + SELECT VALUE into :p_nls_comp from nls_session_parameters where PARAMETER='NLS_COMP'; + SELECT VALUE into :p_nls_length_semantics from nls_session_parameters where PARAMETER='NLS_LENGTH_SEMANTICS'; + SELECT VALUE into :p_nls_nchar_conv_excep from nls_session_parameters where PARAMETER='NLS_NCHAR_CONV_EXCP'; + SELECT VALUE into :p_nls_date_lang from nls_session_parameters where PARAMETER='NLS_DATE_LANGUAGE'; + SELECT VALUE into :p_nls_sort from nls_session_parameters where PARAMETER='NLS_SORT'; + SELECT VALUE into :p_nls_currency from nls_session_parameters where PARAMETER='NLS_CURRENCY'; + SELECT VALUE into :p_nls_date_format from nls_session_parameters where PARAMETER='NLS_DATE_FORMAT'; + SELECT VALUE into :p_nls_iso_currency from nls_session_parameters where PARAMETER='NLS_ISO_CURRENCY'; + SELECT VALUE into :p_nls_numeric_chars from nls_session_parameters where PARAMETER='NLS_NUMERIC_CHARACTERS'; + SELECT VALUE into :p_nls_dual_currency from nls_session_parameters where PARAMETER='NLS_DUAL_CURRENCY'; + SELECT VALUE into :p_nls_timestamp from nls_session_parameters where PARAMETER='NLS_TIMESTAMP_FORMAT'; + SELECT VALUE into :p_nls_timestamp_tz from nls_session_parameters where PARAMETER='NLS_TIMESTAMP_TZ_FORMAT'; + SELECT '0' into :p_err_code from dual; + SELECT '0' into :p_err_msg from dual; + END;` + stmt := NewStmt(cmdText, conn) + stmt.AddParam("p_nls_calendar", "", 40, Output) + stmt.AddParam("p_nls_comp", "", 40, Output) + stmt.AddParam("p_nls_length_semantics", "", 40, Output) + stmt.AddParam("p_nls_nchar_conv_excep", "", 40, Output) + stmt.AddParam("p_nls_date_lang", "", 40, Output) + stmt.AddParam("p_nls_sort", "", 40, Output) + stmt.AddParam("p_nls_currency", "", 40, Output) + stmt.AddParam("p_nls_date_format", "", 40, Output) + stmt.AddParam("p_nls_iso_currency", "", 40, Output) + stmt.AddParam("p_nls_numeric_chars", "", 40, Output) + stmt.AddParam("p_nls_dual_currency", "", 40, Output) + stmt.AddParam("p_nls_timestamp", "", 40, Output) + stmt.AddParam("p_nls_timestamp_tz", "", 40, Output) + stmt.AddParam("p_err_code", "", 2000, Output) + stmt.AddParam("p_err_msg", "", 2000, Output) + //fmt.Println(stmt.Pars) + _, err := stmt.Exec(nil) + if err != nil { + return nil, err + } + for _, par := range stmt.Pars { + if par.Name == "p_nls_calendar" { + conn.NLSData.Calender = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_comp" { + conn.NLSData.Comp = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_length_semantics" { + conn.NLSData.LengthSemantics = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_nchar_conv_excep" { + conn.NLSData.NCharConvExcep = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_date_lang" { + conn.NLSData.DateLang = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_sort" { + conn.NLSData.Sort = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_currency" { + conn.NLSData.Currency = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_date_format" { + conn.NLSData.DateFormat = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_iso_currency" { + conn.NLSData.IsoCurrency = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_numeric_chars" { + conn.NLSData.NumericChars = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_dual_currency" { + conn.NLSData.DualCurrency = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_timestamp" { + conn.NLSData.Timestamp = conn.strConv.Decode(par.Value) + } else if par.Name == "p_nls_timestamp_tz" { + conn.NLSData.TimestampTZ = conn.strConv.Decode(par.Value) + } + } + return &conn.NLSData, nil +} + +func (conn *Connection) Prepare(query string) (driver.Stmt, error) { + return NewStmt(query, conn), nil +} + +func (conn *Connection) Ping(ctx context.Context) error { + conn.session.ResetBuffer() + return (&simpleObject{ + session: conn.session, + operationID: 0x93, + data: nil, + }).write().read() +} + +func (conn *Connection) Logoff() error { + session := conn.session + session.ResetBuffer() + session.PutBytes([]byte{0x11, 0x87, 0, 0, 0, 0x2, 0x1, 0x11, + 0x1, 0, 0, 0, 0x1, 0, 0, 0, + 0, 0, 0x1, 0, 0, 0, 0, 0, + 3, 9, 0}) + err := session.Write() + if err != nil { + return err + } + loop := true + for loop { + msg, err := session.GetByte() + if err != nil { + return err + } + switch msg { + case 4: + session.Summary, err = network.NewSummary(session) + if err != nil { + return err + } + loop = false + case 9: + if session.HasEOSCapability { + if session.Summary == nil { + session.Summary = new(network.SummaryObject) + } + session.Summary.EndOfCallStatus, err = session.GetInt(4, true, true) + if err != nil { + return err + } + } + if session.HasFSAPCapability { + if session.Summary == nil { + session.Summary = new(network.SummaryObject) + } + session.Summary.EndToEndECIDSequence, err = session.GetInt(2, true, true) + if err != nil { + return err + } + } + loop = false + default: + return errors.New(fmt.Sprintf("message code error: received code %d and expected code is 4, 9", msg)) + } + } + if session.HasError() { + return errors.New(session.GetError()) + } + return nil +} + +func (conn *Connection) Open() error { + switch conn.conStr.DBAPrivilege { + case SYSDBA: + conn.LogonMode |= SysDba + case SYSOPER: + conn.LogonMode |= SysOper + default: + conn.LogonMode = 0 + } + conn.session = network.NewSession(*conn.connOption) + err := conn.session.Connect() + if err != nil { + return err + } + + conn.tcpNego, err = NewTCPNego(conn.session) + if err != nil { + return err + } + // create string converter object + conn.strConv = converters.NewStringConverter(conn.tcpNego.ServerCharset) + conn.session.StrConv = conn.strConv + + conn.dataNego, err = buildTypeNego(conn.tcpNego, conn.session) + if err != nil { + return err + } + + conn.session.TTCVersion = conn.dataNego.CompileTimeCaps[7] + + if conn.tcpNego.ServerCompileTimeCaps[7] < conn.session.TTCVersion { + conn.session.TTCVersion = conn.tcpNego.ServerCompileTimeCaps[7] + } + + //if (((int) this.m_serverCompiletimeCapabilities[15] & 1) != 0) + // this.m_marshallingEngine.HasEOCSCapability = true; + //if (((int) this.m_serverCompiletimeCapabilities[16] & 16) != 0) + // this.m_marshallingEngine.HasFSAPCapability = true; + + err = conn.doAuth() + if err != nil { + return err + } + conn.State = Opened + conn.dBVersion, err = GetDBVersion(conn.session) + if err != nil { + return err + } + + sessionID, err := strconv.ParseUint(conn.SessionProperties["AUTH_SESSION_ID"], 10, 32) + if err != nil { + return err + } + conn.sessionID = int(sessionID) + serialNum, err := strconv.ParseUint(conn.SessionProperties["AUTH_SERIAL_NUM"], 10, 32) + if err != nil { + return err + } + conn.serialID = int(serialNum) + conn.connOption.InstanceName = conn.SessionProperties["AUTH_SC_INSTANCE_NAME"] + conn.connOption.Host = conn.SessionProperties["AUTH_SC_SERVER_HOST"] + conn.connOption.ServiceName = conn.SessionProperties["AUTH_SC_SERVICE_NAME"] + conn.connOption.DomainName = conn.SessionProperties["AUTH_SC_DB_DOMAIN"] + conn.connOption.DBName = conn.SessionProperties["AUTH_SC_DBUNIQUE_NAME"] + _, err = conn.GetNLS() + if err != nil { + return err + } + return nil +} + +func (conn *Connection) Begin() (driver.Tx, error) { + conn.autoCommit = false + return &Transaction{conn: conn}, nil +} + +func NewConnection(databaseUrl string) (*Connection, error) { + //this.m_id = this.GetHashCode().ToString(); + conStr, err := newConnectionStringFromUrl(databaseUrl) + if err != nil { + return nil, err + } + userName := "" + User, err := user.Current() + if err == nil { + userName = User.Name + } + hostName, _ := os.Hostname() + indexOfSlash := strings.LastIndex(os.Args[0], "/") + indexOfSlash += 1 + if indexOfSlash < 0 { + indexOfSlash = 0 + } + //userName = "samy" + //hostName = "LABMANAGER" + connOption := &network.ConnectionOption{ + Port: conStr.Port, + TransportConnectTo: 0xFFFF, + SSLVersion: "", + WalletDict: "", + TransportDataUnitSize: 0xFFFF, + SessionDataUnitSize: 0xFFFF, + Protocol: "tcp", + Host: conStr.Host, + UserID: conStr.UserID, + //IP: "", + SID: conStr.SID, + //Addr: "", + //Server: conn.conStr.Host, + ServiceName: conStr.ServiceName, + InstanceName: conStr.InstanceName, + ClientData: network.ClientData{ + ProgramPath: os.Args[0], + ProgramName: os.Args[0][indexOfSlash:], + UserName: userName, + HostName: hostName, + DriverName: "OracleClientGo", + PID: os.Getpid(), + }, + //InAddrAny: false, + } + return &Connection{ + State: Closed, + conStr: conStr, + connOption: connOption, + }, nil +} + +func (conn *Connection) Close() (err error) { + //var err error = nil + if conn.session != nil { + //err = conn.Logoff() + conn.session.Disconnect() + conn.session = nil + } + return +} + +func (conn *Connection) doAuth() error { + conn.session.ResetBuffer() + conn.session.PutBytes([]byte{3, 118, 0, 1}) + conn.session.PutUint(len(conn.conStr.UserID), 4, true, true) + conn.LogonMode = conn.LogonMode | NoNewPass + conn.session.PutUint(int(conn.LogonMode), 4, true, true) + conn.session.PutBytes([]byte{1, 1, 5, 1, 1}) + conn.session.PutBytes([]byte(conn.conStr.UserID)) + conn.session.PutKeyValString("AUTH_TERMINAL", conn.connOption.ClientData.HostName, 0) + conn.session.PutKeyValString("AUTH_PROGRAM_NM", conn.connOption.ClientData.ProgramName, 0) + conn.session.PutKeyValString("AUTH_MACHINE", conn.connOption.ClientData.HostName, 0) + conn.session.PutKeyValString("AUTH_PID", fmt.Sprintf("%d", conn.connOption.ClientData.PID), 0) + conn.session.PutKeyValString("AUTH_SID", conn.connOption.ClientData.UserName, 0) + err := conn.session.Write() + if err != nil { + return err + } + + conn.authObject, err = NewAuthObject(conn.conStr.UserID, conn.conStr.Password, conn.tcpNego, conn.session) + if err != nil { + return err + } + // if proxyAuth ==> mode |= PROXY + err = conn.authObject.Write(conn.connOption, conn.LogonMode, conn.session) + if err != nil { + return err + } + stop := false + for !stop { + msg, err := conn.session.GetInt(1, false, false) + if err != nil { + return err + } + switch msg { + case 4: + conn.session.Summary, err = network.NewSummary(conn.session) + if err != nil { + return err + } + if conn.session.HasError() { + return errors.New(conn.session.GetError()) + } + stop = true + case 8: + dictLen, err := conn.session.GetInt(4, true, true) + if err != nil { + return err + } + conn.SessionProperties = make(map[string]string, dictLen) + for x := 0; x < dictLen; x++ { + key, val, _, err := conn.session.GetKeyVal() + if err != nil { + return err + } + conn.SessionProperties[string(key)] = string(val) + } + case 15: + warning, err := network.NewWarningObject(conn.session) + if err != nil { + return err + } + if warning != nil { + fmt.Println(warning) + } + stop = true + default: + return errors.New(fmt.Sprintf("message code error: received code %d and expected code is 8", msg)) + } + } + + // if verifyResponse == true + // conn.authObject.VerifyResponse(conn.SessionProperties["AUTH_SVR_RESPONSE"]) + return nil +} diff --git a/connection_string.go b/connection_string.go new file mode 100644 index 00000000..d244397a --- /dev/null +++ b/connection_string.go @@ -0,0 +1,357 @@ +package go_ora + +import ( + "errors" + "net/url" + "strconv" + "strings" +) + +type PromotableTransaction string + +const ( + Promotable PromotableTransaction = "Promotable" + Local PromotableTransaction = "Local" +) + +type DBAPrivilege string + +const ( + NONE DBAPrivilege = "NONE" + SYSDBA DBAPrivilege = "SYSDBA" + SYSOPER DBAPrivilege = "SYSOPER" +) + +func DBAPrivilegeFromString(s string) DBAPrivilege { + S := strings.ToUpper(s) + if S == "SYSDBA" { + return SYSDBA + } else if S == "SYSOPER" { + return SYSOPER + } else { + return NONE + } +} + +type EnList string + +const ( + FALSE EnList = "FALSE" + TRUE EnList = "TRUE" + DYNAMIC EnList = "DYNAMIC" +) + +func EnListFromString(s string) EnList { + S := strings.ToUpper(s) + if S == "TRUE" { + return TRUE + } else if S == "DYNAMIC" { + return DYNAMIC + } else { + return FALSE + } +} + +type ConnectionString struct { + DataSource string + Host string + Port int + SID string + ServiceName string + InstanceName string + DBAPrivilege DBAPrivilege + EnList EnList + ConnectionLifeTime int + IncrPoolSize int + DecrPoolSize int + MaxPoolSize int + MinPoolSize int + Password string + PasswordSecurityInfo bool + Pooling bool + ConnectionTimeOut int + UserID string + PromotableTransaction PromotableTransaction + ProxyUserID string + ProxyPassword string + ValidateConnection bool + StmtCacheSize int + StmtCachePurge bool + HaEvent bool + LoadBalance bool + MetadataBooling bool + ContextConnection bool + SelfTuning bool + ApplicationEdition string + PoolReglator int + ConnectionPoolTimeout int + PasswordlessConString string +} + +func NewConnectionString() *ConnectionString { + return &ConnectionString{ + Port: 1521, + DBAPrivilege: NONE, + EnList: TRUE, + IncrPoolSize: 5, + DecrPoolSize: 5, + MaxPoolSize: 100, + MinPoolSize: 1, + ConnectionTimeOut: 15, + PromotableTransaction: Promotable, + StmtCacheSize: 20, + MetadataBooling: true, + SelfTuning: true, + PoolReglator: 100, + ConnectionPoolTimeout: 15, + } +} +func NewConnectionStringFromString(connectionString string) (*ConnectionString, error) { + // initialize + ret := NewConnectionString() + // parse + err := ret.Parse(connectionString) + if err != nil { + return nil, err + } + // validate + ret.validate() + return ret, nil +} + +func (connStr *ConnectionString) validate() { + if !connStr.Pooling { + connStr.MaxPoolSize = -1 + connStr.MinPoolSize = 0 + connStr.IncrPoolSize = -1 + connStr.DecrPoolSize = 0 + connStr.PoolReglator = 0 + } +} +func newConnectionStringFromUrl(databaseUrl string) (*ConnectionString, error) { + u, err := url.Parse(databaseUrl) + if err != nil { + return nil, err + } + q := u.Query() + p := u.Port() + ret := NewConnectionString() + ret.UserID = u.User.Username() + ret.Password, _ = u.User.Password() + if p != "" { + ret.Port, err = strconv.Atoi(p) + if err != nil { + return nil, errors.New("Port must be a number") + } + } + ret.Host = u.Host + ret.SID = strings.Trim(u.Path, "/") + if q != nil { + for key, val := range q { + switch strings.ToUpper(key) { + //case "DATA SOURCE": + // conStr.DataSource = val + case "SERVICE NAME": + ret.ServiceName = val[0] + case "INSTANCE NAME": + ret.InstanceName = val[0] + case "DBA PRIVILEGE": + ret.DBAPrivilege = DBAPrivilegeFromString(val[0]) + case "ENLIST": + ret.EnList = EnListFromString(val[0]) + case "CONNECT TIMEOUT": + fallthrough + case "CONNECTION TIMEOUT": + ret.ConnectionTimeOut, err = strconv.Atoi(val[0]) + if err != nil { + return nil, errors.New("CONNECTION TIMEOUT value must be an integer") + } + case "INC POOL SIZE": + ret.IncrPoolSize, err = strconv.Atoi(val[0]) + if err != nil { + return nil, errors.New("INC POOL SIZE value must be an integer") + } + case "DECR POOL SIZE": + ret.DecrPoolSize, err = strconv.Atoi(val[0]) + if err != nil { + return nil, errors.New("DECR POOL SIZE value must be an integer") + } + case "MAX POOL SIZE": + ret.MaxPoolSize, err = strconv.Atoi(val[0]) + if err != nil { + return nil, errors.New("MAX POOL SIZE value must be an integer") + } + case "MIN POOL SIZE": + ret.MinPoolSize, err = strconv.Atoi(val[0]) + if err != nil { + return nil, errors.New("MIN POOL SIZE value must be an integer") + } + case "POOL REGULATOR": + ret.PoolReglator, err = strconv.Atoi(val[0]) + if err != nil { + return nil, errors.New("POOL REGULATOR value must be an integer") + } + case "STATEMENT CACHE SIZE": + ret.StmtCacheSize, err = strconv.Atoi(val[0]) + if err != nil { + return nil, errors.New("STATEMENT CACHE SIZE value must be an integer") + } + case "CONNECTION POOL TIMEOUT": + ret.ConnectionPoolTimeout, err = strconv.Atoi(val[0]) + if err != nil { + return nil, errors.New("CONNECTION POOL TIMEOUT value must be an integer") + } + //case "CONNECTION LIFETIME": + case "PERSIST SECURITY INFO": + ret.PasswordSecurityInfo = val[0] == "TRUE" + case "POOLING": + ret.Pooling = val[0] == "TRUE" + case "VALIDATE CONNECTION": + ret.ValidateConnection = val[0] == "TRUE" + case "STATEMENT CACHE PURGE": + ret.StmtCachePurge = val[0] == "TRUE" + case "HA EVENTS": + ret.HaEvent = val[0] == "TRUE" + case "LOAD BALANCING": + ret.LoadBalance = val[0] == "TRUE" + case "METADATA POOLING": + ret.MetadataBooling = val[0] == "TRUE" + case "SELF TUNING": + ret.SelfTuning = val[0] == "TRUE" + case "CONTEXT CONNECTION": + ret.ContextConnection = val[0] == "TRUE" + case "PROMOTABLE TRANSACTION": + if val[0] == "ROMOTABLE" { + ret.PromotableTransaction = Promotable + } else { + ret.PromotableTransaction = Local + } + case "APPLICATION EDITION": + ret.ApplicationEdition = val[0] + //case "USER ID": + // val = strings.Trim(val, "'") + // conStr.UserID = strings.Trim(val, "\"") + // if conStr.UserID == "\\" { + // // get os user and password + // } + case "PROXY USER ID": + ret.ProxyUserID = val[0] + //case "PASSWORD": + // val = strings.Trim(val, "'") + // conStr.Password = strings.Trim(val, "\"") + case "PROXY PASSWORD": + ret.ProxyPassword = val[0] + } + } + } + ret.validate() + return ret, nil +} +func (conStr *ConnectionString) Parse(s string) error { + + var upperInvariant = strings.ToUpper(s) + var attribs = strings.Split(upperInvariant, ";") + for _, attrib := range attribs { + fields := strings.Split(attrib, "=") + if len(fields) != 2 { + return errors.New("error in connection string") + } + key := fields[0] + val := fields[1] + var err error + switch key { + case "DATA SOURCE": + conStr.DataSource = val + case "DBA PRIVILEGE": + conStr.DBAPrivilege = DBAPrivilegeFromString(val) + case "ENLIST": + conStr.EnList = EnListFromString(val) + case "CONNECT TIMEOUT": + fallthrough + case "CONNECTION TIMEOUT": + conStr.ConnectionTimeOut, err = strconv.Atoi(val) + if err != nil { + return errors.New("CONNECTION TIMEOUT value must be an integer") + } + case "INC POOL SIZE": + conStr.IncrPoolSize, err = strconv.Atoi(val) + if err != nil { + return errors.New("INC POOL SIZE value must be an integer") + } + case "DECR POOL SIZE": + conStr.DecrPoolSize, err = strconv.Atoi(val) + if err != nil { + return errors.New("DECR POOL SIZE value must be an integer") + } + case "MAX POOL SIZE": + conStr.MaxPoolSize, err = strconv.Atoi(val) + if err != nil { + return errors.New("MAX POOL SIZE value must be an integer") + } + case "MIN POOL SIZE": + conStr.MinPoolSize, err = strconv.Atoi(val) + if err != nil { + return errors.New("MIN POOL SIZE value must be an integer") + } + case "POOL REGULATOR": + conStr.PoolReglator, err = strconv.Atoi(val) + if err != nil { + return errors.New("POOL REGULATOR value must be an integer") + } + case "STATEMENT CACHE SIZE": + conStr.StmtCacheSize, err = strconv.Atoi(val) + if err != nil { + return errors.New("STATEMENT CACHE SIZE value must be an integer") + } + case "CONNECTION POOL TIMEOUT": + conStr.ConnectionPoolTimeout, err = strconv.Atoi(val) + if err != nil { + return errors.New("CONNECTION POOL TIMEOUT value must be an integer") + } + case "CONNECTION LIFETIME": + case "PERSIST SECURITY INFO": + conStr.PasswordSecurityInfo = val == "TRUE" + case "POOLING": + conStr.Pooling = val == "TRUE" + case "VALIDATE CONNECTION": + conStr.ValidateConnection = val == "TRUE" + case "STATEMENT CACHE PURGE": + conStr.StmtCachePurge = val == "TRUE" + case "HA EVENTS": + conStr.HaEvent = val == "TRUE" + case "LOAD BALANCING": + conStr.LoadBalance = val == "TRUE" + case "METADATA POOLING": + conStr.MetadataBooling = val == "TRUE" + case "SELF TUNING": + conStr.SelfTuning = val == "TRUE" + case "CONTEXT CONNECTION": + conStr.ContextConnection = val == "TRUE" + case "PROMOTABLE TRANSACTION": + if val == "ROMOTABLE" { + conStr.PromotableTransaction = Promotable + } else { + conStr.PromotableTransaction = Local + } + case "APPLICATION EDITION": + conStr.ApplicationEdition = val + case "USER ID": + val = strings.Trim(val, "'") + conStr.UserID = strings.Trim(val, "\"") + if conStr.UserID == "\\" { + // get os user and password + } + case "PROXY USER ID": + val = strings.Trim(val, "'") + conStr.ProxyUserID = strings.Trim(val, "\"") + case "PASSWORD": + val = strings.Trim(val, "'") + conStr.Password = strings.Trim(val, "\"") + case "PROXY PASSWORD": + val = strings.Trim(val, "'") + conStr.ProxyPassword = strings.Trim(val, "\"") + } + + } + return nil +} diff --git a/converters/string_conversion.go b/converters/string_conversion.go new file mode 100644 index 00000000..dd4d2fcd --- /dev/null +++ b/converters/string_conversion.go @@ -0,0 +1,8846 @@ +package converters + +import ( + "encoding/binary" + "unicode/utf16" +) + +type StringConverter struct { + LangID int + CharWidth int + eReplace int + dReplace int + dBuffer []int + eBuffer map[int]int +} + +func MaxBytePerChar(charsetID int) int { + switch charsetID { + case 870: + fallthrough + case 871: + return 3 + case 872: + fallthrough + case 873: + return 4 + case 2000: + fallthrough + case 2002: + return 2 + default: + return 1 + } +} + +func (conv *StringConverter) Encode(input string) []byte { + if len(input) == 0 { + return nil + } + temp := utf16.Encode([]rune(input)) + switch conv.LangID { + case 870: + fallthrough + case 871: + fallthrough + case 872: + fallthrough + case 873: // 32bit utf-8 + // utf-8 encoding + return []byte(input) + case 2000: + output := make([]byte, 0, len(temp)*2) + for x := 0; x < len(temp); x++ { + tempbyte := []byte{0, 0} + binary.BigEndian.PutUint16(tempbyte, temp[x]) + output = append(output, tempbyte...) + } + return output + case 2002: + output := make([]byte, 0, len(temp)*2) + for x := 0; x < len(temp); x++ { + tempbyte := []byte{0, 0} + binary.LittleEndian.PutUint16(tempbyte, temp[x]) + output = append(output, tempbyte...) + } + return output + default: + output := make([]byte, len(temp)) + for x := 0; x < len(temp); x++ { + if ch, ok := conv.eBuffer[int(temp[x])]; ok { + output[x] = uint8(ch) + } else { + output[x] = uint8(conv.eReplace) + } + } + return output + } +} + +func (conv *StringConverter) Decode(input []byte) string { + if len(input) == 0 { + return "" + } + switch conv.LangID { + case 870: + fallthrough + case 871: + fallthrough + case 872: + fallthrough + case 873: + // utf-8 encoding + return string(input) + case 2000: + index := 0 + if len(input)%2 > 0 { + input = append(input, 0) + } + output := make([]uint16, len(input)/2) + for index < len(input) { + output[index/2] = binary.BigEndian.Uint16(input[index : index+2]) + index += 2 + } + return string(utf16.Decode(output)) + case 2002: + index := 0 + if len(input)%2 > 0 { + input = append(input, 0) + } + output := make([]uint16, len(input)/2) + for index < len(input) { + output[index/2] = binary.LittleEndian.Uint16(input[index : index+2]) + index += 2 + } + return string(utf16.Decode(output)) + default: + output := make([]uint16, len(input)) + for x := 0; x < len(input); x++ { + index := int(input[x]) + if index >= len(conv.dBuffer) { + output[x] = uint16(conv.dReplace) + } else { + output[x] = uint16(conv.dBuffer[input[x]]) + // change number to byte + if output[x] == 0xFFFF { + output[x] = uint16(conv.dReplace) + } + } + + } + return string(utf16.Decode(output)) + } +} + +func NewStringConverter(langID int) *StringConverter { + switch langID { + case 0x1: // 1 + return &StringConverter{ + LangID: 1, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 163: 35, 165: 89, 63741: 102, 8356: 76, + 192: 65, 193: 65, 194: 65, 196: 65, 258: 65, 260: 65, 262: 67, 268: 67, 199: 67, 270: 68, 272: 68, 200: 69, 201: 69, 202: 69, 203: 69, 282: 69, + 280: 69, 204: 73, 205: 73, 206: 73, 313: 76, 317: 76, 321: 76, 323: 78, 327: 78, 210: 79, 211: 79, 212: 79, 214: 79, 336: 79, 340: 82, 344: 82, + 346: 83, 352: 83, 350: 83, 356: 84, 354: 84, 217: 85, 218: 85, 219: 85, 220: 85, 368: 85, 366: 85, 221: 89, 377: 90, 381: 90, 379: 90, 224: 97, + 225: 97, 226: 97, 228: 97, 259: 97, 261: 97, 263: 99, 269: 99, 231: 99, 271: 100, 273: 100, 232: 101, 233: 101, 234: 101, 235: 101, 283: 101, 281: 101, + 236: 105, 237: 105, 238: 105, 314: 108, 318: 108, 322: 108, 324: 110, 328: 110, 242: 111, 243: 111, 244: 111, 246: 111, 337: 111, 341: 114, 345: 114, 347: 115, + 353: 115, 351: 115, 357: 116, 355: 116, 249: 117, 250: 117, 251: 117, 252: 117, 369: 117, 367: 117, 253: 121, 378: 122, 382: 122, 380: 122, 207: 73, 239: 105, + 255: 121, + }, + } + case 0x2: // 2 + return &StringConverter{ + LangID: 2, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 161, 162, 163, 65535, 165, 65535, 167, 164, 169, 170, 171, 65535, 65535, 65535, 65535, + 176, 177, 178, 179, 65535, 181, 182, 183, 65535, 185, 186, 187, 188, 189, 65535, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 65535, 209, 210, 211, 212, 213, 214, 338, 216, 217, 218, 219, 220, 376, 65535, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 65535, 241, 242, 243, 244, 245, 246, 339, 248, 249, 250, 251, 252, 255, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 161: 161, 162: 162, 163: 163, 165: 165, 167: 167, 164: 168, 169: 169, 170: 170, 171: 171, 176: 176, 177: 177, 178: 178, 179: 179, 181: 181, 182: 182, + 183: 183, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 191: 191, 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, + 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 338: 215, 216: 216, 217: 217, + 218: 218, 219: 219, 220: 220, 376: 221, 223: 223, 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, + 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 339: 247, 248: 248, 249: 249, 250: 250, 251: 251, + 252: 252, 255: 253, 8216: 96, 8213: 45, 175: 45, 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 63741: 102, 8356: 76, 221: 89, 253: 121, 946: 223, + }, + } + case 0x3: // 3 + return &StringConverter{ + LangID: 3, + CharWidth: 1, + eReplace: 65533, + dReplace: 252, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 8248, 95, + 8216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 8764, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 192, 194, 200, 202, 203, 206, 207, 180, 96, 94, 168, 126, 217, 219, 8356, + 175, 65535, 65535, 176, 199, 231, 209, 241, 161, 191, 164, 163, 165, 167, 402, 162, + 226, 234, 244, 251, 225, 233, 243, 250, 224, 232, 242, 249, 228, 235, 246, 252, + 197, 238, 216, 198, 229, 237, 248, 230, 196, 236, 214, 220, 201, 239, 223, 212, + 193, 195, 227, 272, 273, 205, 204, 211, 210, 213, 245, 352, 353, 218, 376, 255, + 222, 254, 65535, 65535, 65535, 65535, 8213, 188, 189, 170, 186, 171, 8718, 187, 177, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 8248: 94, 95: 95, + 8216: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 8764: 126, 127: 127, + 65535: 255, 192: 161, 194: 162, 200: 163, 202: 164, 203: 165, 206: 166, 207: 167, 180: 168, 96: 169, 94: 170, 168: 171, 126: 172, 217: 173, 219: 174, 8356: 175, + 175: 176, 176: 179, 199: 180, 231: 181, 209: 182, 241: 183, 161: 184, 191: 185, 164: 186, 163: 187, 165: 188, 167: 189, 402: 190, 162: 191, 226: 192, 234: 193, + 244: 194, 251: 195, 225: 196, 233: 197, 243: 198, 250: 199, 224: 200, 232: 201, 242: 202, 249: 203, 228: 204, 235: 205, 246: 206, 252: 207, 197: 208, 238: 209, + 216: 210, 198: 211, 229: 212, 237: 213, 248: 214, 230: 215, 196: 216, 236: 217, 214: 218, 220: 219, 201: 220, 239: 221, 223: 222, 212: 223, 193: 224, 195: 225, + 227: 226, 272: 227, 273: 228, 205: 229, 204: 230, 211: 231, 210: 232, 213: 233, 245: 234, 352: 235, 353: 236, 218: 237, 376: 238, 255: 239, 222: 240, 254: 241, + 8213: 246, 188: 247, 189: 248, 170: 249, 186: 250, 171: 251, 8718: 252, 187: 253, 177: 254, 160: 32, 173: 45, 166: 124, 221: 89, 253: 121, 946: 222, 63741: 190, + }, + } + case 0x4: // 4 + return &StringConverter{ + LangID: 4, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 239, 238, 236, 196, 197, + 201, 230, 198, 244, 246, 242, 251, 249, 255, 214, 220, 162, 163, 165, 8359, 402, + 225, 237, 243, 250, 241, 209, 170, 186, 191, 8976, 172, 189, 188, 161, 171, 187, + 9617, 9618, 9619, 9474, 9508, 9569, 9570, 9558, 9557, 9571, 9553, 9559, 9565, 9564, 9563, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 9566, 9567, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9575, + 9576, 9572, 9573, 9561, 9560, 9554, 9555, 9579, 9578, 9496, 9484, 9608, 9604, 9612, 9616, 9600, + 945, 946, 915, 960, 931, 963, 956, 964, 934, 920, 937, 948, 8734, 966, 949, 8745, + 8801, 177, 8805, 8804, 8992, 8993, 247, 8776, 176, 8729, 183, 8730, 8319, 178, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 236: 141, 196: 142, 197: 143, + 201: 144, 230: 145, 198: 146, 244: 147, 246: 148, 242: 149, 251: 150, 249: 151, 255: 152, 214: 153, 220: 154, 162: 155, 163: 156, 165: 157, 8359: 158, 402: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 170: 166, 186: 167, 191: 168, 8976: 169, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 187: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 9569: 181, 9570: 182, 9558: 183, 9557: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 9564: 189, 9563: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 9566: 198, 9567: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 9575: 207, + 9576: 208, 9572: 209, 9573: 210, 9561: 211, 9560: 212, 9554: 213, 9555: 214, 9579: 215, 9578: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 9612: 221, 9616: 222, 9600: 223, + 945: 224, 946: 225, 915: 226, 960: 227, 931: 228, 963: 229, 956: 230, 964: 231, 934: 232, 920: 233, 937: 234, 948: 235, 8734: 236, 966: 237, 949: 238, 8745: 239, + 8801: 240, 177: 241, 8805: 242, 8804: 243, 8992: 244, 8993: 245, 247: 246, 8776: 247, 176: 248, 8729: 249, 183: 250, 8730: 251, 8319: 252, 178: 253, 8718: 254, 160: 255, + 8216: 96, 181: 230, 8213: 45, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 8356: 76, 192: 65, 193: 65, 194: 65, 195: 65, 200: 69, 202: 69, 203: 69, + 204: 73, 205: 73, 206: 73, 207: 73, 210: 79, 211: 79, 212: 79, 213: 79, 217: 85, 218: 85, 219: 85, 221: 89, 227: 97, 245: 111, 253: 121, 223: 225, + 63741: 159, 63742: 250, + }, + } + case 0x5: // 5 + return &StringConverter{ + LangID: 5, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 162, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 94, 163, 165, 183, 169, 167, 182, 188, 189, 190, 91, 93, 175, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 94: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 91: 186, 93: 187, 175: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 176, + 8764: 161, 376: 232, + }, + } + case 0x6: // 6 + return &StringConverter{ + LangID: 6, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 91, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 93, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 95, + 8764: 161, 376: 232, + }, + } + case 0x7: // 7 + return &StringConverter{ + LangID: 7, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 162, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 94, 163, 165, 183, 169, 167, 182, 188, 189, 190, 91, 93, 175, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 94: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 91: 186, 93: 187, 175: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 176, + 8764: 161, 376: 232, + }, + } + case 0x8: // 8 + return &StringConverter{ + LangID: 8, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 36, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 163, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 175, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 91, 165, 183, 169, 167, 182, 188, 189, 190, 94, 93, 126, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 36: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 163: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 175: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 91: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 94: 186, 93: 187, 126: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0x9: // 9 + return &StringConverter{ + LangID: 9, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 36, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 163, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 181, 175, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 91, 165, 183, 169, 167, 182, 188, 189, 190, 94, 93, 126, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 36: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 163: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 181: 160, 175: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 91: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 94: 186, 93: 187, 126: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0xa: // 10 + return &StringConverter{ + LangID: 10, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 239, 238, 236, 196, 197, + 201, 230, 198, 244, 246, 242, 251, 249, 255, 214, 220, 248, 163, 216, 215, 402, + 225, 237, 243, 250, 241, 209, 170, 186, 191, 174, 172, 189, 188, 161, 171, 187, + 9617, 9618, 9619, 9474, 9508, 193, 194, 192, 169, 9571, 9553, 9559, 9565, 162, 165, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 227, 195, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 164, + 240, 208, 202, 203, 200, 305, 205, 206, 207, 9496, 9484, 9608, 9604, 166, 204, 9600, + 211, 223, 212, 210, 245, 213, 181, 254, 222, 218, 219, 217, 253, 221, 175, 180, + 173, 177, 8215, 190, 182, 167, 247, 184, 176, 168, 183, 185, 179, 178, 9632, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 236: 141, 196: 142, 197: 143, + 201: 144, 230: 145, 198: 146, 244: 147, 246: 148, 242: 149, 251: 150, 249: 151, 255: 152, 214: 153, 220: 154, 248: 155, 163: 156, 216: 157, 215: 158, 402: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 170: 166, 186: 167, 191: 168, 174: 169, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 187: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 193: 181, 194: 182, 192: 183, 169: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 162: 189, 165: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 227: 198, 195: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 164: 207, + 240: 208, 208: 209, 202: 210, 203: 211, 200: 212, 305: 213, 205: 214, 206: 215, 207: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 166: 221, 204: 222, 9600: 223, + 211: 224, 223: 225, 212: 226, 210: 227, 245: 228, 213: 229, 181: 230, 254: 231, 222: 232, 218: 233, 219: 234, 217: 235, 253: 236, 221: 237, 175: 238, 180: 239, + 173: 240, 177: 241, 8215: 242, 190: 243, 182: 244, 167: 245, 247: 246, 184: 247, 176: 248, 168: 249, 183: 250, 185: 251, 179: 252, 178: 253, 9632: 254, 160: 255, + 8216: 96, 8213: 45, 8248: 94, 8718: 254, 8764: 126, 8356: 76, 63741: 159, + }, + } + case 0xb: // 11 + return &StringConverter{ + LangID: 11, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 220, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 252, 223, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 220, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 252, 223, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 167: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 196: 219, 214: 220, 220: 221, 94: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 228: 251, 246: 252, 252: 253, 223: 254, 127: 255, + 64: 64, 91: 91, 92: 92, 93: 93, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 124, + 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 204: 73, 205: 73, 206: 73, + 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 224: 97, 225: 97, 226: 97, 231: 99, 232: 101, 233: 101, 234: 101, 236: 105, 237: 105, 238: 105, + 242: 111, 243: 111, 244: 111, 249: 117, 250: 117, 251: 117, 946: 126, + }, + } + case 0xc: // 12 + return &StringConverter{ + LangID: 12, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 224, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 176, 231, 167, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 233, 249, 232, 168, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 224, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 176, 231, 167, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 233, 249, 232, 168, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 163: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 224: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 176: 219, 231: 220, 167: 221, 94: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 233: 251, 249: 252, 232: 253, 168: 254, 127: 255, + 35: 35, 64: 64, 91: 91, 92: 92, 93: 93, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, + 166: 124, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 204: 73, 205: 73, + 206: 73, 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 225: 97, 226: 97, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, 243: 111, 244: 111, + 250: 117, 251: 117, + }, + } + case 0xd: // 13 + return &StringConverter{ + LangID: 13, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 201, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 197, 220, 95, + 233, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 229, 252, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 201, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 197, 220, 95, + 233, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 229, 252, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 201: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 196: 219, 214: 220, 197: 221, 220: 222, 95: 223, + 233: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 228: 251, 246: 252, 229: 253, 252: 254, 127: 255, + 64: 64, 91: 91, 92: 92, 93: 93, 94: 94, 96: 96, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, + 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 202: 69, 204: 73, 205: 73, 206: 73, + 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 224: 97, 225: 98, 226: 99, 231: 99, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, 243: 111, + 244: 111, 249: 117, 250: 117, 251: 117, + }, + } + case 0xe: // 14 + return &StringConverter{ + LangID: 14, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 161, 209, 191, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 176, 241, 231, 126, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 161, 209, 191, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 176, 241, 231, 126, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 163: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 167: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 161: 219, 209: 220, 191: 221, 94: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 176: 251, 241: 252, 231: 253, 126: 254, 127: 255, + 35: 35, 64: 64, 91: 91, 92: 92, 93: 93, 123: 123, 124: 124, 125: 125, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 124, 180: 39, + 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, + 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 224: 97, 225: 97, 226: 97, 232: 101, 233: 101, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, 243: 111, + 244: 111, 249: 117, 250: 117, 251: 117, + }, + } + case 0xf: // 15 + return &StringConverter{ + LangID: 15, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 197, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 229, 126, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 197, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 229, 126, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 64: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 196: 219, 214: 220, 197: 221, 94: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 228: 251, 246: 252, 229: 253, 126: 254, 127: 255, + 91: 91, 92: 92, 93: 93, 123: 123, 124: 124, 125: 125, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, + 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 195: 65, 198: 91, 199: 67, 208: 68, 200: 69, 201: 69, 202: 69, 203: 69, 204: 73, + 205: 73, 206: 73, 207: 73, 209: 78, 210: 79, 211: 79, 212: 79, 213: 79, 338: 92, 216: 92, 222: 84, 217: 85, 218: 85, 219: 85, 220: 89, 221: 89, + 376: 89, 224: 97, 225: 97, 226: 97, 227: 97, 230: 123, 231: 99, 240: 100, 232: 101, 233: 101, 234: 101, 235: 101, 236: 105, 237: 105, 238: 105, 239: 105, + 241: 110, 242: 111, 243: 111, 244: 111, 245: 111, 339: 124, 248: 124, 254: 116, 249: 117, 250: 117, 251: 117, 252: 121, 253: 121, 255: 121, 223: 115, + }, + } + case 0x10: // 16 + return &StringConverter{ + LangID: 16, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 196, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 198, 216, 197, 220, 95, + 228, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 230, 248, 229, 252, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 196, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 198, 216, 197, 220, 95, + 228, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 230, 248, 229, 252, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 196: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 198: 219, 216: 220, 197: 221, 220: 222, 95: 223, + 228: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 230: 251, 248: 252, 229: 253, 252: 254, 127: 255, + 64: 64, 91: 91, 92: 92, 93: 93, 94: 94, 96: 96, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, + 173: 45, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, + 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 224: 97, 225: 98, 226: 99, 231: 99, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, 243: 111, 244: 111, + 249: 117, 250: 117, 251: 117, + }, + } + case 0x11: // 17 + return &StringConverter{ + LangID: 17, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 176, 231, 233, 94, 95, + 249, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 224, 242, 232, 236, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 176, 231, 233, 94, 95, + 249, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 224, 242, 232, 236, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 163: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 167: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 176: 219, 231: 220, 233: 221, 94: 222, 95: 223, + 249: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 224: 251, 242: 252, 232: 253, 236: 254, 127: 255, + 35: 35, 64: 64, 91: 91, 92: 92, 93: 93, 96: 96, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, + 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 204: 73, + 205: 73, 206: 73, 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 225: 97, 226: 97, 234: 101, 237: 105, 238: 105, 243: 111, 244: 111, 250: 117, + 251: 117, + }, + } + case 0x12: // 18 + return &StringConverter{ + LangID: 18, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 190, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 307, 189, 124, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 168, 63741, 188, 180, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 190, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 307, 189, 124, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 168, 63741, 188, 180, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 163: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 190: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 307: 219, 189: 220, 124: 221, 94: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 168: 251, 63741: 252, 188: 253, 180: 254, 127: 255, + 35: 35, 64: 64, 91: 91, 92: 92, 93: 93, 123: 123, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 93, + 8248: 94, 8764: 126, 165: 89, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, 211: 79, + 212: 79, 217: 85, 218: 85, 219: 85, 221: 89, 224: 97, 225: 97, 226: 97, 231: 99, 232: 101, 233: 101, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, + 243: 111, 244: 111, 249: 117, 250: 117, 251: 117, 253: 121, + }, + } + case 0x13: // 19 + return &StringConverter{ + LangID: 19, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 249, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 224, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 233, 231, 234, 238, 232, + 244, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 252, 251, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 249, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 224, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 233, 231, 234, 238, 232, + 244, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 252, 251, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 249: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 224: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 233: 219, 231: 220, 234: 221, 238: 222, 232: 223, + 244: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 228: 251, 246: 252, 252: 253, 251: 254, 127: 255, + 35: 35, 64: 64, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, 96: 96, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, + 8213: 45, 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, + 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 221: 89, 225: 97, 226: 97, 236: 105, 237: 105, 242: 111, + 243: 111, 250: 117, 253: 121, + }, + } + case 0x14: // 20 + return &StringConverter{ + LangID: 20, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 381, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 352, 272, 262, 268, 95, + 382, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 353, 273, 263, 269, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 381, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 352, 272, 262, 268, 95, + 382, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 353, 273, 263, 269, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 381: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 352: 219, 272: 220, 262: 221, 268: 222, 95: 223, + 382: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 353: 251, 273: 252, 263: 253, 269: 254, 127: 255, + }, + } + case 0x15: // 21 + return &StringConverter{ + LangID: 21, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 197, 220, 95, + 233, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 229, 252, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 197, 220, 95, + 233, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 229, 252, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 64: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 196: 219, 214: 220, 197: 221, 220: 222, 95: 223, + 233: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 228: 251, 246: 252, 229: 253, 252: 254, 127: 255, + 91: 91, 92: 92, 93: 93, 94: 94, 96: 96, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, + 166: 124, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 201: 69, 202: 69, 204: 73, 205: 73, 206: 73, + 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 224: 97, 225: 98, 226: 99, 231: 99, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, 243: 111, + 244: 111, 249: 117, 250: 117, 251: 117, + }, + } + case 0x16: // 22 + return &StringConverter{ + LangID: 22, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 305, 34, 35, 36, 37, 287, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 304, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 350, 214, 199, 220, 95, + 286, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 351, 246, 231, 252, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 305, 34, 35, 36, 37, 287, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 304, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 350, 214, 199, 220, 95, + 286, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 351, 246, 231, 252, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 305: 161, 34: 162, 35: 163, 36: 164, 37: 165, 287: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 304: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 350: 219, 214: 220, 199: 221, 220: 222, 95: 223, + 286: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 351: 251, 246: 252, 231: 253, 252: 254, 127: 255, + 33: 33, 38: 38, 64: 64, 91: 91, 92: 92, 93: 93, 94: 94, 96: 96, 123: 123, 124: 124, 125: 125, 126: 126, 171: 60, 187: 62, 8216: 96, 8213: 45, + 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 201: 69, 202: 69, 63738: 73, 204: 73, + 205: 73, 206: 73, 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 224: 97, 225: 98, 226: 99, 234: 101, 236: 105, 237: 105, 238: 105, 63736: 105, + 242: 111, 243: 111, 244: 111, 249: 117, 250: 117, 251: 117, + }, + } + case 0x17: // 23 + return &StringConverter{ + LangID: 23, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, + 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 123, 124, 125, 126, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, + 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 123, 124, 125, 126, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 64: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 91: 219, 92: 220, 93: 221, 94: 222, 95: 223, + 1488: 224, 1489: 225, 1490: 226, 1491: 227, 1492: 228, 1493: 229, 1494: 230, 1495: 231, 1496: 232, 1497: 233, 1498: 234, 1499: 235, 1500: 236, 1501: 237, 1502: 238, 1503: 239, + 1504: 240, 1505: 241, 1506: 242, 1507: 243, 1508: 244, 1509: 245, 1510: 246, 1511: 247, 1512: 248, 1513: 249, 1514: 250, 123: 251, 124: 252, 125: 253, 126: 254, 127: 255, + 97: 65, 98: 66, 99: 67, 100: 68, 101: 69, 102: 70, 103: 71, 104: 72, 105: 73, 106: 74, 107: 75, 108: 76, 109: 77, 110: 78, 111: 79, 112: 80, + 113: 81, 114: 82, 115: 83, 116: 84, 117: 85, 118: 86, 119: 87, 120: 88, 121: 89, 122: 90, 171: 60, 187: 62, 183: 46, 160: 32, 173: 45, 166: 124, + 819: 95, 180: 39, 168: 34, 184: 44, 172: 45, 215: 42, 247: 47, + }, + } + case 0x19: // 25 + return &StringConverter{ + LangID: 25, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 2305, 2306, 2307, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2318, 2319, 2320, 2317, 2322, + 2323, 2324, 2321, 2325, 2326, 2327, 2328, 2329, 2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, + 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2399, 2352, + 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361, 160, 2366, 2367, 2368, 2369, 2370, 2371, + 2374, 2375, 2376, 2373, 2378, 2379, 2380, 2377, 2381, 2364, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 2415, 65535, 65535, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 2305: 161, 2306: 162, 2307: 163, 2309: 164, 2310: 165, 2311: 166, 2312: 167, 2313: 168, 2314: 169, 2315: 170, 2318: 171, 2319: 172, 2320: 173, 2317: 174, 2322: 175, + 2323: 176, 2324: 177, 2321: 178, 2325: 179, 2326: 180, 2327: 181, 2328: 182, 2329: 183, 2330: 184, 2331: 185, 2332: 186, 2333: 187, 2334: 188, 2335: 189, 2336: 190, 2337: 191, + 2338: 192, 2339: 193, 2340: 194, 2341: 195, 2342: 196, 2343: 197, 2344: 198, 2345: 199, 2346: 200, 2347: 201, 2348: 202, 2349: 203, 2350: 204, 2351: 205, 2399: 206, 2352: 207, + 2353: 208, 2354: 209, 2355: 210, 2356: 211, 2357: 212, 2358: 213, 2359: 214, 2360: 215, 2361: 216, 160: 217, 2366: 218, 2367: 219, 2368: 220, 2369: 221, 2370: 222, 2371: 223, + 2374: 224, 2375: 225, 2376: 226, 2373: 227, 2378: 228, 2379: 229, 2380: 230, 2377: 231, 2381: 232, 2364: 233, 2406: 241, 2407: 242, 2408: 243, 2409: 244, 2410: 245, 2411: 246, + 2412: 247, 2413: 248, 2414: 249, 2415: 250, + }, + } + case 0x1b: // 27 + return &StringConverter{ + LangID: 27, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 91, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 93, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 95, + 8764: 161, 376: 232, + }, + } + case 0x1c: // 28 + return &StringConverter{ + LangID: 28, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 239, 238, 236, 196, 197, + 201, 230, 198, 244, 246, 242, 251, 249, 255, 214, 220, 248, 163, 216, 215, 402, + 225, 237, 243, 250, 241, 209, 170, 186, 191, 174, 172, 189, 188, 161, 171, 187, + 9617, 9618, 9619, 9474, 9508, 193, 194, 192, 169, 9571, 9553, 9559, 9565, 162, 165, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 227, 195, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 164, + 240, 208, 202, 203, 200, 8364, 205, 206, 207, 9496, 9484, 9608, 9604, 166, 204, 9600, + 211, 223, 212, 210, 245, 213, 181, 254, 222, 218, 219, 217, 253, 221, 175, 180, + 173, 177, 8215, 190, 182, 167, 247, 184, 176, 168, 183, 185, 179, 178, 9632, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 236: 141, 196: 142, 197: 143, + 201: 144, 230: 145, 198: 146, 244: 147, 246: 148, 242: 149, 251: 150, 249: 151, 255: 152, 214: 153, 220: 154, 248: 155, 163: 156, 216: 157, 215: 158, 402: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 170: 166, 186: 167, 191: 168, 174: 169, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 187: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 193: 181, 194: 182, 192: 183, 169: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 162: 189, 165: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 227: 198, 195: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 164: 207, + 240: 208, 208: 209, 202: 210, 203: 211, 200: 212, 8364: 213, 205: 214, 206: 215, 207: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 166: 221, 204: 222, 9600: 223, + 211: 224, 223: 225, 212: 226, 210: 227, 245: 228, 213: 229, 181: 230, 254: 231, 222: 232, 218: 233, 219: 234, 217: 235, 253: 236, 221: 237, 175: 238, 180: 239, + 173: 240, 177: 241, 8215: 242, 190: 243, 182: 244, 167: 245, 247: 246, 184: 247, 176: 248, 168: 249, 183: 250, 185: 251, 179: 252, 178: 253, 9632: 254, 160: 255, + 8216: 96, 8213: 45, 8248: 94, 8764: 126, 8356: 76, 63741: 159, 305: 213, 8718: 254, + }, + } + case 0x1f: // 31 + return &StringConverter{ + LangID: 31, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 161: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, + 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, + 208: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 221: 221, 222: 222, 223: 223, + 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, + 240: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 253: 253, 254: 254, 255: 255, + 8216: 96, 8213: 45, 63742: 183, 8248: 94, 8764: 126, 63741: 102, 8356: 76, 376: 89, 946: 223, + }, + } + case 0x20: // 32 + return &StringConverter{ + LangID: 32, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 260, 728, 321, 164, 317, 346, 167, 168, 352, 350, 356, 377, 173, 381, 379, + 176, 261, 731, 322, 180, 318, 347, 711, 184, 353, 351, 357, 378, 733, 382, 380, + 340, 193, 194, 258, 196, 313, 262, 199, 268, 201, 280, 203, 282, 205, 206, 270, + 272, 323, 327, 211, 212, 336, 214, 215, 344, 366, 218, 368, 220, 221, 354, 223, + 341, 225, 226, 259, 228, 314, 263, 231, 269, 233, 281, 235, 283, 237, 238, 271, + 273, 324, 328, 243, 244, 337, 246, 247, 345, 367, 250, 369, 252, 253, 355, 729, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 260: 161, 728: 162, 321: 163, 164: 164, 317: 165, 346: 166, 167: 167, 168: 168, 352: 169, 350: 170, 356: 171, 377: 172, 173: 173, 381: 174, 379: 175, + 176: 176, 261: 177, 731: 178, 322: 179, 180: 180, 318: 181, 347: 182, 711: 183, 184: 184, 353: 185, 351: 186, 357: 187, 378: 188, 733: 189, 382: 190, 380: 191, + 340: 192, 193: 193, 194: 194, 258: 195, 196: 196, 313: 197, 262: 198, 199: 199, 268: 200, 201: 201, 280: 202, 203: 203, 282: 204, 205: 205, 206: 206, 270: 207, + 272: 208, 323: 209, 327: 210, 211: 211, 212: 212, 336: 213, 214: 214, 215: 215, 344: 216, 366: 217, 218: 218, 368: 219, 220: 220, 221: 221, 354: 222, 223: 223, + 341: 224, 225: 225, 226: 226, 259: 227, 228: 228, 314: 229, 263: 230, 231: 231, 269: 232, 233: 233, 281: 234, 235: 235, 283: 236, 237: 237, 238: 238, 271: 239, + 273: 240, 324: 241, 328: 242, 243: 243, 244: 244, 337: 245, 246: 246, 247: 247, 345: 248, 367: 249, 250: 250, 369: 251, 252: 252, 253: 253, 355: 254, 729: 255, + 730: 176, + }, + } + case 0x21: // 33 + return &StringConverter{ + LangID: 33, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 294, 728, 163, 164, 65535, 292, 167, 168, 304, 350, 286, 308, 173, 65535, 379, + 176, 295, 178, 179, 180, 181, 293, 183, 184, 305, 351, 287, 309, 189, 65535, 380, + 192, 193, 194, 65535, 196, 266, 264, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 65535, 209, 210, 211, 212, 288, 214, 215, 284, 217, 218, 219, 220, 364, 348, 223, + 224, 225, 226, 65535, 228, 267, 265, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 65535, 241, 242, 243, 244, 289, 246, 247, 285, 249, 250, 251, 252, 365, 349, 729, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 294: 161, 728: 162, 163: 163, 164: 164, 65535: 240, 292: 166, 167: 167, 168: 168, 304: 169, 350: 170, 286: 171, 308: 172, 173: 173, 379: 175, 176: 176, + 295: 177, 178: 178, 179: 179, 180: 180, 181: 181, 293: 182, 183: 183, 184: 184, 305: 185, 351: 186, 287: 187, 309: 188, 189: 189, 380: 191, 192: 192, 193: 193, + 194: 194, 196: 196, 266: 197, 264: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, 209: 209, 210: 210, 211: 211, + 212: 212, 288: 213, 214: 214, 215: 215, 284: 216, 217: 217, 218: 218, 219: 219, 220: 220, 364: 221, 348: 222, 223: 223, 224: 224, 225: 225, 226: 226, 228: 228, + 267: 229, 265: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, 241: 241, 242: 242, 243: 243, 244: 244, 289: 245, + 246: 246, 247: 247, 285: 248, 249: 249, 250: 250, 251: 251, 252: 252, 365: 253, 349: 254, 729: 255, + }, + } + case 0x22: // 34 + return &StringConverter{ + LangID: 34, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 260, 312, 342, 164, 296, 315, 167, 168, 352, 274, 290, 358, 173, 381, 713, + 176, 261, 731, 343, 180, 297, 316, 711, 184, 353, 275, 291, 359, 330, 382, 331, + 256, 193, 194, 195, 196, 197, 198, 302, 268, 201, 280, 203, 278, 205, 206, 298, + 272, 325, 332, 310, 212, 213, 214, 215, 216, 370, 218, 219, 220, 360, 362, 223, + 257, 225, 226, 227, 228, 229, 230, 303, 269, 233, 281, 235, 279, 237, 238, 299, + 273, 326, 333, 311, 244, 245, 246, 247, 248, 371, 250, 251, 252, 361, 363, 729, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 260: 161, 312: 162, 342: 163, 164: 164, 296: 165, 315: 166, 167: 167, 168: 168, 352: 169, 274: 170, 290: 171, 358: 172, 173: 173, 381: 174, 713: 175, + 176: 176, 261: 177, 731: 178, 343: 179, 180: 180, 297: 181, 316: 182, 711: 183, 184: 184, 353: 185, 275: 186, 291: 187, 359: 188, 330: 189, 382: 190, 331: 191, + 256: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 302: 199, 268: 200, 201: 201, 280: 202, 203: 203, 278: 204, 205: 205, 206: 206, 298: 207, + 272: 208, 325: 209, 332: 210, 310: 211, 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 370: 217, 218: 218, 219: 219, 220: 220, 360: 221, 362: 222, 223: 223, + 257: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 303: 231, 269: 232, 233: 233, 281: 234, 235: 235, 279: 236, 237: 237, 238: 238, 299: 239, + 273: 240, 326: 241, 333: 242, 311: 243, 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 371: 249, 250: 250, 251: 251, 252: 252, 361: 253, 363: 254, 729: 255, + }, + } + case 0x23: // 35 + return &StringConverter{ + LangID: 35, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 173, 1038, 1039, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, + 8470, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 167, 1118, 1119, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 1025: 161, 1026: 162, 1027: 163, 1028: 164, 1029: 165, 1030: 166, 1031: 167, 1032: 168, 1033: 169, 1034: 170, 1035: 171, 1036: 172, 173: 173, 1038: 174, 1039: 175, + 1040: 176, 1041: 177, 1042: 178, 1043: 179, 1044: 180, 1045: 181, 1046: 182, 1047: 183, 1048: 184, 1049: 185, 1050: 186, 1051: 187, 1052: 188, 1053: 189, 1054: 190, 1055: 191, + 1056: 192, 1057: 193, 1058: 194, 1059: 195, 1060: 196, 1061: 197, 1062: 198, 1063: 199, 1064: 200, 1065: 201, 1066: 202, 1067: 203, 1068: 204, 1069: 205, 1070: 206, 1071: 207, + 1072: 208, 1073: 209, 1074: 210, 1075: 211, 1076: 212, 1077: 213, 1078: 214, 1079: 215, 1080: 216, 1081: 217, 1082: 218, 1083: 219, 1084: 220, 1085: 221, 1086: 222, 1087: 223, + 1088: 224, 1089: 225, 1090: 226, 1091: 227, 1092: 228, 1093: 229, 1094: 230, 1095: 231, 1096: 232, 1097: 233, 1098: 234, 1099: 235, 1100: 236, 1101: 237, 1102: 238, 1103: 239, + 8470: 240, 1105: 241, 1106: 242, 1107: 243, 1108: 244, 1109: 245, 1110: 246, 1111: 247, 1112: 248, 1113: 249, 1114: 250, 1115: 251, 1116: 252, 167: 253, 1118: 254, 1119: 255, + }, + } + case 0x24: // 36 + return &StringConverter{ + LangID: 36, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 65535, 65535, 65535, 164, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 1548, 173, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 1563, 65535, 65535, 65535, 1567, + 65535, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 65535, 65535, 65535, 65535, 65535, + 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 65535: 255, 164: 164, 1548: 172, 173: 173, 1563: 187, 1567: 191, 1569: 193, 1570: 194, 1571: 195, 1572: 196, 1573: 197, 1574: 198, 1575: 199, 1576: 200, 1577: 201, + 1578: 202, 1579: 203, 1580: 204, 1581: 205, 1582: 206, 1583: 207, 1584: 208, 1585: 209, 1586: 210, 1587: 211, 1588: 212, 1589: 213, 1590: 214, 1591: 215, 1592: 216, 1593: 217, + 1594: 218, 1600: 224, 1601: 225, 1602: 226, 1603: 227, 1604: 228, 1605: 229, 1606: 230, 1607: 231, 1608: 232, 1609: 233, 1610: 234, 1611: 235, 1612: 236, 1613: 237, 1614: 238, + 1615: 239, 1616: 240, 1617: 241, 1618: 242, + }, + } + case 0x25: // 37 + return &StringConverter{ + LangID: 37, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 8216, 8217, 163, 8364, 65535, 166, 167, 168, 169, 65535, 171, 172, 173, 65535, 8213, + 176, 177, 178, 179, 900, 901, 902, 183, 904, 905, 906, 187, 908, 189, 910, 911, + 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, + 928, 929, 65535, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, + 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, + 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 8216: 161, 8217: 162, 163: 163, 8364: 164, 65535: 255, 166: 166, 167: 167, 168: 168, 169: 169, 171: 171, 172: 172, 173: 173, 8213: 175, 176: 176, 177: 177, + 178: 178, 179: 179, 900: 180, 901: 181, 902: 182, 183: 183, 904: 184, 905: 185, 906: 186, 187: 187, 908: 188, 189: 189, 910: 190, 911: 191, 912: 192, 913: 193, + 914: 194, 915: 195, 916: 196, 917: 197, 918: 198, 919: 199, 920: 200, 921: 201, 922: 202, 923: 203, 924: 204, 925: 205, 926: 206, 927: 207, 928: 208, 929: 209, + 931: 211, 932: 212, 933: 213, 934: 214, 935: 215, 936: 216, 937: 217, 938: 218, 939: 219, 940: 220, 941: 221, 942: 222, 943: 223, 944: 224, 945: 225, 946: 226, + 947: 227, 948: 228, 949: 229, 950: 230, 951: 231, 952: 232, 953: 233, 954: 234, 955: 235, 956: 236, 957: 237, 958: 238, 959: 239, 960: 240, 961: 241, 962: 242, + 963: 243, 964: 244, 965: 245, 966: 246, 967: 247, 968: 248, 969: 249, 970: 250, 971: 251, 972: 252, 973: 253, 974: 254, + }, + } + case 0x26: // 38 + return &StringConverter{ + LangID: 38, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 65535, 162, 163, 164, 165, 166, 167, 168, 169, 215, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 247, 187, 188, 189, 190, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 8215, + 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, + 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 65535, 65535, 8206, 8207, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 65535: 255, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 215: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 247: 186, 187: 187, 188: 188, 189: 189, 190: 190, 8215: 223, + 1488: 224, 1489: 225, 1490: 226, 1491: 227, 1492: 228, 1493: 229, 1494: 230, 1495: 231, 1496: 232, 1497: 233, 1498: 234, 1499: 235, 1500: 236, 1501: 237, 1502: 238, 1503: 239, + 1504: 240, 1505: 241, 1506: 242, 1507: 243, 1508: 244, 1509: 245, 1510: 246, 1511: 247, 1512: 248, 1513: 249, 1514: 250, 8206: 253, 8207: 254, 819: 223, + }, + } + case 0x27: // 39 + return &StringConverter{ + LangID: 39, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 286, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 304, 350, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 287, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 305, 351, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 161: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, + 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, + 286: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 304: 221, 350: 222, 223: 223, + 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, + 287: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 305: 253, 351: 254, 255: 255, + 8216: 96, 8213: 45, 63742: 183, 8248: 94, 8764: 126, 63741: 102, 8356: 76, 63738: 73, 376: 89, 63736: 105, 946: 223, + }, + } + case 0x28: // 40 + return &StringConverter{ + LangID: 40, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 260, 274, 290, 298, 296, 310, 167, 315, 272, 352, 358, 381, 173, 362, 330, + 176, 261, 275, 291, 299, 297, 311, 183, 316, 273, 353, 359, 382, 65535, 363, 331, + 256, 193, 194, 195, 196, 197, 198, 302, 268, 201, 280, 203, 278, 205, 206, 207, + 208, 325, 332, 211, 212, 213, 214, 360, 216, 370, 218, 219, 220, 221, 222, 223, + 257, 225, 226, 227, 228, 229, 230, 303, 269, 233, 281, 235, 279, 237, 238, 239, + 240, 326, 333, 243, 244, 245, 246, 361, 248, 371, 250, 251, 252, 253, 254, 312, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 260: 161, 274: 162, 290: 163, 298: 164, 296: 165, 310: 166, 167: 167, 315: 168, 272: 169, 352: 170, 358: 171, 381: 172, 173: 173, 362: 174, 330: 175, + 176: 176, 261: 177, 275: 178, 291: 179, 299: 180, 297: 181, 311: 182, 183: 183, 316: 184, 273: 185, 353: 186, 359: 187, 382: 188, 65535: 189, 363: 190, 331: 191, + 256: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 302: 199, 268: 200, 201: 201, 280: 202, 203: 203, 278: 204, 205: 205, 206: 206, 207: 207, + 208: 208, 325: 209, 332: 210, 211: 211, 212: 212, 213: 213, 214: 214, 360: 215, 216: 216, 370: 217, 218: 218, 219: 219, 220: 220, 221: 221, 222: 222, 223: 223, + 257: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 303: 231, 269: 232, 233: 233, 281: 234, 235: 235, 279: 236, 237: 237, 238: 238, 239: 239, + 240: 240, 326: 241, 333: 242, 243: 243, 244: 244, 245: 245, 246: 246, 361: 247, 248: 248, 371: 249, 250: 250, 251: 251, 252: 252, 253: 253, 254: 254, 312: 255, + }, + } + case 0x29: // 41 + return &StringConverter{ + LangID: 41, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8364, 129, 130, 131, 132, 8230, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 3585, 3586, 3587, 3588, 3589, 3590, 3591, 3592, 3593, 3594, 3595, 3596, 3597, 3598, 3599, + 3600, 3601, 3602, 3603, 3604, 3605, 3606, 3607, 3608, 3609, 3610, 3611, 3612, 3613, 3614, 3615, + 3616, 3617, 3618, 3619, 3620, 3621, 3622, 3623, 3624, 3625, 3626, 3627, 3628, 3629, 3630, 3631, + 3632, 3633, 3634, 3635, 3636, 3637, 3638, 3639, 3640, 3641, 3642, 63681, 63682, 63683, 63684, 3647, + 3648, 3649, 3650, 3651, 3652, 3653, 3654, 3655, 3656, 3657, 3658, 3659, 3660, 3661, 3662, 3663, + 3664, 3665, 3666, 3667, 3668, 3669, 3670, 3671, 3672, 3673, 3674, 3675, 63685, 63686, 63687, 63688, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 8364: 128, 129: 129, 130: 130, 131: 131, 132: 132, 8230: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 3585: 161, 3586: 162, 3587: 163, 3588: 164, 3589: 165, 3590: 166, 3591: 167, 3592: 168, 3593: 169, 3594: 170, 3595: 171, 3596: 172, 3597: 173, 3598: 174, 3599: 175, + 3600: 176, 3601: 177, 3602: 178, 3603: 179, 3604: 180, 3605: 181, 3606: 182, 3607: 183, 3608: 184, 3609: 185, 3610: 186, 3611: 187, 3612: 188, 3613: 189, 3614: 190, 3615: 191, + 3616: 192, 3617: 193, 3618: 194, 3619: 195, 3620: 196, 3621: 197, 3622: 198, 3623: 199, 3624: 200, 3625: 201, 3626: 202, 3627: 203, 3628: 204, 3629: 205, 3630: 206, 3631: 207, + 3632: 208, 3633: 209, 3634: 210, 3635: 211, 3636: 212, 3637: 213, 3638: 214, 3639: 215, 3640: 216, 3641: 217, 3642: 218, 63681: 219, 63682: 220, 63683: 221, 63684: 222, 3647: 223, + 3648: 224, 3649: 225, 3650: 226, 3651: 227, 3652: 228, 3653: 229, 3654: 230, 3655: 231, 3656: 232, 3657: 233, 3658: 234, 3659: 235, 3660: 236, 3661: 237, 3662: 238, 3663: 239, + 3664: 240, 3665: 241, 3666: 242, 3667: 243, 3668: 244, 3669: 245, 3670: 246, 3671: 247, 3672: 248, 3673: 249, 3674: 250, 3675: 251, 63685: 252, 63686: 253, 63687: 254, 63688: 255, + 167: 21, 182: 20, 8252: 19, 8592: 27, 8593: 24, 8594: 26, 8595: 25, 8596: 29, 8597: 18, 8616: 23, 8735: 28, 8962: 127, 9472: 196, 9474: 179, 9484: 218, 9488: 191, + 9492: 192, 9496: 217, 9552: 205, 9553: 186, 9556: 201, 9559: 187, 9562: 200, 9565: 188, 9604: 220, 9644: 22, 9650: 30, 9658: 16, 9660: 31, 9668: 17, 9675: 9, 9688: 8, + 9689: 10, 9786: 1, 9787: 2, 9788: 15, 9792: 12, 9794: 11, 9824: 6, 9827: 5, 9829: 3, 9830: 4, 9834: 13, 9835: 14, 65281: 33, 65282: 34, 65283: 35, 65284: 36, + 65285: 37, 65286: 38, 65287: 39, 65288: 40, 65289: 41, 65290: 42, 65291: 43, 65292: 44, 65293: 45, 65294: 46, 65295: 47, 65296: 48, 65297: 49, 65298: 50, 65299: 51, 65300: 52, + 65301: 53, 65302: 54, 65303: 55, 65304: 56, 65305: 57, 65306: 58, 65307: 59, 65308: 60, 65309: 61, 65310: 62, 65312: 64, 65313: 65, 65314: 66, 65315: 67, 65316: 68, 65317: 69, + 65318: 70, 65319: 71, 65320: 72, 65321: 73, 65322: 74, 65323: 75, 65324: 76, 65325: 77, 65326: 78, 65327: 79, 65328: 80, 65329: 81, 65330: 82, 65331: 83, 65332: 84, 65333: 85, + 65334: 86, 65335: 87, 65336: 88, 65337: 89, 65338: 90, 65339: 91, 65340: 92, 65341: 93, 65342: 94, 65343: 95, 65344: 96, 65345: 97, 65346: 98, 65347: 99, 65348: 100, 65349: 101, + 65350: 102, 65351: 103, 65352: 104, 65353: 105, 65354: 106, 65355: 107, 65356: 108, 65357: 109, 65358: 110, 65359: 111, 65360: 112, 65361: 113, 65362: 114, 65363: 115, 65364: 116, 65365: 117, + 65366: 118, 65367: 119, 65368: 120, 65369: 121, 65370: 122, 65371: 123, 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0x2a: // 42 + return &StringConverter{ + LangID: 42, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 65535, 3585, 3586, 3587, 3588, 3589, 3590, 3591, 91, 162, 46, 60, 40, 43, 124, + 38, 65535, 3592, 3593, 3594, 3595, 3596, 3597, 3598, 93, 33, 36, 42, 41, 59, 94, + 45, 47, 3599, 3600, 3601, 3602, 3603, 3604, 3605, 65535, 166, 44, 37, 95, 62, 63, + 3647, 3662, 3606, 3607, 3608, 3609, 3610, 3611, 3612, 96, 58, 35, 64, 39, 61, 34, + 3663, 97, 98, 99, 100, 101, 102, 103, 104, 105, 3613, 3614, 3615, 3616, 3617, 3618, + 3674, 106, 107, 108, 109, 110, 111, 112, 113, 114, 3619, 3620, 3621, 3622, 3623, 3624, + 3675, 126, 115, 116, 117, 118, 119, 120, 121, 122, 3625, 3626, 3627, 3628, 3629, 3630, + 3664, 3665, 3666, 3667, 3668, 3669, 3670, 3671, 3672, 3673, 3631, 3632, 3633, 3634, 3635, 3636, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 65535, 3637, 3638, 3639, 3640, 3641, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 3642, 3648, 3649, 3650, 3651, 3652, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 3653, 3654, 3655, 3656, 3657, 3658, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 3659, 3660, 3661, 65535, 65535, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 65535: 254, + 3585: 66, 3586: 67, 3587: 68, 3588: 69, 3589: 70, 3590: 71, 3591: 72, 91: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 3592: 82, + 3593: 83, 3594: 84, 3595: 85, 3596: 86, 3597: 87, 3598: 88, 93: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, 3599: 98, + 3600: 99, 3601: 100, 3602: 101, 3603: 102, 3604: 103, 3605: 104, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 3647: 112, 3662: 113, 3606: 114, 3607: 115, + 3608: 116, 3609: 117, 3610: 118, 3611: 119, 3612: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 3663: 128, 97: 129, 98: 130, 99: 131, + 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 3613: 138, 3614: 139, 3615: 140, 3616: 141, 3617: 142, 3618: 143, 3674: 144, 106: 145, 107: 146, 108: 147, + 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 3619: 154, 3620: 155, 3621: 156, 3622: 157, 3623: 158, 3624: 159, 3675: 160, 126: 161, 115: 162, 116: 163, + 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 3625: 170, 3626: 171, 3627: 172, 3628: 173, 3629: 174, 3630: 175, 3664: 176, 3665: 177, 3666: 178, 3667: 179, + 3668: 180, 3669: 181, 3670: 182, 3671: 183, 3672: 184, 3673: 185, 3631: 186, 3632: 187, 3633: 188, 3634: 189, 3635: 190, 3636: 191, 123: 192, 65: 193, 66: 194, 67: 195, + 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 3637: 203, 3638: 204, 3639: 205, 3640: 206, 3641: 207, 125: 208, 74: 209, 75: 210, 76: 211, 77: 212, + 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 3642: 218, 3648: 219, 3649: 220, 3650: 221, 3651: 222, 3652: 223, 92: 224, 83: 226, 84: 227, 85: 228, 86: 229, + 87: 230, 88: 231, 89: 232, 90: 233, 3653: 234, 3654: 235, 3655: 236, 3656: 237, 3657: 238, 3658: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, + 54: 246, 55: 247, 56: 248, 57: 249, 3659: 250, 3660: 251, 3661: 252, 159: 255, + }, + } + case 0x2b: // 43 + return &StringConverter{ + LangID: 43, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 2547, 2534, 2535, 2536, 2537, 2538, 2539, 2540, 2541, 2542, 2543, + 2437, 2438, 2439, 2440, 2441, 2442, 2443, 2447, 2448, 2451, 2452, 2434, 2435, 2433, 2453, 2454, + 2455, 2456, 2457, 2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2524, 2466, 2525, 2467, 65535, + 2468, 2469, 2470, 2471, 2472, 2474, 2475, 2476, 2477, 2478, 2479, 2527, 2480, 2482, 2486, 2487, + 2488, 2489, 65535, 2494, 2495, 2496, 2497, 2498, 2499, 2503, 2504, 2507, 2508, 65535, 65535, 65535, + 63671, 63670, 63669, 63668, 63667, 63666, 63665, 63664, 63663, 63662, 63661, 63660, 63659, 65535, 63658, 65535, + 63657, 63656, 63655, 63654, 63653, 63652, 63651, 63650, 63649, 63648, 63647, 63646, 63645, 65535, 63644, 63643, + 63642, 63641, 63640, 63639, 63638, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 2547: 133, 2534: 134, 2535: 135, 2536: 136, 2537: 137, 2538: 138, 2539: 139, 2540: 140, 2541: 141, 2542: 142, 2543: 143, 2437: 144, 2438: 145, 2439: 146, 2440: 147, + 2441: 148, 2442: 149, 2443: 150, 2447: 151, 2448: 152, 2451: 153, 2452: 154, 2434: 155, 2435: 156, 2433: 157, 2453: 158, 2454: 159, 2455: 160, 2456: 161, 2457: 162, 2458: 163, + 2459: 164, 2460: 165, 2461: 166, 2462: 167, 2463: 168, 2464: 169, 2465: 170, 2524: 171, 2466: 172, 2525: 173, 2467: 174, 2468: 176, 2469: 177, 2470: 178, 2471: 179, 2472: 180, + 2474: 181, 2475: 182, 2476: 183, 2477: 184, 2478: 185, 2479: 186, 2527: 187, 2480: 188, 2482: 189, 2486: 190, 2487: 191, 2488: 192, 2489: 193, 2494: 195, 2495: 196, 2496: 197, + 2497: 198, 2498: 199, 2499: 200, 2503: 201, 2504: 202, 2507: 203, 2508: 204, 63671: 208, 63670: 209, 63669: 210, 63668: 211, 63667: 212, 63666: 213, 63665: 214, 63664: 215, 63663: 216, + 63662: 217, 63661: 218, 63660: 219, 63659: 220, 63658: 222, 63657: 224, 63656: 225, 63655: 226, 63654: 227, 63653: 228, 63652: 229, 63651: 230, 63650: 231, 63649: 232, 63648: 233, 63647: 234, + 63646: 235, 63645: 236, 63644: 238, 63643: 239, 63642: 240, 63641: 241, 63640: 242, 63639: 243, 63638: 244, + }, + } + case 0x2c: // 44 + return &StringConverter{ + LangID: 44, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 258, 194, 202, 212, 416, 431, 272, 259, 226, 234, 244, 417, 432, 273, 65535, + 65535, 65535, 65535, 65535, 65535, 224, 7843, 227, 225, 7841, 65535, 7857, 7859, 7861, 7855, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 7863, 7847, 7849, 7851, 7845, 7853, 232, 65535, 7867, 7869, + 233, 7865, 7873, 7875, 7877, 7871, 7879, 236, 7881, 65535, 65535, 65535, 297, 237, 7883, 242, + 65535, 7887, 245, 243, 7885, 7891, 7893, 7895, 7889, 7897, 7901, 7903, 7905, 7899, 7907, 249, + 65535, 7911, 361, 250, 7909, 7915, 7917, 7919, 7913, 7921, 7923, 7927, 7929, 253, 7925, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 258: 161, 194: 162, 202: 163, 212: 164, 416: 165, 431: 166, 272: 167, 259: 168, 226: 169, 234: 170, 244: 171, 417: 172, 432: 173, 273: 174, 224: 181, + 7843: 182, 227: 183, 225: 184, 7841: 185, 7857: 187, 7859: 188, 7861: 189, 7855: 190, 7863: 198, 7847: 199, 7849: 200, 7851: 201, 7845: 202, 7853: 203, 232: 204, 7867: 206, + 7869: 207, 233: 208, 7865: 209, 7873: 210, 7875: 211, 7877: 212, 7871: 213, 7879: 214, 236: 215, 7881: 216, 297: 220, 237: 221, 7883: 222, 242: 223, 7887: 225, 245: 226, + 243: 227, 7885: 228, 7891: 229, 7893: 230, 7895: 231, 7889: 232, 7897: 233, 7901: 234, 7903: 235, 7905: 236, 7899: 237, 7907: 238, 249: 239, 7911: 241, 361: 242, 250: 243, + 7909: 244, 7915: 245, 7917: 246, 7919: 247, 7913: 248, 7921: 249, 7923: 250, 7927: 251, 7929: 252, 253: 253, 7925: 254, + }, + } + case 0x2d: // 45 + return &StringConverter{ + LangID: 45, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 138, 8249, 338, 141, 142, 143, + 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 154, 8250, 339, 157, 158, 376, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 258, 196, 197, 198, 199, 200, 201, 202, 203, 768, 205, 206, 207, + 272, 209, 777, 211, 212, 416, 214, 215, 216, 217, 218, 219, 220, 431, 771, 223, + 224, 225, 226, 259, 228, 229, 230, 231, 232, 233, 234, 235, 769, 237, 238, 239, + 273, 241, 803, 243, 244, 417, 246, 247, 248, 249, 250, 251, 252, 432, 8363, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 8364: 128, 129: 129, 8218: 130, 402: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 710: 136, 8240: 137, 138: 138, 8249: 139, 338: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 732: 152, 8482: 153, 154: 154, 8250: 155, 339: 156, 157: 157, 158: 158, 376: 159, + 160: 160, 161: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, + 192: 192, 193: 193, 194: 194, 258: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 768: 204, 205: 205, 206: 206, 207: 207, + 272: 208, 209: 209, 777: 210, 211: 211, 212: 212, 416: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 431: 221, 771: 222, 223: 223, + 224: 224, 225: 225, 226: 226, 259: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 769: 236, 237: 237, 238: 238, 239: 239, + 273: 240, 241: 241, 803: 242, 243: 243, 244: 244, 417: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 432: 253, 8363: 254, 255: 255, + 65281: 33, 65282: 34, 65283: 35, 65284: 36, 65285: 37, 65286: 38, 65287: 39, 65288: 40, 65289: 41, 65290: 42, 65291: 43, 65292: 44, 65293: 45, 65294: 46, 65295: 47, 65296: 48, + 65297: 49, 65298: 50, 65299: 51, 65300: 52, 65301: 53, 65302: 54, 65303: 55, 65304: 56, 65305: 57, 65306: 58, 65307: 59, 65308: 60, 65309: 61, 65310: 62, 65312: 64, 65313: 65, + 65314: 66, 65315: 67, 65316: 68, 65317: 69, 65318: 70, 65319: 71, 65320: 72, 65321: 73, 65322: 74, 65323: 75, 65324: 76, 65325: 77, 65326: 78, 65327: 79, 65328: 80, 65329: 81, + 65330: 82, 65331: 83, 65332: 84, 65333: 85, 65334: 86, 65335: 87, 65336: 88, 65337: 89, 65338: 90, 65339: 91, 65340: 92, 65341: 93, 65342: 94, 65343: 95, 65344: 96, 65345: 97, + 65346: 98, 65347: 99, 65348: 100, 65349: 101, 65350: 102, 65351: 103, 65352: 104, 65353: 105, 65354: 106, 65355: 107, 65356: 108, 65357: 109, 65358: 110, 65359: 111, 65360: 112, 65361: 113, + 65362: 114, 65363: 115, 65364: 116, 65365: 117, 65366: 118, 65367: 119, 65368: 120, 65369: 121, 65370: 122, 65371: 123, 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0x2e: // 46 + return &StringConverter{ + LangID: 46, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 8364, 165, 352, 167, 353, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 381, 181, 182, 183, 382, 185, 186, 187, 338, 339, 376, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 161: 161, 162: 162, 163: 163, 8364: 164, 165: 165, 352: 166, 167: 167, 353: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 381: 180, 181: 181, 182: 182, 183: 183, 382: 184, 185: 185, 186: 186, 187: 187, 338: 188, 339: 189, 376: 190, 191: 191, + 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, + 208: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 221: 221, 222: 222, 223: 223, + 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, + 240: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 253: 253, 254: 254, 255: 255, + 8216: 96, 8213: 45, 63742: 183, 8248: 94, 8764: 126, 63741: 102, 8356: 76, 946: 223, + }, + } + case 0x2f: // 47 + return &StringConverter{ + LangID: 47, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 8221, 162, 163, 164, 8222, 166, 167, 216, 169, 342, 171, 172, 173, 174, 198, + 176, 177, 178, 179, 8220, 181, 182, 183, 248, 185, 343, 187, 188, 189, 190, 230, + 260, 302, 256, 262, 196, 197, 280, 274, 268, 201, 377, 278, 290, 310, 298, 315, + 352, 323, 325, 211, 332, 213, 214, 215, 370, 321, 346, 362, 220, 379, 381, 223, + 261, 303, 257, 263, 228, 229, 281, 275, 269, 233, 378, 279, 291, 311, 299, 316, + 353, 324, 326, 243, 333, 245, 246, 247, 371, 322, 347, 363, 252, 380, 382, 8217, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 8221: 161, 162: 162, 163: 163, 164: 164, 8222: 165, 166: 166, 167: 167, 216: 168, 169: 169, 342: 170, 171: 171, 172: 172, 173: 173, 174: 174, 198: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 8220: 180, 181: 181, 182: 182, 183: 183, 248: 184, 185: 185, 343: 186, 187: 187, 188: 188, 189: 189, 190: 190, 230: 191, + 260: 192, 302: 193, 256: 194, 262: 195, 196: 196, 197: 197, 280: 198, 274: 199, 268: 200, 201: 201, 377: 202, 278: 203, 290: 204, 310: 205, 298: 206, 315: 207, + 352: 208, 323: 209, 325: 210, 211: 211, 332: 212, 213: 213, 214: 214, 215: 215, 370: 216, 321: 217, 346: 218, 362: 219, 220: 220, 379: 221, 381: 222, 223: 223, + 261: 224, 303: 225, 257: 226, 263: 227, 228: 228, 229: 229, 281: 230, 275: 231, 269: 232, 233: 233, 378: 234, 279: 235, 291: 236, 311: 237, 299: 238, 316: 239, + 353: 240, 324: 241, 326: 242, 243: 243, 333: 244, 245: 245, 246: 246, 247: 247, 371: 248, 322: 249, 347: 250, 363: 251, 252: 252, 380: 253, 382: 254, 8217: 255, + }, + } + case 0x30: // 48 + return &StringConverter{ + LangID: 48, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 7682, 7683, 163, 266, 267, 7690, 167, 7808, 169, 7810, 7691, 7922, 173, 174, 376, + 7710, 7711, 288, 289, 7744, 7745, 182, 7766, 7809, 7767, 7811, 7776, 7923, 7812, 7813, 7777, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 372, 209, 210, 211, 212, 213, 214, 7786, 216, 217, 218, 219, 220, 221, 374, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 373, 241, 242, 243, 244, 245, 246, 7787, 248, 249, 250, 251, 252, 253, 375, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 7682: 161, 7683: 162, 163: 163, 266: 164, 267: 165, 7690: 166, 167: 167, 7808: 168, 169: 169, 7810: 170, 7691: 171, 7922: 172, 173: 173, 174: 174, 376: 175, + 7710: 176, 7711: 177, 288: 178, 289: 179, 7744: 180, 7745: 181, 182: 182, 7766: 183, 7809: 184, 7767: 185, 7811: 186, 7776: 187, 7923: 188, 7812: 189, 7813: 190, 7777: 191, + 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, + 372: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 7786: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 221: 221, 374: 222, 223: 223, + 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, + 373: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 7787: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 253: 253, 375: 254, 255: 255, + }, + } + case 0x31: // 49 + return &StringConverter{ + LangID: 49, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 1106, 1107, 1105, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 173, 1118, 1119, + 8470, 1026, 1027, 1025, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 164, 1038, 1039, + 1102, 1072, 1073, 1094, 1076, 1077, 1092, 1075, 1093, 1080, 1081, 1082, 1083, 1084, 1085, 1086, + 1087, 1103, 1088, 1089, 1090, 1091, 1078, 1074, 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, + 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, 1061, 1048, 1049, 1050, 1051, 1052, 1053, 1054, + 1055, 1071, 1056, 1057, 1058, 1059, 1046, 1042, 1068, 1067, 1047, 1064, 1069, 1065, 1063, 1066, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 1106: 161, 1107: 162, 1105: 163, 1108: 164, 1109: 165, 1110: 166, 1111: 167, 1112: 168, 1113: 169, 1114: 170, 1115: 171, 1116: 172, 173: 173, 1118: 174, 1119: 175, + 8470: 176, 1026: 177, 1027: 178, 1025: 179, 1028: 180, 1029: 181, 1030: 182, 1031: 183, 1032: 184, 1033: 185, 1034: 186, 1035: 187, 1036: 188, 164: 189, 1038: 190, 1039: 191, + 1102: 192, 1072: 193, 1073: 194, 1094: 195, 1076: 196, 1077: 197, 1092: 198, 1075: 199, 1093: 200, 1080: 201, 1081: 202, 1082: 203, 1083: 204, 1084: 205, 1085: 206, 1086: 207, + 1087: 208, 1103: 209, 1088: 210, 1089: 211, 1090: 212, 1091: 213, 1078: 214, 1074: 215, 1100: 216, 1099: 217, 1079: 218, 1096: 219, 1101: 220, 1097: 221, 1095: 222, 1098: 223, + 1070: 224, 1040: 225, 1041: 226, 1062: 227, 1044: 228, 1045: 229, 1060: 230, 1043: 231, 1061: 232, 1048: 233, 1049: 234, 1050: 235, 1051: 236, 1052: 237, 1053: 238, 1054: 239, + 1055: 240, 1071: 241, 1056: 242, 1057: 243, 1058: 244, 1059: 245, 1046: 246, 1042: 247, 1068: 248, 1067: 249, 1047: 250, 1064: 251, 1069: 252, 1065: 253, 1063: 254, 1066: 255, + }, + } + case 0x32: // 50 + return &StringConverter{ + LangID: 50, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8199, 192, 193, 194, 195, 196, 197, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 217, 218, 219, 220, 221, 222, 181, 215, 247, + 169, 161, 162, 163, 8260, 165, 402, 167, 164, 8217, 8220, 171, 8249, 8250, 64257, 64258, + 174, 8211, 8224, 8225, 183, 166, 182, 8226, 8218, 8222, 8221, 187, 8230, 8240, 172, 191, + 185, 96, 180, 710, 126, 713, 728, 729, 168, 178, 730, 184, 179, 733, 731, 711, + 8213, 177, 188, 189, 190, 224, 225, 226, 227, 228, 229, 231, 232, 233, 234, 235, + 236, 198, 237, 170, 238, 239, 240, 241, 321, 216, 338, 186, 242, 243, 244, 245, + 246, 230, 249, 250, 251, 305, 252, 253, 322, 248, 339, 223, 254, 255, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 193, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 196, 127: 127, + 8199: 128, 192: 129, 193: 130, 194: 131, 195: 132, 196: 133, 197: 134, 199: 135, 200: 136, 201: 137, 202: 138, 203: 139, 204: 140, 205: 141, 206: 142, 207: 143, + 208: 144, 209: 145, 210: 146, 211: 147, 212: 148, 213: 149, 214: 150, 217: 151, 218: 152, 219: 153, 220: 154, 221: 155, 222: 156, 181: 157, 215: 158, 247: 159, + 169: 160, 161: 161, 162: 162, 163: 163, 8260: 164, 165: 165, 402: 166, 167: 167, 164: 168, 8217: 169, 8220: 170, 171: 171, 8249: 172, 8250: 173, 64257: 174, 64258: 175, + 174: 176, 8211: 177, 8224: 178, 8225: 179, 183: 180, 166: 181, 182: 182, 8226: 183, 8218: 184, 8222: 185, 8221: 186, 187: 187, 8230: 188, 8240: 189, 172: 190, 191: 191, + 185: 192, 180: 194, 710: 195, 713: 197, 728: 198, 729: 199, 168: 200, 178: 201, 730: 202, 184: 203, 179: 204, 733: 205, 731: 206, 711: 207, 8213: 208, 177: 209, + 188: 210, 189: 211, 190: 212, 224: 213, 225: 214, 226: 215, 227: 216, 228: 217, 229: 218, 231: 219, 232: 220, 233: 221, 234: 222, 235: 223, 236: 224, 198: 225, + 237: 226, 170: 227, 238: 228, 239: 229, 240: 230, 241: 231, 321: 232, 216: 233, 338: 234, 186: 235, 242: 236, 243: 237, 244: 238, 245: 239, 246: 240, 230: 241, + 249: 242, 250: 243, 251: 244, 305: 245, 252: 246, 253: 247, 322: 248, 248: 249, 339: 250, 223: 251, 254: 252, 255: 253, 65535: 255, 176: 202, 175: 197, 160: 128, + 173: 45, 63741: 166, + }, + } + case 0x33: // 51 + return &StringConverter{ + LangID: 51, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 9472, 9474, 9484, 9488, 9492, 9496, 9500, 9508, 9516, 9524, 9532, 9600, 9604, 9608, 9612, 9616, + 9617, 9618, 9619, 8992, 9632, 8729, 8730, 8776, 8804, 8805, 160, 8993, 176, 178, 183, 247, + 9552, 9553, 9554, 1105, 1108, 9556, 1110, 1111, 9559, 9560, 9561, 9562, 9563, 1169, 9565, 9566, + 9567, 9568, 9569, 1025, 1028, 9571, 1030, 1031, 9574, 9575, 9576, 9577, 9578, 1168, 9580, 169, + 1102, 1072, 1073, 1094, 1076, 1077, 1092, 1075, 1093, 1080, 1081, 1082, 1083, 1084, 1085, 1086, + 1087, 1103, 1088, 1089, 1090, 1091, 1078, 1074, 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, + 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, 1061, 1048, 1049, 1050, 1051, 1052, 1053, 1054, + 1055, 1071, 1056, 1057, 1058, 1059, 1046, 1042, 1068, 1067, 1047, 1064, 1069, 1065, 1063, 1066, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 9472: 128, 9474: 129, 9484: 130, 9488: 131, 9492: 132, 9496: 133, 9500: 134, 9508: 135, 9516: 136, 9524: 137, 9532: 138, 9600: 139, 9604: 140, 9608: 141, 9612: 142, 9616: 143, + 9617: 144, 9618: 145, 9619: 146, 8992: 147, 9632: 148, 8729: 149, 8730: 150, 8776: 151, 8804: 152, 8805: 153, 160: 154, 8993: 155, 176: 156, 178: 157, 183: 158, 247: 159, + 9552: 160, 9553: 161, 9554: 162, 1105: 163, 1108: 164, 9556: 165, 1110: 166, 1111: 167, 9559: 168, 9560: 169, 9561: 170, 9562: 171, 9563: 172, 1169: 173, 9565: 174, 9566: 175, + 9567: 176, 9568: 177, 9569: 178, 1025: 179, 1028: 180, 9571: 181, 1030: 182, 1031: 183, 9574: 184, 9575: 185, 9576: 186, 9577: 187, 9578: 188, 1168: 189, 9580: 190, 169: 191, + 1102: 192, 1072: 193, 1073: 194, 1094: 195, 1076: 196, 1077: 197, 1092: 198, 1075: 199, 1093: 200, 1080: 201, 1081: 202, 1082: 203, 1083: 204, 1084: 205, 1085: 206, 1086: 207, + 1087: 208, 1103: 209, 1088: 210, 1089: 211, 1090: 212, 1091: 213, 1078: 214, 1074: 215, 1100: 216, 1099: 217, 1079: 218, 1096: 219, 1101: 220, 1097: 221, 1095: 222, 1098: 223, + 1070: 224, 1040: 225, 1041: 226, 1062: 227, 1044: 228, 1045: 229, 1060: 230, 1043: 231, 1061: 232, 1048: 233, 1049: 234, 1050: 235, 1051: 236, 1052: 237, 1053: 238, 1054: 239, + 1055: 240, 1071: 241, 1056: 242, 1057: 243, 1058: 244, 1059: 245, 1046: 246, 1042: 247, 1068: 248, 1067: 249, 1047: 250, 1064: 251, 1069: 252, 1065: 253, 1063: 254, 1066: 255, + }, + } + case 0x34: // 52 + return &StringConverter{ + LangID: 52, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 399, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 286, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 304, 350, 223, + 224, 225, 226, 227, 228, 229, 601, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 287, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 305, 351, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 159, 160: 160, 161: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, + 175: 175, 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 190: 190, + 191: 191, 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 399: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, + 207: 207, 286: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 304: 221, 350: 222, + 223: 223, 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 601: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, + 239: 239, 287: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 305: 253, 351: 254, + 255: 255, 8216: 96, 376: 89, 946: 223, 8213: 45, 8248: 94, 8356: 76, 8764: 126, 63736: 105, 63738: 73, 63741: 102, 63742: 183, + }, + } + case 0x3d: // 61 + return &StringConverter{ + LangID: 61, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 233, 226, 65535, 224, 65535, 231, 234, 235, 232, 239, 238, 65535, 65535, 65535, + 65535, 65535, 65535, 244, 65535, 65535, 251, 249, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 160, 65535, 65535, 65535, 164, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 1548, 173, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 1563, 65535, 65535, 65535, 1567, + 65535, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 65535, 65535, 65535, 65535, 65535, + 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 63731, 64606, 64607, 64608, 64609, 64610, 65535, 65535, 65535, 956, 163, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 233: 130, 226: 131, 224: 133, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 244: 147, 251: 150, 249: 151, 160: 160, 164: 164, 1548: 172, + 173: 173, 171: 174, 187: 175, 1563: 187, 1567: 191, 1569: 193, 1570: 194, 1571: 195, 1572: 196, 1573: 197, 1574: 198, 1575: 199, 1576: 200, 1577: 201, 1578: 202, 1579: 203, + 1580: 204, 1581: 205, 1582: 206, 1583: 207, 1584: 208, 1585: 209, 1586: 210, 1587: 211, 1588: 212, 1589: 213, 1590: 214, 1591: 215, 1592: 216, 1593: 217, 1594: 218, 1600: 224, + 1601: 225, 1602: 226, 1603: 227, 1604: 228, 1605: 229, 1606: 230, 1607: 231, 1608: 232, 1609: 233, 1610: 234, 1611: 235, 1612: 236, 1613: 237, 1614: 238, 1615: 239, 1616: 240, + 1617: 241, 1618: 242, 63731: 243, 64606: 244, 64607: 245, 64608: 246, 64609: 247, 64610: 248, 956: 252, 163: 253, 8718: 254, + }, + } + case 0x46: // 70 + return &StringConverter{ + LangID: 70, + CharWidth: 1, + eReplace: 65533, + dReplace: 123, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 1617, 65535, 1600, 65535, 1569, 1570, 65535, 1571, 162, 46, 60, 40, 43, 124, + 38, 65535, 1572, 65535, 65535, 1574, 1575, 65535, 65535, 1576, 33, 36, 42, 41, 59, 172, + 45, 47, 1577, 65535, 1578, 65535, 1579, 65535, 1580, 65535, 166, 44, 37, 95, 62, 63, + 1581, 65535, 1582, 1583, 1584, 1585, 1586, 65535, 1587, 1548, 58, 35, 64, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1588, 65535, 1589, 65535, 1590, 1591, + 1592, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 1593, 65535, 65535, 65535, + 1594, 247, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 1601, 65535, 1602, 65535, + 1603, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 1604, 65535, 1605, 65535, 1606, 65535, + 1563, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 1607, 65535, 65535, 65535, 1608, + 1567, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1609, 65535, 65535, 65535, 1610, 65535, + 215, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 65535, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65535, 65535, 65535, 65535, 65535, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 1617: 66, 65535: 254, 1600: 68, 1569: 70, 1570: 71, 1571: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 1572: 82, 1574: 85, 1575: 86, + 1576: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, 1577: 98, 1578: 100, 1579: 102, 1580: 104, 166: 106, 44: 107, 37: 108, + 95: 109, 62: 110, 63: 111, 1581: 112, 1582: 114, 1583: 115, 1584: 116, 1585: 117, 1586: 118, 1587: 120, 1548: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, + 34: 127, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1588: 138, 1589: 140, 1590: 142, 1591: 143, 1592: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1593: 156, 1594: 160, 247: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, + 120: 167, 121: 168, 122: 169, 1601: 172, 1602: 174, 1603: 176, 1604: 186, 1605: 188, 1606: 190, 1563: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, + 71: 199, 72: 200, 73: 201, 173: 202, 1607: 203, 1608: 207, 1567: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, + 1609: 218, 1610: 222, 215: 224, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, + 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 159: 255, + }, + } + case 0x48: // 72 + return &StringConverter{ + LangID: 72, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 65535, 29, 30, 31, + 65535, 65535, 28, 65535, 65535, 65535, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 1617, 1617, 1600, 160, 1569, 1570, 1570, 1571, 91, 46, 60, 40, 43, 33, + 38, 1571, 1572, 65535, 65535, 1574, 1575, 1575, 1576, 1576, 93, 36, 42, 41, 59, 94, + 45, 47, 1577, 1578, 1578, 1579, 1579, 1580, 1580, 1581, 166, 44, 37, 95, 62, 63, + 1581, 1582, 1582, 1583, 1584, 1585, 1586, 1587, 1587, 1548, 58, 35, 64, 39, 61, 34, + 1588, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1588, 1589, 1589, 1590, 1590, 1591, + 1592, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1593, 1593, 1593, 1593, 1594, 1594, + 1594, 126, 115, 116, 117, 118, 119, 120, 121, 122, 1594, 1601, 1601, 1602, 1602, 1603, + 1603, 1604, 65269, 65269, 65271, 65271, 65535, 65535, 65275, 65275, 1604, 1605, 1605, 1606, 1606, 1607, + 1563, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 1607, 65535, 1607, 65535, 1608, + 1567, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1609, 1610, 1610, 1610, 1610, 48, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 49, 50, 65535, 51, 52, 53, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 54, 55, 56, 57, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 255, 9: 5, 127: 7, 10: 21, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, + 19: 19, 8: 22, 24: 24, 25: 25, 29: 29, 30: 30, 31: 31, 28: 34, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 69, 1617: 67, 1600: 68, 1569: 70, 1570: 72, 1571: 81, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, + 1572: 82, 1574: 85, 1575: 87, 1576: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, 1577: 98, 1578: 100, 1579: 102, 1580: 104, + 1581: 112, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 1582: 114, 1583: 115, 1584: 116, 1585: 117, 1586: 118, 1587: 120, 1548: 121, 58: 122, 35: 123, + 64: 124, 39: 125, 61: 126, 34: 127, 1588: 138, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1589: 140, 1590: 142, + 1591: 143, 1592: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1593: 157, 1594: 170, 126: 161, 115: 162, 116: 163, + 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 1601: 172, 1602: 174, 1603: 176, 1604: 186, 65269: 179, 65271: 181, 65275: 185, 1605: 188, 1606: 190, 1607: 205, + 1563: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 1608: 207, 1567: 208, 74: 209, 75: 210, 76: 211, + 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 1609: 208, 1610: 222, 48: 240, 92: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, + 88: 231, 89: 232, 90: 233, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 251, 55: 252, 56: 253, 57: 254, 179: 250, 96: 121, 123: 192, 124: 187, + 125: 208, 161: 170, 171: 138, 187: 139, 167: 181, 182: 182, 169: 180, 174: 175, 170: 154, 186: 155, 8216: 121, 181: 160, 183: 179, 176: 144, 175: 188, 185: 218, + 178: 234, 189: 184, 188: 183, 190: 185, 180: 190, 8248: 95, 8764: 161, 168: 189, 184: 157, 164: 159, 162: 176, 163: 177, 165: 178, 177: 143, 172: 186, 215: 191, + 192: 100, 193: 101, 194: 98, 195: 102, 196: 99, 197: 103, 198: 158, 199: 104, 208: 172, 200: 116, 201: 113, 202: 114, 203: 115, 204: 120, 205: 117, 206: 118, + 207: 119, 209: 105, 210: 237, 211: 238, 212: 235, 213: 239, 214: 236, 216: 128, 222: 174, 217: 253, 218: 254, 219: 251, 220: 252, 221: 173, 376: 232, 224: 68, + 225: 69, 226: 66, 227: 70, 228: 67, 229: 71, 230: 156, 231: 72, 240: 140, 232: 84, 233: 81, 234: 82, 235: 83, 236: 88, 237: 85, 238: 86, 239: 87, + 241: 73, 242: 205, 243: 206, 244: 203, 245: 207, 246: 204, 248: 112, 254: 142, 249: 221, 250: 222, 251: 219, 252: 220, 253: 141, 255: 223, 223: 89, 1612: 138, + }, + } + case 0x51: // 81 + return &StringConverter{ + LangID: 81, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 161, 162, 163, 65535, 165, 65535, 167, 164, 169, 170, 171, 65535, 65535, 65535, 65535, + 176, 177, 178, 179, 65535, 181, 182, 183, 65535, 185, 186, 187, 188, 189, 65535, 191, + 970, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, + 65535, 928, 929, 931, 932, 933, 934, 935, 936, 937, 940, 941, 942, 943, 65535, 972, + 971, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, + 65535, 960, 961, 963, 964, 965, 966, 967, 968, 969, 962, 973, 974, 900, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 161: 161, 162: 162, 163: 163, 165: 165, 167: 167, 164: 168, 169: 169, 170: 170, 171: 171, 176: 176, 177: 177, 178: 178, 179: 179, 181: 181, 182: 182, + 183: 183, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 191: 191, 970: 192, 913: 193, 914: 194, 915: 195, 916: 196, 917: 197, 918: 198, 919: 199, 920: 200, + 921: 201, 922: 202, 923: 203, 924: 204, 925: 205, 926: 206, 927: 207, 928: 209, 929: 210, 931: 211, 932: 212, 933: 213, 934: 214, 935: 215, 936: 216, 937: 217, + 940: 218, 941: 219, 942: 220, 943: 221, 972: 223, 971: 224, 945: 225, 946: 226, 947: 227, 948: 228, 949: 229, 950: 230, 951: 231, 952: 232, 953: 233, 954: 234, + 955: 235, 956: 236, 957: 237, 958: 238, 959: 239, 960: 241, 961: 242, 963: 243, 964: 244, 965: 245, 966: 246, 967: 247, 968: 248, 969: 249, 962: 250, 973: 251, + 974: 252, 900: 253, 8213: 45, 160: 32, 173: 45, 166: 124, 902: 193, 904: 197, 905: 199, 906: 201, 908: 207, 910: 213, 911: 217, 938: 201, 939: 213, 912: 192, + 944: 224, + }, + } + case 0x52: // 82 + return &StringConverter{ + LangID: 82, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 161, 162, 163, 65535, 165, 65535, 167, 164, 169, 170, 171, 65535, 65535, 304, 65535, + 176, 177, 178, 179, 65535, 181, 182, 183, 65535, 185, 186, 187, 188, 189, 305, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 286, 209, 210, 211, 212, 213, 214, 338, 216, 217, 218, 219, 220, 376, 350, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 287, 241, 242, 243, 244, 245, 246, 339, 248, 249, 250, 251, 252, 255, 351, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 161: 161, 162: 162, 163: 163, 165: 165, 167: 167, 164: 168, 169: 169, 170: 170, 171: 171, 304: 174, 176: 176, 177: 177, 178: 178, 179: 179, 181: 181, + 182: 182, 183: 183, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 305: 190, 191: 191, 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, + 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, 286: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, + 338: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 376: 221, 350: 222, 223: 223, 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, + 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, 287: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, + 339: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 255: 253, 351: 254, 8216: 96, 8213: 45, 175: 45, 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, + 8764: 126, 63741: 102, 8356: 76, 63738: 73, 221: 89, 63736: 105, 253: 121, 946: 223, + }, + } + case 0x5a: // 90 + return &StringConverter{ + LangID: 90, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 162, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 91, 222, 174, + 94, 163, 165, 183, 169, 167, 182, 188, 189, 190, 221, 168, 175, 93, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 91: 173, 222: 174, 174: 175, 94: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 221: 186, 168: 187, 175: 188, 93: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 176, + 8764: 161, 376: 232, 63743: 37, + }, + } + case 0x5b: // 91 + return &StringConverter{ + LangID: 91, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 91, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 93, 36, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 124, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 94, 166, 175, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 124: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 94: 186, 166: 187, 175: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 186, + 8764: 161, 376: 232, 63743: 37, + }, + } + case 0x5c: // 92 + return &StringConverter{ + LangID: 92, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 162, 46, 60, 40, 43, 124, + 38, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 33, 36, 42, 41, 59, 172, + 45, 47, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 166, 44, 37, 95, 62, 63, + 65535, 1514, 65535, 65535, 160, 65535, 65535, 65535, 819, 96, 58, 35, 64, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 65535, 65535, 65535, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 65535, 184, 65535, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 65535, 65535, 65535, 174, + 94, 163, 165, 183, 169, 167, 182, 188, 189, 190, 91, 93, 175, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 65535, 65535, 65535, 65535, 65535, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 65535, 65535, 65535, 65535, 65535, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 65535, 65535, 65535, 65535, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 1488: 65, + 1489: 66, 1490: 67, 1491: 68, 1492: 69, 1493: 70, 1494: 71, 1495: 72, 1496: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 1497: 81, + 1498: 82, 1499: 83, 1500: 84, 1501: 85, 1502: 86, 1503: 87, 1504: 88, 1505: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 1506: 98, 1507: 99, 1508: 100, 1509: 101, 1510: 102, 1511: 103, 1512: 104, 1513: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 65535: 254, 1514: 113, + 160: 116, 819: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, + 104: 136, 105: 137, 171: 138, 187: 139, 177: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 184: 157, + 164: 159, 181: 160, 126: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 174: 175, 94: 176, 163: 177, 165: 178, 183: 179, + 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 91: 186, 93: 187, 175: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, 66: 194, 67: 195, + 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 125: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, + 82: 217, 185: 218, 92: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 48: 240, 49: 241, 50: 242, + 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 159: 255, + }, + } + case 0x5d: // 93 + return &StringConverter{ + LangID: 93, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 123, 241, 199, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 286, 304, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 91, 209, 351, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 305, 58, 214, 350, 39, 61, 220, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 125, 96, 166, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 246, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 93, 36, 64, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 231, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 126, 242, 243, 245, + 287, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 92, 249, 250, 255, + 252, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 35, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 34, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 123: 72, 241: 73, 199: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 286: 90, 304: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 91: 104, 209: 105, 351: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 305: 121, 58: 122, 214: 123, 350: 124, 39: 125, 61: 126, 220: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 125: 140, 96: 141, 166: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 246: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 93: 172, 36: 173, 64: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 231: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 126: 204, 242: 205, 243: 206, 245: 207, 287: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 92: 220, 249: 221, 250: 222, 255: 223, 252: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 35: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 34: 252, 217: 253, 218: 254, 159: 255, 63738: 201, 63736: 137, + }, + } + case 0x5e: // 94 + return &StringConverter{ + LangID: 94, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 222, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 198, 36, 42, 41, 59, 214, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 240, 58, 35, 208, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 96, 253, 123, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 125, 184, 93, 164, + 181, 246, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 64, 221, 91, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 124, 175, 168, 92, 215, + 254, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 126, 242, 243, 245, + 230, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 180, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 94, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 222: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 198: 90, 36: 91, 42: 92, 41: 93, 59: 94, 214: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 240: 121, 58: 122, 35: 123, 208: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 96: 140, 253: 141, 123: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 125: 156, 184: 157, 93: 158, 164: 159, 181: 160, 246: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 64: 172, 221: 173, 91: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 92: 190, 215: 191, 254: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 126: 204, 242: 205, 243: 206, 245: 207, 230: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 180: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 94: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0x5f: // 95 + return &StringConverter{ + LangID: 95, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 166, 91, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 93, 36, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 35, 241, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 209, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 168, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 94, 33, 175, 126, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 166: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 35: 105, 241: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 209: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 168: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 94: 186, 33: 187, 175: 188, 126: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0x60: // 96 + return &StringConverter{ + LangID: 96, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 162, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 91, 222, 174, + 172, 163, 165, 183, 169, 167, 182, 188, 189, 190, 221, 168, 175, 93, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 91: 173, 222: 174, 174: 175, 172: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 221: 186, 168: 187, 175: 188, 93: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 176, + 8764: 161, 376: 232, 63743: 37, + }, + } + case 0x61: // 97 + return &StringConverter{ + LangID: 97, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 162, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 91, 222, 174, + 94, 163, 165, 183, 169, 167, 182, 188, 189, 190, 221, 168, 175, 93, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 91: 173, 222: 174, 174: 175, 94: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 221: 186, 168: 187, 175: 188, 93: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 176, + 8764: 161, 376: 232, 63743: 37, + }, + } + case 0x62: // 98 + return &StringConverter{ + LangID: 98, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 166, 91, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 93, 36, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 35, 241, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 209, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 181, 168, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 94, 33, 175, 126, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 166: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 35: 105, 241: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 209: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 181: 160, 168: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 94: 186, 33: 187, 175: 188, 126: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0x63: // 99 + return &StringConverter{ + LangID: 99, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 91, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 93, 36, 42, 41, 59, 172, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 124, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 94, 166, 175, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 124: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 94: 186, 166: 187, 175: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 186, + 8764: 161, 376: 232, 63743: 25, + }, + } + case 0x64: // 100 + return &StringConverter{ + LangID: 100, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 162, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 166, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 91, 222, 174, + 172, 163, 165, 183, 169, 167, 182, 188, 189, 190, 221, 168, 175, 93, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 91: 173, 222: 174, 174: 175, 172: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 221: 186, 168: 187, 175: 188, 93: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 176, + 8764: 161, 376: 232, 63743: 37, + }, + } + case 0x65: // 101 + return &StringConverter{ + LangID: 101, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 221, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 352, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 382, 198, 8364, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 91, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 338, 339, 376, 172, 353, 175, 93, 381, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 221: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 352: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 382: 157, 198: 158, 8364: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 91: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 338: 183, 339: 184, 376: 232, 172: 186, 353: 187, 175: 188, 93: 189, 381: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 186, + 8764: 161, 63743: 37, + }, + } + case 0x6e: // 110 + return &StringConverter{ + LangID: 110, + CharWidth: 1, + eReplace: 65533, + dReplace: 32, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 176, + 192, 193, 194, 195, 196, 198, 216, 197, 913, 902, 914, 915, 199, 916, 917, 904, + 200, 201, 202, 203, 918, 919, 905, 920, 921, 906, 204, 205, 206, 207, 922, 923, + 224, 225, 226, 227, 228, 230, 248, 229, 945, 940, 946, 947, 231, 948, 949, 941, + 232, 233, 234, 235, 950, 951, 942, 952, 953, 943, 236, 237, 238, 239, 954, 955, + 924, 925, 209, 926, 927, 908, 210, 211, 212, 213, 214, 928, 929, 931, 932, 933, + 910, 939, 217, 218, 219, 220, 934, 935, 936, 937, 911, 912, 970, 944, 171, 187, + 956, 957, 241, 958, 959, 972, 242, 243, 244, 245, 246, 960, 961, 963, 964, 965, + 973, 971, 249, 250, 251, 252, 966, 967, 968, 969, 974, 962, 223, 161, 191, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 176: 127, + 192: 128, 193: 129, 194: 130, 195: 131, 196: 132, 198: 133, 216: 134, 197: 135, 913: 136, 902: 137, 914: 138, 915: 139, 199: 140, 916: 141, 917: 142, 904: 143, + 200: 144, 201: 145, 202: 146, 203: 147, 918: 148, 919: 149, 905: 150, 920: 151, 921: 152, 906: 153, 204: 154, 205: 155, 206: 156, 207: 157, 922: 158, 923: 159, + 224: 160, 225: 161, 226: 162, 227: 163, 228: 164, 230: 165, 248: 166, 229: 167, 945: 168, 940: 169, 946: 170, 947: 171, 231: 172, 948: 173, 949: 174, 941: 175, + 232: 176, 233: 177, 234: 178, 235: 179, 950: 180, 951: 181, 942: 182, 952: 183, 953: 184, 943: 185, 236: 186, 237: 187, 238: 188, 239: 189, 954: 190, 955: 191, + 924: 192, 925: 193, 209: 194, 926: 195, 927: 196, 908: 197, 210: 198, 211: 199, 212: 200, 213: 201, 214: 202, 928: 203, 929: 204, 931: 205, 932: 206, 933: 207, + 910: 208, 939: 209, 217: 210, 218: 211, 219: 212, 220: 213, 934: 214, 935: 215, 936: 216, 937: 217, 911: 218, 912: 219, 970: 220, 944: 221, 171: 222, 187: 223, + 956: 224, 957: 225, 241: 226, 958: 227, 959: 228, 972: 229, 242: 230, 243: 231, 244: 232, 245: 233, 246: 234, 960: 235, 961: 236, 963: 237, 964: 238, 965: 239, + 973: 240, 971: 241, 249: 242, 250: 243, 251: 244, 252: 245, 966: 246, 967: 247, 968: 248, 969: 249, 974: 250, 962: 251, 223: 252, 161: 253, 191: 254, 65535: 255, + }, + } + case 0x71: // 113 + return &StringConverter{ + LangID: 113, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 902, 904, 905, 906, 908, 910, 176, 8, 9, 10, 11, 12, 13, 14, 164, + 16, 17, 18, 19, 182, 167, 163, 911, 8593, 8595, 8594, 8592, 203, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 239, 238, 236, 196, 197, + 201, 230, 198, 244, 246, 242, 251, 249, 913, 214, 220, 248, 945, 216, 940, 914, + 225, 237, 243, 250, 241, 209, 946, 915, 947, 916, 948, 917, 949, 941, 918, 950, + 919, 951, 942, 65535, 170, 193, 194, 192, 920, 952, 65535, 65535, 65535, 921, 938, 65535, + 65535, 186, 161, 191, 65535, 900, 227, 195, 65535, 65535, 953, 943, 970, 65535, 912, 922, + 954, 923, 202, 955, 924, 956, 205, 925, 957, 65535, 65535, 926, 958, 927, 959, 972, + 211, 223, 212, 928, 245, 213, 960, 929, 961, 218, 931, 962, 963, 932, 964, 933, + 939, 965, 973, 971, 944, 934, 966, 935, 967, 936, 183, 968, 937, 969, 974, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 902: 1, 904: 2, 905: 3, 906: 4, 908: 5, 910: 6, 176: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 164: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 182: 20, 167: 21, 163: 22, 911: 23, 8593: 24, 8595: 25, 8594: 26, 8592: 27, 203: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 236: 141, 196: 142, 197: 143, + 201: 144, 230: 145, 198: 146, 244: 147, 246: 148, 242: 149, 251: 150, 249: 151, 913: 152, 214: 153, 220: 154, 248: 155, 945: 156, 216: 157, 940: 158, 914: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 946: 166, 915: 167, 947: 168, 916: 169, 948: 170, 917: 171, 949: 172, 941: 173, 918: 174, 950: 175, + 919: 176, 951: 177, 942: 178, 65535: 255, 170: 180, 193: 181, 194: 182, 192: 183, 920: 184, 952: 185, 921: 189, 938: 190, 186: 193, 161: 194, 191: 195, 900: 197, + 227: 198, 195: 199, 953: 202, 943: 203, 970: 204, 912: 206, 922: 207, 954: 208, 923: 209, 202: 210, 955: 211, 924: 212, 956: 213, 205: 214, 925: 215, 957: 216, + 926: 219, 958: 220, 927: 221, 959: 222, 972: 223, 211: 224, 223: 225, 212: 226, 928: 227, 245: 228, 213: 229, 960: 230, 929: 231, 961: 232, 218: 233, 931: 234, + 962: 235, 963: 236, 932: 237, 964: 238, 933: 239, 939: 240, 965: 241, 973: 242, 971: 243, 944: 244, 934: 245, 966: 246, 935: 247, 967: 248, 936: 249, 183: 250, + 968: 251, 937: 252, 969: 253, 974: 254, + }, + } + case 0x72: // 114 + return &StringConverter{ + LangID: 114, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 258, 259, 260, 261, 262, 263, 266, 267, 272, 273, 276, 277, 278, 279, 280, 281, + 711, 183, 340, 341, 342, 343, 286, 287, 288, 289, 290, 501, 294, 295, 304, 305, + 310, 311, 300, 301, 302, 303, 330, 331, 732, 312, 8220, 63737, 334, 335, 326, 713, + 730, 323, 364, 365, 223, 324, 346, 347, 8216, 325, 8223, 63734, 350, 351, 321, 322, + 192, 193, 313, 315, 196, 338, 198, 199, 200, 201, 368, 203, 204, 205, 358, 207, + 208, 354, 210, 211, 377, 379, 214, 336, 216, 217, 218, 370, 220, 221, 222, 376, + 224, 225, 314, 316, 228, 339, 230, 231, 232, 233, 369, 235, 236, 237, 359, 239, + 240, 355, 242, 243, 378, 380, 246, 337, 248, 249, 250, 371, 252, 253, 254, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 258: 128, 259: 129, 260: 130, 261: 131, 262: 132, 263: 133, 266: 134, 267: 135, 272: 136, 273: 137, 276: 138, 277: 139, 278: 140, 279: 141, 280: 142, 281: 143, + 711: 144, 183: 145, 340: 146, 341: 147, 342: 148, 343: 149, 286: 150, 287: 151, 288: 152, 289: 153, 290: 154, 501: 155, 294: 156, 295: 157, 304: 158, 305: 159, + 310: 160, 311: 161, 300: 162, 301: 163, 302: 164, 303: 165, 330: 166, 331: 167, 732: 168, 312: 169, 8220: 170, 63737: 171, 334: 172, 335: 173, 326: 174, 713: 175, + 730: 176, 323: 177, 364: 178, 365: 179, 223: 180, 324: 181, 346: 182, 347: 183, 8216: 184, 325: 185, 8223: 186, 63734: 187, 350: 188, 351: 189, 321: 190, 322: 191, + 192: 192, 193: 193, 313: 194, 315: 195, 196: 196, 338: 197, 198: 198, 199: 199, 200: 200, 201: 201, 368: 202, 203: 203, 204: 204, 205: 205, 358: 206, 207: 207, + 208: 208, 354: 209, 210: 210, 211: 211, 377: 212, 379: 213, 214: 214, 336: 215, 216: 216, 217: 217, 218: 218, 370: 219, 220: 220, 221: 221, 222: 222, 376: 223, + 224: 224, 225: 225, 314: 226, 316: 227, 228: 228, 339: 229, 230: 230, 231: 231, 232: 232, 233: 233, 369: 234, 235: 235, 236: 236, 237: 237, 359: 238, 239: 239, + 240: 240, 355: 241, 242: 242, 243: 243, 378: 244, 380: 245, 246: 246, 337: 247, 248: 248, 249: 249, 250: 250, 371: 251, 252: 252, 253: 253, 254: 254, 255: 255, + }, + } + case 0x8c: // 140 + return &StringConverter{ + LangID: 140, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, + 9492, 9524, 9516, 9500, 9472, 9532, 9571, 9553, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9488, + 9617, 9618, 9619, 9474, 9508, 8470, 167, 9559, 9565, 9496, 9484, 9608, 9604, 9612, 9616, 9600, + 945, 946, 915, 960, 931, 963, 956, 964, 934, 920, 937, 948, 8734, 966, 949, 8745, + 8801, 177, 8805, 8804, 8992, 8993, 247, 8776, 176, 183, 183, 8730, 8319, 178, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1040: 128, 1041: 129, 1042: 130, 1043: 131, 1044: 132, 1045: 133, 1046: 134, 1047: 135, 1048: 136, 1049: 137, 1050: 138, 1051: 139, 1052: 140, 1053: 141, 1054: 142, 1055: 143, + 1056: 144, 1057: 145, 1058: 146, 1059: 147, 1060: 148, 1061: 149, 1062: 150, 1063: 151, 1064: 152, 1065: 153, 1066: 154, 1067: 155, 1068: 156, 1069: 157, 1070: 158, 1071: 159, + 1072: 160, 1073: 161, 1074: 162, 1075: 163, 1076: 164, 1077: 165, 1078: 166, 1079: 167, 1080: 168, 1081: 169, 1082: 170, 1083: 171, 1084: 172, 1085: 173, 1086: 174, 1087: 175, + 1088: 176, 1089: 177, 1090: 178, 1091: 179, 1092: 180, 1093: 181, 1094: 182, 1095: 183, 1096: 184, 1097: 185, 1098: 186, 1099: 187, 1100: 188, 1101: 189, 1102: 190, 1103: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 9571: 198, 9553: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 9488: 207, + 9617: 208, 9618: 209, 9619: 210, 9474: 211, 9508: 212, 8470: 213, 167: 214, 9559: 215, 9565: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 9612: 221, 9616: 222, 9600: 223, + 945: 224, 946: 225, 915: 226, 960: 227, 931: 228, 963: 229, 956: 230, 964: 231, 934: 232, 920: 233, 937: 234, 948: 235, 8734: 236, 966: 237, 949: 238, 8745: 239, + 8801: 240, 177: 241, 8805: 242, 8804: 243, 8992: 244, 8993: 245, 247: 246, 8776: 247, 176: 248, 183: 250, 8730: 251, 8319: 252, 178: 253, 8718: 254, 160: 255, 8226: 249, + 63742: 250, + }, + } + case 0x96: // 150 + return &StringConverter{ + LangID: 150, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 367, 263, 231, 322, 235, 336, 337, 238, 377, 196, 262, + 201, 313, 314, 244, 246, 317, 318, 346, 347, 214, 220, 356, 357, 321, 215, 269, + 225, 237, 243, 250, 260, 261, 381, 382, 280, 281, 172, 378, 268, 351, 171, 187, + 9617, 9618, 9619, 9474, 9508, 193, 194, 282, 350, 9571, 9553, 9559, 9565, 379, 380, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 258, 259, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 164, + 273, 272, 270, 203, 271, 327, 205, 206, 283, 9496, 9484, 9608, 9604, 354, 366, 9600, + 211, 223, 212, 323, 324, 328, 352, 353, 340, 218, 341, 368, 253, 221, 355, 180, + 173, 733, 731, 711, 728, 167, 247, 184, 176, 168, 729, 369, 344, 345, 9632, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 367: 133, 263: 134, 231: 135, 322: 136, 235: 137, 336: 138, 337: 139, 238: 140, 377: 141, 196: 142, 262: 143, + 201: 144, 313: 145, 314: 146, 244: 147, 246: 148, 317: 149, 318: 150, 346: 151, 347: 152, 214: 153, 220: 154, 356: 155, 357: 156, 321: 157, 215: 158, 269: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 260: 164, 261: 165, 381: 166, 382: 167, 280: 168, 281: 169, 172: 170, 378: 171, 268: 172, 351: 173, 171: 174, 187: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 193: 181, 194: 182, 282: 183, 350: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 379: 189, 380: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 258: 198, 259: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 164: 207, + 273: 208, 272: 209, 270: 210, 203: 211, 271: 212, 327: 213, 205: 214, 206: 215, 283: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 354: 221, 366: 222, 9600: 223, + 211: 224, 223: 225, 212: 226, 323: 227, 324: 228, 328: 229, 352: 230, 353: 231, 340: 232, 218: 233, 341: 234, 368: 235, 253: 236, 221: 237, 355: 238, 180: 239, + 173: 240, 733: 241, 731: 242, 711: 243, 728: 244, 167: 245, 247: 246, 184: 247, 176: 248, 168: 249, 729: 250, 369: 251, 344: 252, 345: 253, 9632: 254, 160: 255, + }, + } + case 0x98: // 152 + return &StringConverter{ + LangID: 152, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 9617, 9618, 9619, 9474, 9508, 9569, 9570, 9558, 9557, 9571, 9553, 9559, 9565, 9564, 9563, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 9566, 9567, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9575, + 9576, 9572, 9573, 9561, 9560, 9554, 9555, 9579, 9578, 9496, 9484, 9608, 9604, 9612, 9616, 9600, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, + 1025, 1105, 1028, 1108, 1031, 1111, 1038, 1118, 176, 8729, 183, 8730, 8470, 164, 9632, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1040: 128, 1041: 129, 1042: 130, 1043: 131, 1044: 132, 1045: 133, 1046: 134, 1047: 135, 1048: 136, 1049: 137, 1050: 138, 1051: 139, 1052: 140, 1053: 141, 1054: 142, 1055: 143, + 1056: 144, 1057: 145, 1058: 146, 1059: 147, 1060: 148, 1061: 149, 1062: 150, 1063: 151, 1064: 152, 1065: 153, 1066: 154, 1067: 155, 1068: 156, 1069: 157, 1070: 158, 1071: 159, + 1072: 160, 1073: 161, 1074: 162, 1075: 163, 1076: 164, 1077: 165, 1078: 166, 1079: 167, 1080: 168, 1081: 169, 1082: 170, 1083: 171, 1084: 172, 1085: 173, 1086: 174, 1087: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 9569: 181, 9570: 182, 9558: 183, 9557: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 9564: 189, 9563: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 9566: 198, 9567: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 9575: 207, + 9576: 208, 9572: 209, 9573: 210, 9561: 211, 9560: 212, 9554: 213, 9555: 214, 9579: 215, 9578: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 9612: 221, 9616: 222, 9600: 223, + 1088: 224, 1089: 225, 1090: 226, 1091: 227, 1092: 228, 1093: 229, 1094: 230, 1095: 231, 1096: 232, 1097: 233, 1098: 234, 1099: 235, 1100: 236, 1101: 237, 1102: 238, 1103: 239, + 1025: 240, 1105: 241, 1028: 242, 1108: 243, 1031: 244, 1111: 245, 1038: 246, 1118: 247, 176: 248, 8729: 249, 183: 250, 8730: 251, 8470: 252, 164: 253, 9632: 254, 160: 32, + 173: 45, + }, + } + case 0x99: // 153 + return &StringConverter{ + LangID: 153, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 1066, 65535, 1098, 65535, + 8470, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 167, 8804, 65535, 8805, 65535, + 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, 1061, 1048, 1049, 1050, 1051, 1052, 1053, 1054, + 1055, 1071, 1056, 1057, 1058, 1059, 1046, 1042, 1068, 1067, 1047, 1064, 1069, 1065, 1063, 65535, + 1102, 1072, 1073, 1094, 1076, 1077, 1092, 1075, 1093, 1080, 1081, 1082, 1083, 1084, 1085, 1086, + 1087, 1103, 1088, 1089, 1090, 1091, 1078, 1074, 1100, 1099, 1079, 1096, 1101, 1097, 1095, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 1066: 172, 1098: 174, 8470: 176, 167: 187, 8804: 188, 8805: 190, 1070: 192, 1040: 193, 1041: 194, 1062: 195, 1044: 196, 1045: 197, 1060: 198, 1043: 199, 1061: 200, + 1048: 201, 1049: 202, 1050: 203, 1051: 204, 1052: 205, 1053: 206, 1054: 207, 1055: 208, 1071: 209, 1056: 210, 1057: 211, 1058: 212, 1059: 213, 1046: 214, 1042: 215, 1068: 216, + 1067: 217, 1047: 218, 1064: 219, 1069: 220, 1065: 221, 1063: 222, 1102: 224, 1072: 225, 1073: 226, 1094: 227, 1076: 228, 1077: 229, 1092: 230, 1075: 231, 1093: 232, 1080: 233, + 1081: 234, 1082: 235, 1083: 236, 1084: 237, 1085: 238, 1086: 239, 1087: 240, 1103: 241, 1088: 242, 1089: 243, 1090: 244, 1091: 245, 1078: 246, 1074: 247, 1100: 248, 1099: 249, + 1079: 250, 1096: 251, 1101: 252, 1097: 253, 1095: 254, 8216: 96, 160: 32, 173: 45, 180: 39, 8248: 94, 8764: 126, + }, + } + case 0x9a: // 154 + return &StringConverter{ + LangID: 154, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, + 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 162, 163, 165, 8359, 402, + 225, 237, 243, 250, 241, 209, 170, 186, 191, 8976, 172, 189, 188, 161, 171, 187, + 9617, 9618, 9619, 9474, 9508, 9569, 9570, 9558, 9557, 9571, 9553, 9559, 9565, 9564, 9563, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 9566, 9567, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9575, + 9576, 9572, 9573, 9561, 9560, 9554, 9555, 9579, 9578, 9496, 9484, 9608, 9604, 9612, 9616, 9600, + 945, 223, 915, 960, 931, 963, 956, 964, 934, 920, 937, 948, 8734, 966, 949, 8745, + 8801, 177, 8805, 8804, 8992, 8993, 247, 8776, 176, 8729, 183, 8730, 8319, 178, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1488: 128, 1489: 129, 1490: 130, 1491: 131, 1492: 132, 1493: 133, 1494: 134, 1495: 135, 1496: 136, 1497: 137, 1498: 138, 1499: 139, 1500: 140, 1501: 141, 1502: 142, 1503: 143, + 1504: 144, 1505: 145, 1506: 146, 1507: 147, 1508: 148, 1509: 149, 1510: 150, 1511: 151, 1512: 152, 1513: 153, 1514: 154, 162: 155, 163: 156, 165: 157, 8359: 158, 402: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 170: 166, 186: 167, 191: 168, 8976: 169, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 187: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 9569: 181, 9570: 182, 9558: 183, 9557: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 9564: 189, 9563: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 9566: 198, 9567: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 9575: 207, + 9576: 208, 9572: 209, 9573: 210, 9561: 211, 9560: 212, 9554: 213, 9555: 214, 9579: 215, 9578: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 9612: 221, 9616: 222, 9600: 223, + 945: 224, 223: 225, 915: 226, 960: 227, 931: 228, 963: 229, 956: 230, 964: 231, 934: 232, 920: 233, 937: 234, 948: 235, 8734: 236, 966: 237, 949: 238, 8745: 239, + 8801: 240, 177: 241, 8805: 242, 8804: 243, 8992: 244, 8993: 245, 247: 246, 8776: 247, 176: 248, 8729: 249, 183: 250, 8730: 251, 8319: 252, 178: 253, 8718: 254, 160: 255, + 181: 230, 63741: 159, + }, + } + case 0x9b: // 155 + return &StringConverter{ + LangID: 155, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1106, 1026, 1107, 1027, 1105, 1025, 1108, 1028, 1109, 1029, 1110, 1030, 1111, 1031, 1112, 1032, + 1113, 1033, 1114, 1034, 1115, 1035, 1116, 1036, 1118, 1038, 1119, 1039, 1102, 1070, 1098, 1066, + 1072, 1040, 1073, 1041, 1094, 1062, 1076, 1044, 1077, 1045, 1092, 1060, 1075, 1043, 171, 187, + 65535, 65535, 65535, 65535, 65535, 1093, 1061, 1080, 1048, 65535, 65535, 65535, 65535, 1081, 1049, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 1082, 1050, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 164, + 1083, 1051, 1084, 1052, 1085, 1053, 1086, 1054, 1087, 65535, 65535, 65535, 65535, 1055, 1103, 65535, + 1071, 1088, 1056, 1089, 1057, 1090, 1058, 1091, 1059, 1078, 1046, 1074, 1042, 1100, 1068, 8470, + 173, 1099, 1067, 1079, 1047, 1096, 1064, 1101, 1069, 1097, 1065, 1095, 1063, 65535, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1106: 128, 1026: 129, 1107: 130, 1027: 131, 1105: 132, 1025: 133, 1108: 134, 1028: 135, 1109: 136, 1029: 137, 1110: 138, 1030: 139, 1111: 140, 1031: 141, 1112: 142, 1032: 143, + 1113: 144, 1033: 145, 1114: 146, 1034: 147, 1115: 148, 1035: 149, 1116: 150, 1036: 151, 1118: 152, 1038: 153, 1119: 154, 1039: 155, 1102: 156, 1070: 157, 1098: 158, 1066: 159, + 1072: 160, 1040: 161, 1073: 162, 1041: 163, 1094: 164, 1062: 165, 1076: 166, 1044: 167, 1077: 168, 1045: 169, 1092: 170, 1060: 171, 1075: 172, 1043: 173, 171: 174, 187: 175, + 65535: 253, 1093: 181, 1061: 182, 1080: 183, 1048: 184, 1081: 189, 1049: 190, 1082: 198, 1050: 199, 164: 207, 1083: 208, 1051: 209, 1084: 210, 1052: 211, 1085: 212, 1053: 213, + 1086: 214, 1054: 215, 1087: 216, 1055: 221, 1103: 222, 1071: 224, 1088: 225, 1056: 226, 1089: 227, 1057: 228, 1090: 229, 1058: 230, 1091: 231, 1059: 232, 1078: 233, 1046: 234, + 1074: 235, 1042: 236, 1100: 237, 1068: 238, 8470: 239, 173: 240, 1099: 241, 1067: 242, 1079: 243, 1047: 244, 1096: 245, 1064: 246, 1101: 247, 1069: 248, 1097: 249, 1065: 250, + 1095: 251, 1063: 252, 8718: 254, 160: 255, + }, + } + case 0x9c: // 156 + return &StringConverter{ + LangID: 156, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 239, 238, 305, 196, 197, + 201, 230, 198, 244, 246, 242, 251, 249, 304, 214, 220, 248, 163, 216, 350, 351, + 225, 237, 243, 250, 241, 209, 286, 287, 191, 174, 172, 189, 188, 161, 171, 187, + 9617, 9618, 9619, 9474, 9508, 193, 194, 192, 169, 9571, 9553, 9559, 9565, 162, 165, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 227, 195, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 164, + 186, 170, 202, 203, 200, 65535, 205, 206, 207, 9496, 9484, 9608, 9604, 166, 204, 9600, + 211, 223, 212, 210, 245, 213, 181, 65535, 215, 218, 219, 217, 236, 255, 175, 180, + 173, 177, 65535, 190, 182, 167, 247, 184, 176, 168, 183, 185, 179, 178, 9632, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 305: 141, 196: 142, 197: 143, + 201: 144, 230: 145, 198: 146, 244: 147, 246: 148, 242: 149, 251: 150, 249: 151, 304: 152, 214: 153, 220: 154, 248: 155, 163: 156, 216: 157, 350: 158, 351: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 286: 166, 287: 167, 191: 168, 174: 169, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 187: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 193: 181, 194: 182, 192: 183, 169: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 162: 189, 165: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 227: 198, 195: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 164: 207, + 186: 208, 170: 209, 202: 210, 203: 211, 200: 212, 65535: 242, 205: 214, 206: 215, 207: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 166: 221, 204: 222, 9600: 223, + 211: 224, 223: 225, 212: 226, 210: 227, 245: 228, 213: 229, 181: 230, 215: 232, 218: 233, 219: 234, 217: 235, 236: 236, 255: 237, 175: 238, 180: 239, 173: 240, + 177: 241, 190: 243, 182: 244, 167: 245, 247: 246, 184: 247, 176: 248, 168: 249, 183: 250, 185: 251, 179: 252, 178: 253, 9632: 254, 160: 255, 8216: 96, 8213: 45, + 8248: 94, 8764: 126, 8356: 76, 63738: 73, 63736: 105, + }, + } + case 0x9e: // 158 + return &StringConverter{ + LangID: 158, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 65535, 176, 162, 163, 167, 183, 182, 1030, 174, 169, 8482, 1026, 1106, 1110, 1027, 1107, + 65535, 177, 8804, 8805, 165, 181, 65535, 1032, 1028, 1108, 1031, 1111, 1033, 1113, 1034, 1114, + 1112, 1029, 172, 65535, 402, 65535, 65535, 171, 187, 65535, 160, 1035, 1115, 1036, 1116, 1109, + 173, 8213, 65535, 65535, 65535, 65535, 247, 65535, 1038, 1118, 1039, 1119, 8470, 1025, 1105, 1103, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 164, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1040: 128, 1041: 129, 1042: 130, 1043: 131, 1044: 132, 1045: 133, 1046: 134, 1047: 135, 1048: 136, 1049: 137, 1050: 138, 1051: 139, 1052: 140, 1053: 141, 1054: 142, 1055: 143, + 1056: 144, 1057: 145, 1058: 146, 1059: 147, 1060: 148, 1061: 149, 1062: 150, 1063: 151, 1064: 152, 1065: 153, 1066: 154, 1067: 155, 1068: 156, 1069: 157, 1070: 158, 1071: 159, + 65535: 215, 176: 161, 162: 162, 163: 163, 167: 164, 183: 165, 182: 166, 1030: 167, 174: 168, 169: 169, 8482: 170, 1026: 171, 1106: 172, 1110: 173, 1027: 174, 1107: 175, + 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 1032: 183, 1028: 184, 1108: 185, 1031: 186, 1111: 187, 1033: 188, 1113: 189, 1034: 190, 1114: 191, 1112: 192, 1029: 193, + 172: 194, 402: 196, 171: 199, 187: 200, 160: 202, 1035: 203, 1115: 204, 1036: 205, 1116: 206, 1109: 207, 173: 208, 8213: 209, 247: 214, 1038: 216, 1118: 217, 1039: 218, + 1119: 219, 8470: 220, 1025: 221, 1105: 222, 1103: 223, 1072: 224, 1073: 225, 1074: 226, 1075: 227, 1076: 228, 1077: 229, 1078: 230, 1079: 231, 1080: 232, 1081: 233, 1082: 234, + 1083: 235, 1084: 236, 1085: 237, 1086: 238, 1087: 239, 1088: 240, 1089: 241, 1090: 242, 1091: 243, 1092: 244, 1093: 245, 1094: 246, 1095: 247, 1096: 248, 1097: 249, 1098: 250, + 1099: 251, 1100: 252, 1101: 253, 1102: 254, 164: 255, 63741: 196, + }, + } + case 0x9f: // 159 + return &StringConverter{ + LangID: 159, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 65535, 176, 162, 163, 167, 183, 182, 1030, 174, 169, 8482, 1026, 1106, 1110, 1027, 1107, + 65535, 177, 8804, 8805, 165, 181, 65535, 1032, 1028, 1108, 1031, 1111, 1033, 1113, 1034, 1114, + 1112, 1029, 172, 65535, 402, 65535, 65535, 171, 187, 65535, 160, 1035, 1115, 1036, 1116, 1109, + 173, 8213, 65535, 65535, 65535, 65535, 247, 65535, 1038, 1118, 1039, 1119, 8470, 1025, 1105, 1103, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 164, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1040: 128, 1041: 129, 1042: 130, 1043: 131, 1044: 132, 1045: 133, 1046: 134, 1047: 135, 1048: 136, 1049: 137, 1050: 138, 1051: 139, 1052: 140, 1053: 141, 1054: 142, 1055: 143, + 1056: 144, 1057: 145, 1058: 146, 1059: 147, 1060: 148, 1061: 149, 1062: 150, 1063: 151, 1064: 152, 1065: 153, 1066: 154, 1067: 155, 1068: 156, 1069: 157, 1070: 158, 1071: 159, + 65535: 215, 176: 161, 162: 162, 163: 163, 167: 164, 183: 165, 182: 166, 1030: 167, 174: 168, 169: 169, 8482: 170, 1026: 171, 1106: 172, 1110: 173, 1027: 174, 1107: 175, + 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 1032: 183, 1028: 184, 1108: 185, 1031: 186, 1111: 187, 1033: 188, 1113: 189, 1034: 190, 1114: 191, 1112: 192, 1029: 193, + 172: 194, 402: 196, 171: 199, 187: 200, 160: 202, 1035: 203, 1115: 204, 1036: 205, 1116: 206, 1109: 207, 173: 208, 8213: 209, 247: 214, 1038: 216, 1118: 217, 1039: 218, + 1119: 219, 8470: 220, 1025: 221, 1105: 222, 1103: 223, 1072: 224, 1073: 225, 1074: 226, 1075: 227, 1076: 228, 1077: 229, 1078: 230, 1079: 231, 1080: 232, 1081: 233, 1082: 234, + 1083: 235, 1084: 236, 1085: 237, 1086: 238, 1087: 239, 1088: 240, 1089: 241, 1090: 242, 1091: 243, 1092: 244, 1093: 245, 1094: 246, 1095: 247, 1096: 248, 1097: 249, 1098: 250, + 1099: 251, 1100: 252, 1101: 253, 1102: 254, 164: 255, 63741: 196, + }, + } + case 0xa0: // 160 + return &StringConverter{ + LangID: 160, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 227, 224, 193, 231, 234, 202, 232, 205, 212, 236, 195, 194, + 201, 192, 200, 244, 245, 242, 218, 249, 204, 213, 220, 162, 163, 217, 8359, 211, + 225, 237, 243, 250, 241, 209, 170, 186, 191, 210, 172, 189, 188, 161, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 945, 223, 915, 960, 931, 963, 181, 964, 934, 920, 937, 948, 65535, 966, 949, 65535, + 65535, 177, 8805, 8804, 65535, 65535, 247, 65535, 176, 729, 183, 65535, 65535, 178, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 227: 132, 224: 133, 193: 134, 231: 135, 234: 136, 202: 137, 232: 138, 205: 139, 212: 140, 236: 141, 195: 142, 194: 143, + 201: 144, 192: 145, 200: 146, 244: 147, 245: 148, 242: 149, 218: 150, 249: 151, 204: 152, 213: 153, 220: 154, 162: 155, 163: 156, 217: 157, 8359: 158, 211: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 170: 166, 186: 167, 191: 168, 210: 169, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 187: 175, + 65535: 252, 945: 224, 223: 225, 915: 226, 960: 227, 931: 228, 963: 229, 181: 230, 964: 231, 934: 232, 920: 233, 937: 234, 948: 235, 966: 237, 949: 238, 177: 241, + 8805: 242, 8804: 243, 247: 246, 176: 248, 729: 249, 183: 250, 178: 253, 8718: 254, 160: 255, 169: 99, 174: 82, 8216: 96, 8213: 45, 173: 45, 180: 39, 8248: 94, + 8764: 126, 8356: 76, 215: 42, 196: 65, 197: 65, 203: 69, 206: 73, 207: 73, 214: 79, 216: 79, 219: 85, 221: 89, 228: 97, 229: 97, 235: 101, 238: 105, + 239: 105, 246: 111, 248: 111, 251: 117, 253: 121, 255: 121, + }, + } + case 0xa1: // 161 + return &StringConverter{ + LangID: 161, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 208, 240, 222, 196, 197, + 201, 230, 198, 244, 246, 254, 251, 221, 253, 214, 220, 248, 163, 216, 8359, 402, + 225, 237, 243, 250, 193, 205, 211, 218, 191, 65535, 172, 189, 188, 161, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 945, 223, 915, 960, 931, 963, 956, 964, 934, 920, 937, 948, 65535, 966, 949, 65535, + 65535, 177, 8805, 8804, 65535, 65535, 247, 65535, 176, 729, 183, 65535, 65535, 178, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 208: 139, 240: 140, 222: 141, 196: 142, 197: 143, + 201: 144, 230: 145, 198: 146, 244: 147, 246: 148, 254: 149, 251: 150, 221: 151, 253: 152, 214: 153, 220: 154, 248: 155, 163: 156, 216: 157, 8359: 158, 402: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 193: 164, 205: 165, 211: 166, 218: 167, 191: 168, 65535: 252, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 187: 175, + 945: 224, 223: 225, 915: 226, 960: 227, 931: 228, 963: 229, 956: 230, 964: 231, 934: 232, 920: 233, 937: 234, 948: 235, 966: 237, 949: 238, 177: 241, 8805: 242, + 8804: 243, 247: 246, 176: 248, 729: 249, 183: 250, 178: 253, 8718: 254, 160: 255, 63741: 159, + }, + } + case 0xa2: // 162 + return &StringConverter{ + LangID: 162, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 256, 257, 201, 260, 214, 220, 225, 261, 268, 228, 269, 262, 263, 233, 377, + 378, 270, 237, 271, 274, 275, 278, 243, 279, 244, 246, 245, 250, 282, 283, 252, + 65535, 176, 280, 163, 167, 183, 182, 223, 174, 169, 8482, 281, 168, 8800, 65535, 302, + 303, 298, 8804, 8805, 299, 310, 948, 931, 322, 315, 316, 317, 318, 313, 314, 325, + 326, 323, 172, 65535, 324, 327, 916, 171, 187, 65535, 160, 328, 336, 213, 337, 332, + 65535, 8213, 8220, 8221, 8216, 8217, 247, 65535, 333, 340, 341, 344, 65535, 65535, 345, 342, + 343, 352, 65535, 65535, 353, 346, 347, 193, 356, 357, 205, 381, 382, 362, 211, 212, + 363, 366, 218, 367, 368, 369, 370, 371, 221, 253, 311, 379, 321, 380, 65535, 711, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 256: 129, 257: 130, 201: 131, 260: 132, 214: 133, 220: 134, 225: 135, 261: 136, 268: 137, 228: 138, 269: 139, 262: 140, 263: 141, 233: 142, 377: 143, + 378: 144, 270: 145, 237: 146, 271: 147, 274: 148, 275: 149, 278: 150, 243: 151, 279: 152, 244: 153, 246: 154, 245: 155, 250: 156, 282: 157, 283: 158, 252: 159, + 65535: 254, 176: 161, 280: 162, 163: 163, 167: 164, 183: 165, 182: 166, 223: 167, 174: 168, 169: 169, 8482: 170, 281: 171, 168: 172, 8800: 173, 302: 175, 303: 176, + 298: 177, 8804: 178, 8805: 179, 299: 180, 310: 181, 948: 182, 931: 183, 322: 184, 315: 185, 316: 186, 317: 187, 318: 188, 313: 189, 314: 190, 325: 191, 326: 192, + 323: 193, 172: 194, 324: 196, 327: 197, 916: 198, 171: 199, 187: 200, 160: 202, 328: 203, 336: 204, 213: 205, 337: 206, 332: 207, 8213: 209, 8220: 210, 8221: 211, + 8216: 212, 8217: 213, 247: 214, 333: 216, 340: 217, 341: 218, 344: 219, 345: 222, 342: 223, 343: 224, 352: 225, 353: 228, 346: 229, 347: 230, 193: 231, 356: 232, + 357: 233, 205: 234, 381: 235, 382: 236, 362: 237, 211: 238, 212: 239, 363: 240, 366: 241, 218: 242, 367: 243, 368: 244, 369: 245, 370: 246, 371: 247, 221: 248, + 253: 249, 311: 250, 379: 251, 321: 252, 380: 253, 711: 255, + }, + } + case 0xa3: // 163 + return &StringConverter{ + LangID: 163, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 65535, 176, 162, 163, 167, 183, 182, 223, 174, 350, 8482, 180, 168, 8800, 381, 216, + 65535, 177, 8804, 8805, 165, 181, 948, 931, 928, 351, 65535, 170, 186, 8486, 382, 248, + 191, 161, 172, 65535, 402, 8764, 262, 171, 268, 65535, 160, 192, 195, 213, 338, 339, + 272, 8213, 8220, 8221, 8216, 8217, 247, 65535, 65535, 169, 65535, 65535, 65535, 65535, 198, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 263, 65535, 269, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 273, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 960, 65535, 65535, 65535, 65535, 230, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 65535: 255, 176: 161, 162: 162, 163: 163, 167: 164, 183: 165, 182: 166, 223: 167, 174: 168, 350: 169, 8482: 170, 180: 171, 168: 172, 8800: 173, 381: 174, 216: 175, + 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 948: 182, 931: 183, 928: 184, 351: 185, 170: 187, 186: 188, 8486: 189, 382: 190, 248: 191, 191: 192, 161: 193, + 172: 194, 402: 196, 8764: 197, 262: 198, 171: 199, 268: 200, 160: 202, 192: 203, 195: 204, 213: 205, 338: 206, 339: 207, 272: 208, 8213: 209, 8220: 210, 8221: 211, + 8216: 212, 8217: 213, 247: 214, 169: 217, 198: 222, 187: 223, 263: 230, 269: 232, 273: 240, 960: 249, 230: 254, 63741: 196, + }, + } + case 0xa4: // 164 + return &StringConverter{ + LangID: 164, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 8224, 176, 162, 163, 167, 8226, 182, 223, 174, 169, 8482, 180, 168, 8800, 198, 216, + 8734, 177, 8804, 8805, 165, 181, 948, 931, 928, 960, 8747, 170, 186, 8486, 230, 248, + 191, 161, 172, 8730, 402, 8776, 8710, 171, 187, 8230, 160, 192, 195, 213, 338, 339, + 8211, 8213, 8220, 8221, 8216, 8217, 247, 9674, 255, 376, 286, 287, 304, 305, 350, 351, + 8225, 183, 8218, 8222, 8240, 194, 202, 193, 203, 200, 205, 206, 207, 204, 211, 212, + 65535, 210, 218, 219, 217, 65535, 710, 732, 713, 728, 729, 730, 184, 733, 731, 711, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 8224: 160, 176: 161, 162: 162, 163: 163, 167: 164, 8226: 165, 182: 166, 223: 167, 174: 168, 169: 169, 8482: 170, 180: 171, 168: 172, 8800: 173, 198: 174, 216: 175, + 8734: 176, 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 948: 182, 931: 183, 928: 184, 960: 185, 8747: 186, 170: 187, 186: 188, 8486: 189, 230: 190, 248: 191, + 191: 192, 161: 193, 172: 194, 8730: 195, 402: 196, 8776: 197, 8710: 198, 171: 199, 187: 200, 8230: 201, 160: 202, 192: 203, 195: 204, 213: 205, 338: 206, 339: 207, + 8211: 208, 8213: 209, 8220: 210, 8221: 211, 8216: 212, 8217: 213, 247: 214, 9674: 215, 255: 216, 376: 217, 286: 218, 287: 219, 304: 220, 305: 221, 350: 222, 351: 223, + 8225: 224, 183: 225, 8218: 226, 8222: 227, 8240: 228, 194: 229, 202: 230, 193: 231, 203: 232, 200: 233, 205: 234, 206: 235, 207: 236, 204: 237, 211: 238, 212: 239, + 65535: 245, 210: 241, 218: 242, 219: 243, 217: 244, 710: 246, 732: 247, 713: 248, 728: 249, 729: 250, 730: 251, 184: 252, 733: 253, 731: 254, 711: 255, 175: 248, + 173: 225, 166: 124, 8764: 197, 215: 42, 63738: 73, 63736: 105, 916: 198, 63740: 240, 63741: 196, + }, + } + case 0xa5: // 165 + return &StringConverter{ + LangID: 165, + CharWidth: 1, + eReplace: 65533, + dReplace: 192, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 8764, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 221, 176, 162, 163, 167, 65535, 182, 223, 174, 169, 8482, 180, 168, 8800, 198, 216, + 65535, 177, 8804, 8805, 165, 181, 948, 931, 928, 960, 65535, 170, 186, 8486, 230, 248, + 191, 161, 172, 65535, 402, 65535, 916, 171, 187, 65535, 160, 192, 195, 213, 338, 339, + 65535, 8213, 8220, 8221, 8216, 8217, 247, 65535, 255, 376, 65535, 164, 208, 240, 222, 254, + 253, 183, 65535, 65535, 65535, 194, 202, 193, 203, 200, 205, 206, 207, 204, 211, 212, + 65535, 210, 218, 219, 217, 305, 8248, 126, 713, 728, 729, 730, 184, 733, 731, 711, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 8764: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 221: 160, 176: 161, 162: 162, 163: 163, 167: 164, 65535: 240, 182: 166, 223: 167, 174: 168, 169: 169, 8482: 170, 180: 171, 168: 172, 8800: 173, 198: 174, 216: 175, + 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 948: 182, 931: 183, 928: 184, 960: 185, 170: 187, 186: 188, 8486: 189, 230: 190, 248: 191, 191: 192, 161: 193, + 172: 194, 402: 196, 916: 198, 171: 199, 187: 200, 160: 202, 192: 203, 195: 204, 213: 205, 338: 206, 339: 207, 8213: 209, 8220: 210, 8221: 211, 8216: 212, 8217: 213, + 247: 214, 255: 216, 376: 217, 164: 219, 208: 220, 240: 221, 222: 222, 254: 223, 253: 224, 183: 225, 194: 229, 202: 230, 193: 231, 203: 232, 200: 233, 205: 234, + 206: 235, 207: 236, 204: 237, 211: 238, 212: 239, 210: 241, 218: 242, 219: 243, 217: 244, 305: 245, 8248: 246, 126: 247, 713: 248, 728: 249, 729: 250, 730: 251, + 184: 252, 733: 253, 731: 254, 711: 255, 173: 225, 166: 124, 215: 42, 63741: 196, + }, + } + case 0xa6: // 166 + return &StringConverter{ + LangID: 166, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 65535, 8216, 8217, 163, 174, 247, 166, 167, 168, 169, 8482, 171, 172, 65535, 65535, 8213, + 176, 177, 178, 179, 900, 901, 902, 183, 904, 905, 906, 187, 908, 189, 910, 911, + 970, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, + 928, 929, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 971, + 912, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, + 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 65535, 65535, 972, 973, 974, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 65535: 255, 8216: 161, 8217: 162, 163: 163, 174: 164, 247: 165, 166: 166, 167: 167, 168: 168, 169: 169, 8482: 170, 171: 171, 172: 172, 8213: 175, 176: 176, 177: 177, + 178: 178, 179: 179, 900: 180, 901: 181, 902: 182, 183: 183, 904: 184, 905: 185, 906: 186, 187: 187, 908: 188, 189: 189, 910: 190, 911: 191, 970: 192, 913: 193, + 914: 194, 915: 195, 916: 196, 917: 197, 918: 198, 919: 199, 920: 200, 921: 201, 922: 202, 923: 203, 924: 204, 925: 205, 926: 206, 927: 207, 928: 208, 929: 209, + 931: 210, 932: 211, 933: 212, 934: 213, 935: 214, 936: 215, 937: 216, 938: 217, 939: 218, 940: 219, 941: 220, 942: 221, 943: 222, 971: 223, 912: 224, 945: 225, + 946: 226, 947: 227, 948: 228, 949: 229, 950: 230, 951: 231, 952: 232, 953: 233, 954: 234, 955: 235, 956: 236, 957: 237, 958: 238, 959: 239, 960: 240, 961: 241, + 962: 242, 963: 243, 964: 244, 965: 245, 966: 246, 967: 247, 968: 248, 969: 249, 972: 252, 973: 253, 974: 254, + }, + } + case 0xa7: // 167 + return &StringConverter{ + LangID: 167, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 64287, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 63713, 63712, 63711, 63710, 63709, 63708, 8362, 63707, 63706, 63705, 63704, 63703, 63702, 63701, 63700, 63699, + 63698, 63697, 63696, 63695, 63694, 63693, 63692, 63691, 63690, 63689, 63688, 63687, 63684, 63685, 63686, 63674, + 64316, 8222, 65535, 65535, 65535, 65535, 1468, 64331, 64309, 8230, 160, 1464, 1463, 1461, 1462, 1460, + 8211, 8213, 8220, 8221, 8216, 8217, 64298, 64299, 63682, 63730, 1458, 1457, 1467, 1465, 1464, 1459, + 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, + 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 63678, 63683, 63676, 63676, 63677, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 64287: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 63713: 160, 63712: 161, 63711: 162, 63710: 163, 63709: 164, 63708: 165, 8362: 166, 63707: 167, 63706: 168, 63705: 169, 63704: 170, 63703: 171, 63702: 172, 63701: 173, 63700: 174, 63699: 175, + 63698: 176, 63697: 177, 63696: 178, 63695: 179, 63694: 180, 63693: 181, 63692: 182, 63691: 183, 63690: 184, 63689: 185, 63688: 186, 63687: 187, 63684: 188, 63685: 189, 63686: 190, 63674: 191, + 64316: 192, 8222: 193, 65535: 197, 1468: 198, 64331: 199, 64309: 200, 8230: 201, 160: 202, 1464: 222, 1463: 204, 1461: 205, 1462: 206, 1460: 207, 8211: 208, 8213: 209, 8220: 210, + 8221: 211, 8216: 212, 8217: 213, 64298: 214, 64299: 215, 63682: 216, 63730: 217, 1458: 218, 1457: 219, 1467: 220, 1465: 221, 1459: 223, 1488: 224, 1489: 225, 1490: 226, 1491: 227, + 1492: 228, 1493: 229, 1494: 230, 1495: 231, 1496: 232, 1497: 233, 1498: 234, 1499: 235, 1500: 236, 1501: 237, 1502: 238, 1503: 239, 1504: 240, 1505: 241, 1506: 242, 1507: 243, + 1508: 244, 1509: 245, 1510: 246, 1511: 247, 1512: 248, 1513: 249, 1514: 250, 63678: 251, 63683: 252, 63676: 254, 63677: 255, + }, + } + case 0xaa: // 170 + return &StringConverter{ + LangID: 170, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8364, 129, 8218, 131, 8222, 8230, 8224, 8225, 136, 8240, 352, 8249, 346, 356, 381, 377, + 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 353, 8250, 347, 357, 382, 378, + 160, 711, 728, 321, 164, 260, 166, 167, 168, 169, 350, 171, 172, 173, 174, 379, + 176, 177, 731, 322, 180, 181, 182, 183, 184, 261, 351, 187, 317, 733, 318, 380, + 340, 193, 194, 258, 196, 313, 262, 199, 268, 201, 280, 203, 282, 205, 206, 270, + 272, 323, 327, 211, 212, 336, 214, 215, 344, 366, 218, 368, 220, 221, 354, 223, + 341, 225, 226, 259, 228, 314, 263, 231, 269, 233, 281, 235, 283, 237, 238, 271, + 273, 324, 328, 243, 244, 337, 246, 247, 345, 367, 250, 369, 252, 253, 355, 729, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 8364: 128, 129: 129, 8218: 130, 131: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 136: 136, 8240: 137, 352: 138, 8249: 139, 346: 140, 356: 141, 381: 142, 377: 143, + 144: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 152: 152, 8482: 153, 353: 154, 8250: 155, 347: 156, 357: 157, 382: 158, 378: 159, + 160: 160, 711: 161, 728: 162, 321: 163, 164: 164, 260: 165, 166: 166, 167: 167, 168: 168, 169: 169, 350: 170, 171: 171, 172: 172, 173: 173, 174: 174, 379: 175, + 176: 176, 177: 177, 731: 178, 322: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 261: 185, 351: 186, 187: 187, 317: 188, 733: 189, 318: 190, 380: 191, + 340: 192, 193: 193, 194: 194, 258: 195, 196: 196, 313: 197, 262: 198, 199: 199, 268: 200, 201: 201, 280: 202, 203: 203, 282: 204, 205: 205, 206: 206, 270: 207, + 272: 208, 323: 209, 327: 210, 211: 211, 212: 212, 336: 213, 214: 214, 215: 215, 344: 216, 366: 217, 218: 218, 368: 219, 220: 220, 221: 221, 354: 222, 223: 223, + 341: 224, 225: 225, 226: 226, 259: 227, 228: 228, 314: 229, 263: 230, 231: 231, 269: 232, 233: 233, 281: 234, 235: 235, 283: 236, 237: 237, 238: 238, 271: 239, + 273: 240, 324: 241, 328: 242, 243: 243, 244: 244, 337: 245, 246: 246, 247: 247, 345: 248, 367: 249, 250: 250, 369: 251, 252: 252, 253: 253, 355: 254, 729: 255, + 161: 33, 162: 99, 163: 76, 165: 89, 170: 97, 175: 151, 178: 50, 179: 51, 185: 49, 186: 111, 188: 49, 189: 49, 190: 51, 192: 65, 195: 65, 197: 65, + 198: 65, 200: 69, 202: 69, 204: 73, 207: 73, 209: 78, 210: 79, 213: 79, 216: 79, 217: 85, 219: 85, 224: 97, 227: 97, 229: 97, 230: 97, 232: 101, + 234: 101, 236: 105, 239: 105, 241: 110, 242: 111, 245: 111, 248: 111, 249: 117, 251: 117, 255: 121, 256: 65, 257: 97, 264: 67, 265: 99, 266: 67, 267: 99, + 274: 69, 275: 101, 276: 69, 277: 101, 278: 69, 279: 101, 284: 71, 285: 103, 286: 71, 287: 103, 288: 71, 289: 103, 290: 71, 291: 103, 292: 72, 293: 104, + 294: 72, 295: 104, 296: 73, 297: 105, 298: 73, 299: 105, 300: 73, 301: 105, 302: 73, 303: 105, 304: 73, 305: 105, 308: 74, 309: 106, 310: 75, 311: 107, + 315: 76, 316: 108, 325: 78, 326: 110, 332: 79, 333: 111, 334: 79, 335: 111, 338: 79, 339: 111, 342: 82, 343: 114, 348: 83, 349: 115, 358: 84, 359: 116, + 360: 85, 361: 117, 362: 85, 363: 117, 364: 85, 365: 117, 370: 85, 371: 117, 372: 87, 373: 119, 374: 89, 375: 121, 376: 89, 384: 98, 393: 208, 401: 70, + 402: 102, 407: 73, 410: 108, 415: 79, 416: 79, 417: 111, 427: 116, 430: 84, 431: 85, 432: 117, 438: 122, 448: 124, 451: 33, 461: 65, 462: 97, 463: 73, + 464: 105, 465: 79, 466: 111, 467: 85, 468: 117, 469: 85, 470: 117, 471: 85, 472: 117, 473: 85, 474: 117, 475: 85, 476: 117, 478: 65, 479: 97, 484: 71, + 485: 103, 486: 71, 487: 103, 488: 75, 489: 107, 490: 79, 491: 111, 492: 79, 493: 111, 496: 106, 609: 103, 697: 39, 698: 34, 699: 145, 700: 39, 708: 94, + 710: 94, 712: 39, 713: 175, 714: 180, 715: 96, 717: 95, 730: 176, 732: 126, 768: 96, 769: 180, 770: 94, 771: 126, 772: 175, 773: 175, 774: 162, 775: 255, + 776: 168, 778: 176, 780: 161, 782: 34, 807: 184, 817: 95, 818: 95, 894: 59, 946: 223, 956: 181, 1211: 104, 1417: 58, 1642: 37, 8192: 32, 8193: 32, 8194: 32, + 8195: 32, 8196: 32, 8197: 32, 8198: 32, 8208: 45, 8209: 45, 8228: 149, 8242: 39, 8243: 148, 8245: 96, 8252: 33, 8260: 47, 8304: 176, 8308: 52, 8309: 53, 8310: 54, + 8311: 55, 8312: 56, 8320: 48, 8321: 49, 8322: 50, 8323: 51, 8324: 52, 8325: 53, 8326: 54, 8327: 55, 8328: 56, 8329: 57, 8356: 163, 8450: 67, 8455: 69, 8458: 103, + 8459: 72, 8460: 72, 8461: 72, 8462: 104, 8464: 73, 8465: 73, 8466: 76, 8467: 108, 8469: 78, 8472: 80, 8473: 80, 8474: 81, 8475: 82, 8476: 82, 8477: 82, 8484: 90, + 8488: 90, 8490: 75, 8491: 197, 8492: 66, 8493: 67, 8494: 101, 8495: 101, 8496: 69, 8497: 70, 8499: 77, 8500: 111, 8592: 139, 8593: 94, 8594: 155, 8595: 161, 8596: 45, + 8597: 124, 8616: 124, 8709: 216, 8722: 45, 8723: 177, 8725: 47, 8726: 92, 8727: 42, 8728: 176, 8729: 149, 8735: 76, 8739: 124, 8758: 58, 8764: 126, 8810: 171, 8811: 187, + 8901: 183, 8962: 166, 8963: 94, 9001: 60, 9002: 62, 9472: 166, 9474: 45, 9484: 45, 9488: 172, 9492: 76, 9496: 45, 9500: 43, 9508: 43, 9516: 84, 9524: 43, 9532: 43, + 9552: 61, 9553: 166, 9556: 45, 9559: 172, 9562: 76, 9565: 45, 9568: 166, 9571: 166, 9574: 84, 9577: 166, 9580: 43, 9600: 45, 9604: 45, 9608: 45, 9617: 45, 9618: 45, + 9619: 45, 9632: 166, 9644: 45, 9650: 94, 9658: 62, 9660: 161, 9668: 60, 9675: 48, 9688: 149, 9689: 48, 9786: 162, 9787: 162, 9788: 48, 9792: 43, 9794: 62, 9824: 166, + 9827: 166, 9829: 166, 9830: 166, 9834: 100, 9835: 100, 10072: 124, 10075: 145, 10076: 146, 10077: 147, 10078: 148, 12288: 32, 12296: 60, 12297: 62, 12298: 171, 12299: 187, 12314: 91, + 12315: 93, 12317: 147, 12318: 148, 12319: 132, 12539: 183, 12540: 151, 65281: 33, 65282: 34, 65283: 35, 65284: 36, 65285: 37, 65286: 38, 65287: 39, 65288: 40, 65289: 41, 65290: 42, + 65291: 43, 65292: 44, 65293: 45, 65294: 46, 65295: 47, 65296: 48, 65297: 49, 65298: 50, 65299: 51, 65300: 52, 65301: 53, 65302: 54, 65303: 55, 65304: 56, 65305: 57, 65306: 58, + 65307: 59, 65308: 60, 65309: 61, 65310: 62, 65312: 64, 65313: 65, 65314: 66, 65315: 67, 65316: 68, 65317: 69, 65318: 70, 65319: 71, 65320: 72, 65321: 73, 65322: 74, 65323: 75, + 65324: 76, 65325: 77, 65326: 78, 65327: 79, 65328: 80, 65329: 81, 65330: 82, 65331: 83, 65332: 84, 65333: 85, 65334: 86, 65335: 87, 65336: 88, 65337: 89, 65338: 90, 65339: 91, + 65340: 92, 65341: 93, 65342: 94, 65343: 95, 65344: 96, 65345: 97, 65346: 98, 65347: 99, 65348: 100, 65349: 101, 65350: 102, 65351: 103, 65352: 104, 65353: 105, 65354: 106, 65355: 107, + 65356: 108, 65357: 109, 65358: 110, 65359: 111, 65360: 112, 65361: 113, 65362: 114, 65363: 115, 65364: 116, 65365: 117, 65366: 118, 65367: 119, 65368: 120, 65369: 121, 65370: 122, 65371: 123, + 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0xab: // 171 + return &StringConverter{ + LangID: 171, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1026, 1027, 8218, 1107, 8222, 8230, 8224, 8225, 8364, 8240, 1033, 8249, 1034, 1036, 1035, 1039, + 1106, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 1113, 8250, 1114, 1116, 1115, 1119, + 160, 1038, 1118, 1032, 164, 1168, 166, 167, 1025, 169, 1028, 171, 172, 173, 174, 1031, + 176, 177, 1030, 1110, 1169, 181, 182, 183, 1105, 8470, 1108, 187, 1112, 1029, 1109, 1111, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1026: 128, 1027: 129, 8218: 130, 1107: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 8364: 136, 8240: 137, 1033: 138, 8249: 139, 1034: 140, 1036: 141, 1035: 142, 1039: 143, + 1106: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 152: 152, 8482: 153, 1113: 154, 8250: 155, 1114: 156, 1116: 157, 1115: 158, 1119: 159, + 160: 160, 1038: 161, 1118: 162, 1032: 163, 164: 164, 1168: 165, 166: 166, 167: 167, 1025: 168, 169: 169, 1028: 170, 171: 171, 172: 172, 173: 173, 174: 174, 1031: 175, + 176: 176, 177: 177, 1030: 178, 1110: 179, 1169: 180, 181: 181, 182: 182, 183: 183, 1105: 184, 8470: 185, 1108: 186, 187: 187, 1112: 188, 1029: 189, 1109: 190, 1111: 191, + 1040: 192, 1041: 193, 1042: 194, 1043: 195, 1044: 196, 1045: 197, 1046: 198, 1047: 199, 1048: 200, 1049: 201, 1050: 202, 1051: 203, 1052: 204, 1053: 205, 1054: 206, 1055: 207, + 1056: 208, 1057: 209, 1058: 210, 1059: 211, 1060: 212, 1061: 213, 1062: 214, 1063: 215, 1064: 216, 1065: 217, 1066: 218, 1067: 219, 1068: 220, 1069: 221, 1070: 222, 1071: 223, + 1072: 224, 1073: 225, 1074: 226, 1075: 227, 1076: 228, 1077: 229, 1078: 230, 1079: 231, 1080: 232, 1081: 233, 1082: 234, 1083: 235, 1084: 236, 1085: 237, 1086: 238, 1087: 239, + 1088: 240, 1089: 241, 1090: 242, 1091: 243, 1092: 244, 1093: 245, 1094: 246, 1095: 247, 1096: 248, 1097: 249, 1098: 250, 1099: 251, 1100: 252, 1101: 253, 1102: 254, 1103: 255, + 192: 65, 193: 65, 194: 65, 195: 65, 196: 65, 197: 65, 199: 67, 200: 69, 201: 69, 202: 69, 203: 69, 204: 73, 205: 73, 206: 73, 207: 73, 209: 78, + 210: 79, 211: 79, 212: 79, 213: 79, 214: 79, 216: 79, 217: 85, 218: 85, 219: 85, 220: 85, 221: 89, 224: 97, 225: 97, 226: 97, 227: 97, 228: 97, + 229: 97, 231: 99, 232: 101, 233: 101, 234: 101, 235: 101, 236: 105, 237: 105, 238: 105, 239: 105, 241: 110, 242: 111, 243: 111, 244: 111, 245: 111, 246: 111, + 248: 111, 249: 117, 250: 117, 251: 117, 252: 117, 253: 121, 255: 121, 256: 65, 257: 97, 258: 65, 259: 97, 260: 65, 261: 97, 262: 67, 263: 99, 264: 67, + 265: 99, 266: 67, 267: 99, 268: 67, 269: 99, 270: 68, 271: 100, 272: 68, 273: 100, 274: 69, 275: 101, 276: 69, 277: 101, 278: 69, 279: 101, 280: 69, + 281: 101, 282: 69, 283: 101, 284: 71, 285: 103, 286: 71, 287: 103, 288: 71, 289: 103, 290: 71, 291: 103, 292: 72, 293: 104, 294: 72, 295: 104, 296: 73, + 297: 105, 298: 73, 299: 105, 300: 73, 301: 105, 302: 73, 303: 105, 304: 73, 308: 74, 309: 106, 310: 75, 311: 107, 313: 76, 314: 108, 315: 76, 316: 108, + 317: 76, 318: 108, 321: 76, 322: 108, 323: 78, 324: 110, 325: 78, 326: 110, 327: 78, 328: 110, 332: 79, 333: 111, 334: 79, 335: 111, 336: 79, 337: 111, + 340: 82, 341: 114, 342: 82, 343: 114, 344: 82, 345: 114, 346: 83, 347: 115, 348: 83, 349: 115, 350: 83, 351: 115, 352: 83, 353: 115, 354: 84, 355: 116, + 356: 84, 357: 116, 358: 84, 359: 116, 360: 85, 361: 117, 362: 85, 363: 117, 364: 85, 365: 117, 366: 85, 367: 117, 368: 85, 369: 117, 370: 85, 371: 117, + 372: 87, 373: 119, 374: 89, 375: 121, 376: 89, 377: 90, 378: 122, 379: 90, 380: 122, 381: 90, 382: 122, 384: 98, 407: 73, 410: 108, 415: 79, 416: 79, + 417: 111, 427: 116, 430: 84, 431: 85, 432: 117, 461: 65, 462: 97, 463: 73, 464: 105, 465: 79, 466: 111, 467: 85, 468: 117, 469: 85, 470: 117, 471: 85, + 472: 117, 473: 85, 474: 117, 475: 85, 476: 117, 478: 65, 479: 97, 484: 71, 485: 103, 486: 71, 487: 103, 488: 75, 489: 107, 490: 79, 491: 111, 492: 79, + 493: 111, 496: 106, 8252: 33, 8592: 60, 8593: 94, 8594: 62, 8595: 118, 8596: 45, 8597: 166, 8616: 166, 8729: 149, 8730: 118, 8735: 76, 8962: 166, 9472: 45, 9474: 166, + 9484: 45, 9488: 172, 9492: 76, 9496: 45, 9500: 43, 9508: 43, 9516: 84, 9524: 43, 9532: 43, 9552: 61, 9553: 166, 9554: 45, 9555: 227, 9556: 227, 9557: 172, 9558: 172, + 9559: 172, 9560: 76, 9561: 76, 9562: 76, 9563: 45, 9564: 45, 9565: 45, 9566: 166, 9567: 166, 9568: 166, 9569: 166, 9570: 166, 9571: 166, 9572: 84, 9573: 84, 9574: 84, + 9575: 166, 9576: 166, 9577: 166, 9578: 43, 9579: 43, 9580: 43, 9600: 45, 9604: 45, 9608: 45, 9612: 166, 9616: 166, 9617: 45, 9618: 45, 9619: 45, 9632: 166, 9644: 45, + 9650: 94, 9658: 62, 9660: 161, 9668: 60, 9675: 48, 9688: 149, 9689: 48, 9786: 79, 9787: 79, 9788: 48, 9792: 43, 9794: 62, 9824: 166, 9827: 166, 9829: 166, 9830: 166, + 9834: 100, 9835: 100, 65281: 33, 65282: 34, 65283: 35, 65284: 36, 65285: 37, 65286: 38, 65287: 39, 65288: 40, 65289: 41, 65290: 42, 65291: 43, 65292: 44, 65293: 45, 65294: 46, + 65295: 47, 65296: 48, 65297: 49, 65298: 50, 65299: 51, 65300: 52, 65301: 53, 65302: 54, 65303: 55, 65304: 56, 65305: 57, 65306: 58, 65307: 59, 65308: 60, 65309: 61, 65310: 62, + 65312: 64, 65313: 65, 65314: 66, 65315: 67, 65316: 68, 65317: 69, 65318: 70, 65319: 71, 65320: 72, 65321: 73, 65322: 74, 65323: 75, 65324: 76, 65325: 77, 65326: 78, 65327: 79, + 65328: 80, 65329: 81, 65330: 82, 65331: 83, 65332: 84, 65333: 85, 65334: 86, 65335: 87, 65336: 88, 65337: 89, 65338: 90, 65339: 91, 65340: 92, 65341: 93, 65342: 94, 65343: 95, + 65344: 96, 65345: 97, 65346: 98, 65347: 99, 65348: 100, 65349: 101, 65350: 102, 65351: 103, 65352: 104, 65353: 105, 65354: 106, 65355: 107, 65356: 108, 65357: 109, 65358: 110, 65359: 111, + 65360: 112, 65361: 113, 65362: 114, 65363: 115, 65364: 116, 65365: 117, 65366: 118, 65367: 119, 65368: 120, 65369: 121, 65370: 122, 65371: 123, 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0xac: // 172 + return &StringConverter{ + LangID: 172, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 65535, 381, 65535, 65535, + 65535, 8216, 8217, 8220, 8221, 8226, 8211, 8213, 732, 8482, 353, 8250, 65535, 382, 65535, 376, + 65535, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 160, 8218: 130, 402: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 710: 136, 8240: 137, 352: 138, 8249: 139, 381: 141, 8216: 145, 8217: 146, 8220: 147, 8221: 148, + 8226: 149, 8211: 150, 8213: 151, 732: 152, 8482: 153, 353: 154, 8250: 155, 382: 157, 376: 159, 161: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, + 168: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, + 184: 184, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, + 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, 208: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 215: 215, + 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 221: 221, 222: 222, 223: 223, 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, + 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, 240: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 247: 247, + 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 253: 253, 254: 254, 255: 255, 63741: 131, + }, + } + case 0xad: // 173 + return &StringConverter{ + LangID: 173, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 8216, 8217, 8220, 8221, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 160, 65535, 162, 163, 164, 165, 8213, 167, 1025, 169, 1028, 8592, 172, 173, 174, 1031, + 176, 177, 8804, 8805, 180, 65535, 182, 733, 1105, 8470, 65535, 8594, 65535, 65535, 65535, 711, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 190, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 160: 160, 162: 162, 163: 163, 164: 164, 165: 165, 8213: 166, 167: 167, 1025: 168, 169: 169, 1028: 170, 8592: 171, + 172: 172, 173: 173, 174: 174, 1031: 175, 176: 176, 177: 177, 8804: 178, 8805: 179, 180: 180, 182: 182, 733: 183, 1105: 184, 8470: 185, 8594: 187, 711: 191, 1040: 192, + 1041: 193, 1042: 194, 1043: 195, 1044: 196, 1045: 197, 1046: 198, 1047: 199, 1048: 200, 1049: 201, 1050: 202, 1051: 203, 1052: 204, 1053: 205, 1054: 206, 1055: 207, 1056: 208, + 1057: 209, 1058: 210, 1059: 211, 1060: 212, 1061: 213, 1062: 214, 1063: 215, 1064: 216, 1065: 217, 1066: 218, 1067: 219, 1068: 220, 1069: 221, 1070: 222, 1071: 223, 1072: 224, + 1073: 225, 1074: 226, 1075: 227, 1076: 228, 1077: 229, 1078: 230, 1079: 231, 1080: 232, 1081: 233, 1082: 234, 1083: 235, 1084: 236, 1085: 237, 1086: 238, 1087: 239, 1088: 240, + 1089: 241, 1090: 242, 1091: 243, 1092: 244, 1093: 245, 1094: 246, 1095: 247, 1096: 248, 1097: 249, 1098: 250, 1099: 251, 1100: 252, 1101: 253, 1102: 254, 1103: 255, + }, + } + case 0xae: // 174 + return &StringConverter{ + LangID: 174, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 136, 8240, 138, 8249, 140, 141, 142, 143, + 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 154, 8250, 156, 157, 158, 159, + 160, 901, 902, 163, 164, 165, 166, 167, 168, 169, 63737, 171, 172, 173, 174, 8213, + 176, 177, 178, 179, 900, 181, 182, 183, 904, 905, 906, 187, 908, 189, 910, 911, + 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, + 928, 929, 63738, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, + 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, + 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 63739, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 8364: 128, 129: 129, 8218: 130, 402: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 136: 136, 8240: 137, 138: 138, 8249: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 152: 152, 8482: 153, 154: 154, 8250: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 901: 161, 902: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 63737: 170, 171: 171, 172: 172, 173: 173, 174: 174, 8213: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 900: 180, 181: 181, 182: 182, 183: 183, 904: 184, 905: 185, 906: 186, 187: 187, 908: 188, 189: 189, 910: 190, 911: 191, + 912: 192, 913: 193, 914: 194, 915: 195, 916: 196, 917: 197, 918: 198, 919: 199, 920: 200, 921: 201, 922: 202, 923: 203, 924: 204, 925: 205, 926: 206, 927: 207, + 928: 208, 929: 209, 63738: 210, 931: 211, 932: 212, 933: 213, 934: 214, 935: 215, 936: 216, 937: 217, 938: 218, 939: 219, 940: 220, 941: 221, 942: 222, 943: 223, + 944: 224, 945: 225, 946: 226, 947: 227, 948: 228, 949: 229, 950: 230, 951: 231, 952: 232, 953: 233, 954: 234, 955: 235, 956: 236, 957: 237, 958: 238, 959: 239, + 960: 240, 961: 241, 962: 242, 963: 243, 964: 244, 965: 245, 966: 246, 967: 247, 968: 248, 969: 249, 970: 250, 971: 251, 972: 252, 973: 253, 974: 254, 63739: 255, + 180: 47, 192: 65, 193: 65, 194: 65, 195: 65, 196: 65, 197: 65, 199: 67, 200: 69, 201: 69, 202: 69, 203: 69, 204: 73, 205: 73, 206: 73, 207: 73, + 209: 78, 210: 79, 211: 79, 212: 79, 213: 79, 214: 79, 216: 79, 217: 85, 218: 85, 219: 85, 220: 85, 221: 89, 224: 97, 225: 97, 226: 97, 227: 97, + 228: 97, 229: 97, 231: 99, 232: 101, 233: 101, 234: 101, 235: 101, 236: 105, 237: 105, 238: 105, 239: 105, 241: 110, 242: 111, 243: 111, 244: 111, 245: 111, + 246: 111, 248: 111, 249: 117, 250: 117, 251: 117, 252: 117, 253: 121, 255: 121, 256: 65, 257: 97, 258: 65, 259: 97, 260: 65, 261: 97, 262: 67, 263: 99, + 264: 67, 265: 99, 266: 67, 267: 99, 268: 67, 269: 99, 270: 68, 271: 100, 272: 68, 273: 100, 274: 69, 275: 101, 276: 69, 277: 101, 278: 69, 279: 101, + 280: 69, 281: 101, 282: 69, 283: 101, 284: 71, 285: 103, 286: 71, 287: 103, 288: 71, 289: 103, 290: 71, 291: 103, 292: 72, 293: 104, 294: 72, 295: 104, + 296: 73, 297: 105, 298: 73, 299: 105, 300: 73, 301: 105, 302: 73, 303: 105, 304: 73, 308: 74, 309: 106, 310: 75, 311: 107, 313: 76, 314: 108, 315: 76, + 316: 108, 317: 76, 318: 108, 321: 76, 322: 108, 323: 78, 324: 110, 325: 78, 326: 110, 327: 78, 328: 110, 332: 79, 333: 111, 334: 79, 335: 111, 336: 79, + 337: 111, 340: 82, 341: 114, 342: 82, 343: 114, 344: 82, 345: 114, 346: 83, 347: 115, 348: 83, 349: 115, 350: 83, 351: 115, 352: 83, 353: 115, 354: 84, + 355: 116, 356: 84, 357: 116, 358: 84, 359: 116, 360: 85, 361: 117, 362: 85, 363: 117, 364: 85, 365: 117, 366: 85, 367: 117, 368: 85, 369: 117, 370: 85, + 371: 117, 372: 87, 373: 119, 374: 89, 375: 121, 376: 89, 377: 90, 378: 122, 379: 90, 380: 122, 381: 90, 382: 122, 384: 98, 401: 131, 407: 73, 410: 108, + 415: 79, 416: 79, 417: 111, 427: 116, 430: 84, 431: 85, 432: 117, 461: 65, 462: 97, 463: 73, 464: 105, 465: 79, 466: 111, 467: 85, 468: 117, 469: 85, + 470: 117, 471: 85, 472: 117, 473: 85, 474: 117, 475: 85, 476: 117, 478: 65, 479: 97, 484: 71, 485: 103, 486: 71, 487: 103, 488: 75, 489: 107, 490: 79, + 491: 111, 492: 79, 493: 111, 496: 106, 781: 180, 894: 59, 8252: 33, 8592: 60, 8593: 94, 8594: 62, 8595: 118, 8596: 45, 8597: 166, 8616: 166, 8735: 76, 8962: 166, + 9472: 45, 9474: 166, 9484: 45, 9488: 172, 9492: 76, 9496: 45, 9500: 43, 9508: 43, 9516: 84, 9524: 43, 9532: 43, 9552: 61, 9553: 166, 9556: 45, 9559: 172, 9562: 76, + 9565: 45, 9568: 166, 9571: 166, 9574: 84, 9577: 166, 9580: 43, 9600: 45, 9604: 45, 9608: 45, 9617: 45, 9618: 45, 9619: 45, 9632: 166, 9644: 45, 9650: 94, 9658: 62, + 9660: 161, 9668: 60, 9675: 48, 9688: 149, 9689: 48, 9786: 79, 9787: 79, 9788: 48, 9792: 43, 9794: 62, 9824: 166, 9827: 166, 9829: 166, 9830: 166, 9834: 100, 9835: 100, + 65281: 33, 65282: 34, 65283: 35, 65284: 36, 65285: 37, 65286: 38, 65287: 39, 65288: 40, 65289: 41, 65290: 42, 65291: 43, 65292: 44, 65293: 45, 65294: 46, 65295: 47, 65296: 48, + 65297: 49, 65298: 50, 65299: 51, 65300: 52, 65301: 53, 65302: 54, 65303: 55, 65304: 56, 65305: 57, 65306: 58, 65307: 59, 65308: 60, 65309: 61, 65310: 62, 65312: 64, 65313: 65, + 65314: 66, 65315: 67, 65316: 68, 65317: 69, 65318: 70, 65319: 71, 65320: 72, 65321: 73, 65322: 74, 65323: 75, 65324: 76, 65325: 77, 65326: 78, 65327: 79, 65328: 80, 65329: 81, + 65330: 82, 65331: 83, 65332: 84, 65333: 85, 65334: 86, 65335: 87, 65336: 88, 65337: 89, 65338: 90, 65339: 91, 65340: 92, 65341: 93, 65342: 94, 65343: 95, 65344: 96, 65345: 97, + 65346: 98, 65347: 99, 65348: 100, 65349: 101, 65350: 102, 65351: 103, 65352: 104, 65353: 105, 65354: 106, 65355: 107, 65356: 108, 65357: 109, 65358: 110, 65359: 111, 65360: 112, 65361: 113, + 65362: 114, 65363: 115, 65364: 116, 65365: 117, 65366: 118, 65367: 119, 65368: 120, 65369: 121, 65370: 122, 65371: 123, 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0xaf: // 175 + return &StringConverter{ + LangID: 175, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 138, 8249, 140, 141, 142, 143, + 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 154, 8250, 156, 157, 158, 159, + 160, 161, 162, 163, 8362, 165, 166, 167, 168, 169, 215, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 247, 187, 188, 189, 190, 191, + 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, + 1472, 1473, 1474, 1475, 1520, 1521, 1522, 1523, 1524, 63629, 63630, 63631, 63632, 63633, 63634, 63635, + 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, + 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 63636, 63637, 8206, 8207, 63638, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 8364: 128, 129: 129, 8218: 130, 402: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 710: 136, 8240: 137, 138: 138, 8249: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 732: 152, 8482: 153, 154: 154, 8250: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 161: 161, 162: 162, 163: 163, 8362: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 215: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 247: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, + 1456: 192, 1457: 193, 1458: 194, 1459: 195, 1460: 196, 1461: 197, 1462: 198, 1463: 199, 1464: 200, 1465: 201, 1466: 202, 1467: 203, 1468: 204, 1469: 205, 1470: 206, 1471: 207, + 1472: 208, 1473: 209, 1474: 210, 1475: 211, 1520: 212, 1521: 213, 1522: 214, 1523: 215, 1524: 216, 63629: 217, 63630: 218, 63631: 219, 63632: 220, 63633: 221, 63634: 222, 63635: 223, + 1488: 224, 1489: 225, 1490: 226, 1491: 227, 1492: 228, 1493: 229, 1494: 230, 1495: 231, 1496: 232, 1497: 233, 1498: 234, 1499: 235, 1500: 236, 1501: 237, 1502: 238, 1503: 239, + 1504: 240, 1505: 241, 1506: 242, 1507: 243, 1508: 244, 1509: 245, 1510: 246, 1511: 247, 1512: 248, 1513: 249, 1514: 250, 63636: 251, 63637: 252, 8206: 253, 8207: 254, 63638: 255, + 164: 164, 401: 70, 65281: 33, 65282: 34, 65283: 35, 65284: 36, 65285: 37, 65286: 38, 65287: 39, 65288: 40, 65289: 41, 65290: 42, 65291: 43, 65292: 44, 65293: 45, 65294: 46, + 65295: 47, 65296: 48, 65297: 49, 65298: 50, 65299: 51, 65300: 52, 65301: 53, 65302: 54, 65303: 55, 65304: 56, 65305: 57, 65306: 58, 65307: 59, 65308: 60, 65309: 61, 65310: 62, + 65312: 64, 65313: 65, 65314: 66, 65315: 67, 65316: 68, 65317: 69, 65318: 70, 65319: 71, 65320: 72, 65321: 73, 65322: 74, 65323: 75, 65324: 76, 65325: 77, 65326: 78, 65327: 79, + 65328: 80, 65329: 81, 65330: 82, 65331: 83, 65332: 84, 65333: 85, 65334: 86, 65335: 87, 65336: 88, 65337: 89, 65338: 90, 65339: 91, 65340: 92, 65341: 93, 65342: 94, 65343: 95, + 65344: 96, 65345: 97, 65346: 98, 65347: 99, 65348: 100, 65349: 101, 65350: 102, 65351: 103, 65352: 104, 65353: 105, 65354: 106, 65355: 107, 65356: 108, 65357: 109, 65358: 110, 65359: 111, + 65360: 112, 65361: 113, 65362: 114, 65363: 115, 65364: 116, 65365: 117, 65366: 118, 65367: 119, 65368: 120, 65369: 121, 65370: 122, 65371: 123, 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0xb0: // 176 + return &StringConverter{ + LangID: 176, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 160, 8221, 162, 163, 164, 8222, 166, 167, 216, 169, 342, 171, 172, 173, 174, 198, + 176, 177, 178, 179, 8220, 181, 182, 183, 248, 185, 343, 187, 188, 189, 190, 230, + 260, 302, 256, 262, 196, 197, 280, 274, 268, 201, 377, 278, 290, 310, 298, 315, + 352, 323, 325, 211, 332, 213, 214, 215, 370, 321, 346, 362, 220, 379, 381, 223, + 261, 303, 257, 263, 228, 229, 281, 275, 269, 233, 378, 279, 291, 311, 299, 316, + 353, 324, 326, 243, 333, 245, 246, 247, 371, 322, 347, 363, 252, 380, 382, 8217, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 159, 160: 160, 8221: 161, 162: 162, 163: 163, 164: 164, 8222: 165, 166: 166, 167: 167, 216: 168, 169: 169, 342: 170, 171: 171, 172: 172, 173: 173, 174: 174, + 198: 175, 176: 176, 177: 177, 178: 178, 179: 179, 8220: 180, 181: 181, 182: 182, 183: 183, 248: 184, 185: 185, 343: 186, 187: 187, 188: 188, 189: 189, 190: 190, + 230: 191, 260: 192, 302: 193, 256: 194, 262: 195, 196: 196, 197: 197, 280: 198, 274: 199, 268: 200, 201: 201, 377: 202, 278: 203, 290: 204, 310: 205, 298: 206, + 315: 207, 352: 208, 323: 209, 325: 210, 211: 211, 332: 212, 213: 213, 214: 214, 215: 215, 370: 216, 321: 217, 346: 218, 362: 219, 220: 220, 379: 221, 381: 222, + 223: 223, 261: 224, 303: 225, 257: 226, 263: 227, 228: 228, 229: 229, 281: 230, 275: 231, 269: 232, 233: 233, 378: 234, 279: 235, 291: 236, 311: 237, 299: 238, + 316: 239, 353: 240, 324: 241, 326: 242, 243: 243, 333: 244, 245: 245, 246: 246, 247: 247, 371: 248, 322: 249, 347: 250, 363: 251, 252: 252, 380: 253, 382: 254, + 8217: 255, + }, + } + case 0xb1: // 177 + return &StringConverter{ + LangID: 177, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 141, 142, 143, + 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, 157, 158, 376, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 286, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 304, 350, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 287, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 305, 351, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 8364: 128, 129: 129, 8218: 130, 402: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 710: 136, 8240: 137, 352: 138, 8249: 139, 338: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 732: 152, 8482: 153, 353: 154, 8250: 155, 339: 156, 157: 157, 158: 158, 376: 159, + 160: 160, 161: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, + 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, + 286: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 304: 221, 350: 222, 223: 223, + 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, + 287: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 305: 253, 351: 254, 255: 255, + 221: 89, 253: 121, 256: 65, 257: 97, 258: 65, 259: 97, 260: 65, 261: 97, 262: 67, 263: 99, 264: 67, 265: 99, 266: 67, 267: 99, 268: 67, 269: 99, + 270: 68, 271: 100, 272: 68, 273: 100, 274: 69, 275: 101, 276: 69, 277: 101, 278: 69, 279: 101, 280: 69, 281: 101, 282: 69, 283: 101, 284: 71, 285: 103, + 288: 71, 289: 103, 290: 71, 291: 103, 292: 72, 293: 104, 294: 72, 295: 104, 296: 73, 297: 105, 298: 73, 299: 105, 300: 73, 301: 105, 302: 73, 303: 105, + 308: 74, 309: 106, 310: 75, 311: 107, 313: 76, 314: 108, 315: 76, 316: 108, 317: 76, 318: 108, 321: 76, 322: 108, 323: 78, 324: 110, 325: 78, 326: 110, + 327: 78, 328: 110, 332: 79, 333: 111, 334: 79, 335: 111, 336: 79, 337: 111, 340: 82, 341: 114, 342: 82, 343: 114, 344: 82, 345: 114, 346: 83, 347: 115, + 348: 83, 349: 115, 354: 84, 355: 116, 356: 84, 357: 116, 358: 84, 359: 116, 360: 85, 361: 117, 362: 85, 363: 117, 364: 85, 365: 117, 366: 85, 367: 117, + 368: 85, 369: 117, 370: 85, 371: 117, 372: 87, 373: 119, 374: 89, 375: 121, 377: 90, 378: 122, 379: 90, 380: 122, 381: 90, 382: 122, 384: 98, 393: 68, + 401: 131, 407: 73, 410: 108, 415: 79, 416: 79, 417: 111, 427: 116, 430: 84, 431: 85, 432: 117, 438: 122, 448: 124, 451: 33, 461: 65, 462: 97, 463: 73, + 464: 105, 465: 79, 466: 111, 467: 85, 468: 117, 469: 85, 470: 117, 471: 85, 472: 117, 473: 85, 474: 117, 475: 85, 476: 117, 478: 65, 479: 97, 484: 71, + 485: 103, 486: 71, 487: 103, 488: 75, 489: 107, 490: 79, 491: 111, 492: 79, 493: 111, 496: 106, 609: 103, 697: 39, 698: 34, 699: 145, 700: 39, 708: 94, + 711: 94, 712: 39, 713: 175, 714: 180, 715: 96, 717: 95, 728: 94, 729: 39, 730: 176, 731: 184, 733: 168, 768: 96, 769: 180, 770: 94, 771: 152, 772: 175, + 773: 175, 774: 136, 775: 183, 776: 168, 778: 167, 780: 136, 782: 168, 807: 184, 817: 95, 818: 95, 946: 223, 956: 181, 1211: 104, 1417: 58, 1642: 37, 8192: 32, + 8193: 32, 8194: 32, 8195: 32, 8196: 32, 8197: 32, 8198: 32, 8208: 45, 8209: 45, 8228: 149, 8242: 39, 8243: 168, 8245: 96, 8252: 33, 8260: 47, 8304: 176, 8308: 52, + 8309: 53, 8310: 54, 8311: 55, 8312: 56, 8320: 176, 8321: 48, 8322: 178, 8323: 179, 8324: 52, 8325: 53, 8326: 54, 8327: 55, 8328: 56, 8329: 57, 8356: 163, 8450: 67, + 8455: 69, 8458: 103, 8459: 72, 8460: 72, 8461: 72, 8462: 104, 8464: 73, 8465: 73, 8466: 76, 8467: 108, 8469: 78, 8472: 80, 8473: 80, 8474: 81, 8475: 82, 8476: 82, + 8477: 82, 8484: 90, 8488: 90, 8490: 75, 8491: 197, 8492: 66, 8493: 67, 8494: 101, 8495: 101, 8496: 69, 8497: 70, 8499: 77, 8500: 111, 8592: 139, 8593: 94, 8594: 155, + 8595: 118, 8596: 45, 8597: 124, 8616: 124, 8709: 216, 8722: 45, 8723: 177, 8725: 47, 8726: 92, 8727: 42, 8728: 176, 8729: 149, 8735: 76, 8739: 124, 8758: 58, 8764: 126, + 8810: 171, 8811: 187, 8901: 183, 8962: 166, 8963: 94, 9001: 60, 9002: 62, 9472: 166, 9474: 45, 9484: 45, 9488: 172, 9492: 76, 9496: 45, 9500: 43, 9508: 43, 9516: 84, + 9524: 43, 9532: 43, 9552: 61, 9553: 166, 9556: 45, 9559: 172, 9562: 76, 9565: 45, 9568: 166, 9571: 166, 9574: 84, 9577: 166, 9580: 43, 9600: 45, 9604: 45, 9608: 45, + 9617: 45, 9618: 45, 9619: 45, 9632: 166, 9644: 45, 9650: 94, 9658: 62, 9660: 161, 9668: 60, 9675: 48, 9688: 149, 9689: 48, 9786: 79, 9787: 79, 9788: 48, 9792: 43, + 9794: 62, 9824: 166, 9827: 166, 9829: 166, 9830: 166, 9834: 100, 9835: 100, 10072: 124, 10075: 145, 10076: 146, 10077: 147, 10078: 148, 12288: 32, 12296: 60, 12297: 62, 12298: 171, + 12299: 187, 12314: 91, 12315: 61, 12317: 34, 12318: 34, 12319: 132, 12539: 183, 12540: 151, 65281: 33, 65282: 34, 65283: 35, 65284: 36, 65285: 37, 65286: 38, 65287: 39, 65288: 40, + 65289: 41, 65290: 42, 65291: 43, 65292: 44, 65293: 45, 65294: 46, 65295: 47, 65296: 48, 65297: 49, 65298: 50, 65299: 51, 65300: 52, 65301: 53, 65302: 54, 65303: 55, 65304: 56, + 65305: 57, 65306: 58, 65307: 59, 65308: 60, 65309: 61, 65310: 62, 65312: 64, 65313: 65, 65314: 66, 65315: 67, 65316: 68, 65317: 69, 65318: 70, 65319: 71, 65320: 72, 65321: 73, + 65322: 74, 65323: 75, 65324: 76, 65325: 77, 65326: 78, 65327: 79, 65328: 80, 65329: 81, 65330: 82, 65331: 83, 65332: 84, 65333: 85, 65334: 86, 65335: 87, 65336: 88, 65337: 89, + 65338: 90, 65339: 91, 65340: 92, 65341: 93, 65342: 94, 65343: 95, 65344: 96, 65345: 97, 65346: 98, 65347: 99, 65348: 100, 65349: 101, 65350: 102, 65351: 103, 65352: 104, 65353: 105, + 65354: 106, 65355: 107, 65356: 108, 65357: 109, 65358: 110, 65359: 111, 65360: 112, 65361: 113, 65362: 114, 65363: 115, 65364: 116, 65365: 117, 65366: 118, 65367: 119, 65368: 120, 65369: 121, + 65370: 122, 65371: 123, 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0xb2: // 178 + return &StringConverter{ + LangID: 178, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 141, 381, 143, + 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, 157, 382, 376, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 8364: 128, 129: 129, 8218: 130, 402: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 710: 136, 8240: 137, 352: 138, 8249: 139, 338: 140, 141: 141, 381: 142, 143: 143, + 144: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 732: 152, 8482: 153, 353: 154, 8250: 155, 339: 156, 157: 157, 382: 158, 376: 159, + 160: 160, 161: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, + 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, + 208: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 221: 221, 222: 222, 223: 223, + 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, + 240: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 253: 253, 254: 254, 255: 255, + 256: 65, 257: 97, 258: 65, 259: 97, 260: 65, 261: 97, 262: 67, 263: 99, 264: 67, 265: 99, 266: 67, 267: 99, 268: 67, 269: 99, 270: 68, 271: 100, + 272: 208, 273: 100, 274: 69, 275: 101, 276: 69, 277: 101, 278: 69, 279: 101, 280: 69, 281: 101, 282: 69, 283: 101, 284: 71, 285: 103, 286: 71, 287: 103, + 288: 71, 289: 103, 290: 71, 291: 103, 292: 72, 293: 104, 294: 72, 295: 104, 296: 73, 297: 105, 298: 73, 299: 105, 300: 73, 301: 105, 302: 73, 303: 105, + 304: 73, 305: 105, 308: 74, 309: 106, 310: 75, 311: 107, 313: 76, 314: 108, 315: 76, 316: 108, 317: 76, 318: 108, 321: 76, 322: 108, 323: 78, 324: 110, + 325: 78, 326: 110, 327: 78, 328: 110, 332: 79, 333: 111, 334: 79, 335: 111, 336: 79, 337: 111, 340: 82, 341: 114, 342: 82, 343: 114, 344: 82, 345: 114, + 346: 83, 347: 115, 348: 83, 349: 115, 350: 83, 351: 115, 354: 84, 355: 116, 356: 84, 357: 116, 358: 84, 359: 116, 360: 85, 361: 117, 362: 85, 363: 117, + 364: 85, 365: 117, 366: 85, 367: 117, 368: 85, 369: 117, 370: 85, 371: 117, 372: 87, 373: 119, 374: 89, 375: 121, 377: 90, 378: 122, 379: 90, 380: 122, + 384: 98, 393: 208, 401: 131, 407: 73, 410: 108, 415: 79, 416: 79, 417: 111, 427: 116, 430: 84, 431: 85, 432: 117, 438: 122, 448: 124, 451: 33, 461: 65, + 462: 97, 463: 73, 464: 105, 465: 79, 466: 111, 467: 85, 468: 117, 469: 85, 470: 117, 471: 85, 472: 117, 473: 85, 474: 117, 475: 85, 476: 117, 478: 65, + 479: 97, 484: 71, 485: 103, 486: 71, 487: 103, 488: 75, 489: 107, 490: 79, 491: 111, 492: 79, 493: 111, 496: 106, 609: 103, 697: 39, 698: 34, 700: 39, + 708: 94, 712: 39, 713: 175, 714: 180, 715: 96, 717: 95, 730: 176, 768: 96, 769: 180, 770: 94, 771: 126, 772: 175, 773: 175, 776: 168, 778: 176, 782: 34, + 807: 184, 817: 95, 818: 95, 894: 59, 915: 71, 920: 84, 931: 83, 934: 70, 937: 79, 945: 97, 946: 223, 948: 100, 949: 101, 956: 181, 960: 112, 963: 115, + 964: 116, 966: 102, 1211: 104, 1417: 58, 1642: 37, 8192: 32, 8193: 32, 8194: 32, 8195: 32, 8196: 32, 8197: 32, 8198: 32, 8208: 45, 8209: 45, 8215: 61, 8228: 183, + 8242: 39, 8245: 96, 8260: 47, 8304: 176, 8308: 52, 8309: 53, 8310: 54, 8311: 55, 8312: 56, 8319: 110, 8320: 48, 8321: 49, 8322: 50, 8323: 51, 8324: 52, 8325: 53, + 8326: 54, 8327: 55, 8328: 56, 8329: 57, 8353: 162, 8356: 163, 8359: 80, 8450: 67, 8455: 69, 8458: 103, 8459: 72, 8460: 72, 8461: 72, 8462: 104, 8464: 73, 8465: 73, + 8466: 76, 8467: 108, 8469: 78, 8472: 80, 8473: 80, 8474: 81, 8475: 82, 8476: 82, 8477: 82, 8484: 90, 8488: 90, 8490: 75, 8491: 197, 8492: 66, 8493: 67, 8494: 101, + 8495: 101, 8496: 69, 8497: 70, 8499: 77, 8500: 111, 8709: 216, 8722: 45, 8723: 177, 8725: 47, 8726: 92, 8727: 42, 8728: 176, 8729: 183, 8730: 118, 8734: 56, 8739: 124, + 8745: 110, 8758: 58, 8764: 126, 8776: 152, 8801: 61, 8804: 61, 8805: 61, 8810: 171, 8811: 187, 8901: 183, 8962: 166, 8963: 94, 8976: 172, 8992: 40, 8993: 41, 9001: 60, + 9002: 62, 9472: 45, 9474: 166, 9484: 43, 9488: 43, 9492: 43, 9496: 43, 9500: 43, 9508: 166, 9516: 45, 9524: 45, 9532: 43, 9552: 45, 9553: 166, 9554: 43, 9555: 43, + 9556: 43, 9557: 43, 9558: 43, 9559: 43, 9560: 43, 9561: 43, 9562: 43, 9563: 43, 9564: 43, 9565: 43, 9566: 166, 9567: 166, 9568: 166, 9569: 166, 9570: 166, 9571: 166, + 9572: 45, 9573: 45, 9574: 45, 9575: 45, 9576: 45, 9577: 45, 9578: 43, 9579: 43, 9580: 43, 9600: 175, 9604: 95, 9608: 166, 9612: 166, 9616: 166, 9617: 166, 9618: 166, + 9619: 166, 9632: 166, 9788: 164, 10072: 124, 12288: 32, 12296: 60, 12297: 62, 12298: 171, 12299: 187, 12314: 91, 12315: 93, 12539: 183, 65281: 33, 65282: 34, 65283: 35, 65284: 36, + 65285: 37, 65286: 38, 65287: 39, 65288: 40, 65289: 41, 65290: 42, 65291: 43, 65292: 44, 65293: 45, 65294: 46, 65295: 47, 65296: 48, 65297: 49, 65298: 50, 65299: 51, 65300: 52, + 65301: 53, 65302: 54, 65303: 55, 65304: 56, 65305: 57, 65306: 58, 65307: 59, 65308: 60, 65309: 61, 65310: 62, 65312: 64, 65313: 65, 65314: 66, 65315: 67, 65316: 68, 65317: 69, + 65318: 70, 65319: 71, 65320: 72, 65321: 73, 65322: 74, 65323: 75, 65324: 76, 65325: 77, 65326: 78, 65327: 79, 65328: 80, 65329: 81, 65330: 82, 65331: 83, 65332: 84, 65333: 85, + 65334: 86, 65335: 87, 65336: 88, 65337: 89, 65338: 90, 65339: 91, 65340: 92, 65341: 93, 65342: 94, 65343: 95, 65344: 96, 65345: 97, 65346: 98, 65347: 99, 65348: 100, 65349: 101, + 65350: 102, 65351: 103, 65352: 104, 65353: 105, 65354: 106, 65355: 107, 65356: 108, 65357: 109, 65358: 110, 65359: 111, 65360: 112, 65361: 113, 65362: 114, 65363: 115, 65364: 116, 65365: 117, + 65366: 118, 65367: 119, 65368: 120, 65369: 121, 65370: 122, 65371: 123, 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0xb3: // 179 + return &StringConverter{ + LangID: 179, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8364, 129, 8218, 131, 8222, 8230, 8224, 8225, 136, 8240, 138, 8249, 140, 168, 711, 184, + 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 154, 8250, 156, 175, 731, 159, + 160, 63740, 162, 163, 164, 63741, 166, 167, 216, 169, 342, 171, 172, 173, 174, 198, + 176, 177, 178, 179, 180, 181, 182, 183, 248, 185, 343, 187, 188, 189, 190, 230, + 260, 302, 256, 262, 196, 197, 280, 274, 268, 201, 377, 278, 290, 310, 298, 315, + 352, 323, 325, 211, 332, 213, 214, 215, 370, 321, 346, 362, 220, 379, 381, 223, + 261, 303, 257, 263, 228, 229, 281, 275, 269, 233, 378, 279, 291, 311, 299, 316, + 353, 324, 326, 243, 333, 245, 246, 247, 371, 322, 347, 363, 252, 380, 382, 729, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 8364: 128, 129: 129, 8218: 130, 131: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 136: 136, 8240: 137, 138: 138, 8249: 139, 140: 140, 168: 141, 711: 142, 184: 143, + 144: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 152: 152, 8482: 153, 154: 154, 8250: 155, 156: 156, 175: 157, 731: 158, 159: 159, + 160: 160, 63740: 161, 162: 162, 163: 163, 164: 164, 63741: 165, 166: 166, 167: 167, 216: 168, 169: 169, 342: 170, 171: 171, 172: 172, 173: 173, 174: 174, 198: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 248: 184, 185: 185, 343: 186, 187: 187, 188: 188, 189: 189, 190: 190, 230: 191, + 260: 192, 302: 193, 256: 194, 262: 195, 196: 196, 197: 197, 280: 198, 274: 199, 268: 200, 201: 201, 377: 202, 278: 203, 290: 204, 310: 205, 298: 206, 315: 207, + 352: 208, 323: 209, 325: 210, 211: 211, 332: 212, 213: 213, 214: 214, 215: 215, 370: 216, 321: 217, 346: 218, 362: 219, 220: 220, 379: 221, 381: 222, 223: 223, + 261: 224, 303: 225, 257: 226, 263: 227, 228: 228, 229: 229, 281: 230, 275: 231, 269: 232, 233: 233, 378: 234, 279: 235, 291: 236, 311: 237, 299: 238, 316: 239, + 353: 240, 324: 241, 326: 242, 243: 243, 333: 244, 245: 245, 246: 246, 247: 247, 371: 248, 322: 249, 347: 250, 363: 251, 252: 252, 380: 253, 382: 254, 729: 255, + 65281: 33, 65282: 34, 65283: 35, 65284: 36, 65285: 37, 65286: 38, 65287: 39, 65288: 40, 65289: 41, 65290: 42, 65291: 43, 65292: 44, 65293: 45, 65294: 46, 65295: 47, 65296: 48, + 65297: 49, 65298: 50, 65299: 51, 65300: 52, 65301: 53, 65302: 54, 65303: 55, 65304: 56, 65305: 57, 65306: 58, 65307: 59, 65308: 60, 65309: 61, 65310: 62, 65312: 64, 65313: 65, + 65314: 66, 65315: 67, 65316: 68, 65317: 69, 65318: 70, 65319: 71, 65320: 72, 65321: 73, 65322: 74, 65323: 75, 65324: 76, 65325: 77, 65326: 78, 65327: 79, 65328: 80, 65329: 81, + 65330: 82, 65331: 83, 65332: 84, 65333: 85, 65334: 86, 65335: 87, 65336: 88, 65337: 89, 65338: 90, 65339: 91, 65340: 92, 65341: 93, 65342: 94, 65343: 95, 65344: 96, 65345: 97, + 65346: 98, 65347: 99, 65348: 100, 65349: 101, 65350: 102, 65351: 103, 65352: 104, 65353: 105, 65354: 106, 65355: 107, 65356: 108, 65357: 109, 65358: 110, 65359: 111, 65360: 112, 65361: 113, + 65362: 114, 65363: 115, 65364: 116, 65365: 117, 65366: 118, 65367: 119, 65368: 120, 65369: 121, 65370: 122, 65371: 123, 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0xb4: // 180 + return &StringConverter{ + LangID: 180, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 123, 224, 225, 227, 229, 231, 241, 196, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 126, 220, 36, 42, 41, 59, 94, + 45, 47, 194, 91, 192, 193, 195, 197, 199, 209, 246, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 167, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 223, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 64, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 228, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 166, 242, 243, 245, + 252, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 125, 249, 250, 255, + 214, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 92, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 93, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 123: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 196: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 126: 89, 220: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 91: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 246: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 167: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 223: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 64: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 228: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 166: 204, 242: 205, 243: 206, 245: 207, 252: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 125: 220, 249: 221, 250: 222, 255: 223, 214: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 92: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 93: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 95, + 8764: 89, 376: 232, + }, + } + case 0xb5: // 181 + return &StringConverter{ + LangID: 181, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 123, 225, 227, 229, 92, 241, 176, 46, 60, 40, 43, 33, + 38, 93, 234, 235, 125, 237, 238, 239, 126, 223, 233, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 242, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 249, 58, 163, 167, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 91, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 236, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 35, 165, 183, 169, 64, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 224, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 166, 243, 245, + 232, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 96, 250, 255, + 231, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 123: 68, 225: 69, 227: 70, 229: 71, 92: 72, 241: 73, 176: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 93: 81, + 234: 82, 235: 83, 125: 84, 237: 85, 238: 86, 239: 87, 126: 88, 223: 89, 233: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 242: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 249: 121, 58: 122, 163: 123, 167: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 91: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 236: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 35: 177, + 165: 178, 183: 179, 169: 180, 64: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 224: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 166: 205, 243: 206, 245: 207, 232: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 96: 221, 250: 222, 255: 223, 231: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 221, 8248: 95, + 8764: 88, 376: 232, + }, + } + case 0xb6: // 182 + return &StringConverter{ + LangID: 182, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 125, 231, 241, 35, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 164, 197, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 36, 199, 209, 248, 44, 37, 95, 62, 63, + 166, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 198, 216, 39, 61, 34, + 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 123, 184, 91, 93, + 181, 252, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 230, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 229, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 126, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 125: 71, 231: 72, 241: 73, 35: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 164: 90, 197: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 36: 103, 199: 104, 209: 105, 248: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 166: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 198: 123, 216: 124, 39: 125, 61: 126, 34: 127, 64: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 123: 156, 184: 157, 91: 158, 93: 159, 181: 160, 252: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 230: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 229: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 126: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0xb7: // 183 + return &StringConverter{ + LangID: 183, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 123, 224, 225, 227, 125, 231, 241, 167, 46, 60, 40, 43, 33, + 38, 96, 234, 235, 232, 237, 238, 239, 236, 223, 164, 197, 42, 41, 59, 94, + 45, 47, 194, 35, 192, 193, 195, 36, 199, 209, 246, 44, 37, 95, 62, 63, + 248, 92, 202, 203, 200, 205, 206, 207, 204, 233, 58, 196, 214, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 93, + 181, 252, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 91, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 228, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 166, 242, 243, 245, + 229, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 126, 249, 250, 255, + 201, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 64, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 123: 67, 224: 68, 225: 69, 227: 70, 125: 71, 231: 72, 241: 73, 167: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 96: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 164: 90, 197: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 35: 99, 192: 100, 193: 101, 195: 102, 36: 103, 199: 104, 209: 105, 246: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 92: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 233: 121, 58: 122, 196: 123, 214: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 93: 159, 181: 160, 252: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 91: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 228: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 166: 204, 242: 205, 243: 206, 245: 207, 229: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 126: 220, 249: 221, 250: 222, 255: 223, 201: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 64: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0xb8: // 184 + return &StringConverter{ + LangID: 184, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 355, 225, 259, 269, 231, 263, 91, 46, 60, 40, 43, 33, + 38, 233, 281, 235, 367, 237, 238, 318, 314, 223, 93, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 733, 193, 258, 268, 199, 262, 124, 44, 37, 95, 62, 63, + 711, 201, 280, 203, 366, 205, 206, 317, 313, 96, 58, 35, 64, 39, 61, 34, + 728, 97, 98, 99, 100, 101, 102, 103, 104, 105, 347, 328, 273, 253, 345, 351, + 730, 106, 107, 108, 109, 110, 111, 112, 113, 114, 322, 324, 353, 184, 731, 164, + 261, 126, 115, 116, 117, 118, 119, 120, 121, 122, 346, 327, 272, 221, 344, 350, + 729, 260, 380, 354, 379, 167, 382, 378, 381, 377, 321, 323, 352, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 341, 243, 337, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 282, 369, 252, 357, 250, 283, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 271, 212, 214, 340, 211, 336, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 270, 368, 220, 356, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 355: 68, 225: 69, 259: 70, 269: 71, 231: 72, 263: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 281: 82, 235: 83, 367: 84, 237: 85, 238: 86, 318: 87, 314: 88, 223: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 733: 100, 193: 101, 258: 102, 268: 103, 199: 104, 262: 105, 124: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 711: 112, 201: 113, + 280: 114, 203: 115, 366: 116, 205: 117, 206: 118, 317: 119, 313: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 728: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 347: 138, 328: 139, 273: 140, 253: 141, 345: 142, 351: 143, 730: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 322: 154, 324: 155, 353: 156, 184: 157, 731: 158, 164: 159, 261: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 346: 170, 327: 171, 272: 172, 221: 173, 344: 174, 350: 175, 729: 176, 260: 177, + 380: 178, 354: 179, 379: 180, 167: 181, 382: 182, 378: 183, 381: 184, 377: 185, 321: 186, 323: 187, 352: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 341: 205, 243: 206, 337: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 282: 218, 369: 219, 252: 220, 357: 221, 250: 222, 283: 223, 92: 224, 65535: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 271: 234, 212: 235, 214: 236, 340: 237, 211: 238, 336: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 270: 250, 368: 251, 220: 252, 356: 253, 218: 254, 159: 255, 176: 144, + }, + } + case 0xb9: // 185 + return &StringConverter{ + LangID: 185, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 1106, 1107, 1105, 1108, 1109, 1110, 1111, 1112, 91, 46, 60, 40, 43, 33, + 38, 1113, 1114, 1115, 1116, 1118, 1119, 1066, 8470, 1026, 93, 36, 42, 41, 59, 94, + 45, 47, 1027, 1025, 1028, 1029, 1030, 1031, 1032, 1033, 124, 44, 37, 95, 62, 63, + 1034, 1035, 1036, 173, 1038, 1039, 1102, 1072, 1073, 96, 58, 35, 64, 39, 61, 34, + 1094, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1076, 1077, 1092, 1075, 1093, 1080, + 1081, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1082, 1083, 1084, 1085, 1086, 1087, + 1103, 126, 115, 116, 117, 118, 119, 120, 121, 122, 1088, 1089, 1090, 1091, 1078, 1074, + 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1061, 1048, 1049, 1050, 1051, 1052, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1053, 1054, 1055, 1071, 1056, 1057, + 92, 167, 83, 84, 85, 86, 87, 88, 89, 90, 1058, 1059, 1046, 1042, 1068, 1067, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1047, 1064, 1069, 1065, 1063, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 1106: 66, 1107: 67, 1105: 68, 1108: 69, 1109: 70, 1110: 71, 1111: 72, 1112: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 1113: 81, + 1114: 82, 1115: 83, 1116: 84, 1118: 85, 1119: 86, 1066: 87, 8470: 88, 1026: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 1027: 98, 1025: 99, 1028: 100, 1029: 101, 1030: 102, 1031: 103, 1032: 104, 1033: 105, 124: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 1034: 112, 1035: 113, + 1036: 114, 173: 115, 1038: 116, 1039: 117, 1102: 118, 1072: 119, 1073: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 1094: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1076: 138, 1077: 139, 1092: 140, 1075: 141, 1093: 142, 1080: 143, 1081: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1082: 154, 1083: 155, 1084: 156, 1085: 157, 1086: 158, 1087: 159, 1103: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 1088: 170, 1089: 171, 1090: 172, 1091: 173, 1078: 174, 1074: 175, 1100: 176, 1099: 177, + 1079: 178, 1096: 179, 1101: 180, 1097: 181, 1095: 182, 1098: 183, 1070: 184, 1040: 185, 1041: 186, 1062: 187, 1044: 188, 1045: 189, 1060: 190, 1043: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 1061: 202, 1048: 203, 1049: 204, 1050: 205, 1051: 206, 1052: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 1053: 218, 1054: 219, 1055: 220, 1071: 221, 1056: 222, 1057: 223, 92: 224, 167: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 1058: 234, 1059: 235, 1046: 236, 1042: 237, 1068: 238, 1067: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 1047: 250, 1064: 251, 1069: 252, 1065: 253, 1063: 254, 159: 255, + }, + } + case 0xba: // 186 + return &StringConverter{ + LangID: 186, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 64, 225, 227, 229, 92, 241, 176, 46, 60, 40, 43, 33, + 38, 123, 234, 235, 125, 237, 238, 239, 236, 223, 167, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 249, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 181, 58, 163, 224, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 91, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 96, 168, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 35, 165, 183, 169, 93, 182, 188, 189, 190, 172, 124, 175, 126, 180, 215, + 233, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 232, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 166, 250, 255, + 231, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 64: 68, 225: 69, 227: 70, 229: 71, 92: 72, 241: 73, 176: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 123: 81, + 234: 82, 235: 83, 125: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 167: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 249: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 181: 121, 58: 122, 163: 123, 224: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 91: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 96: 160, 168: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 35: 177, + 165: 178, 183: 179, 169: 180, 93: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 126: 189, 180: 190, 215: 191, 233: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 232: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 166: 221, 250: 222, 255: 223, 231: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0xbb: // 187 + return &StringConverter{ + LangID: 187, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 162, 46, 60, 40, 43, 124, + 38, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 33, 36, 42, 41, 59, 172, + 45, 47, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 166, 44, 37, 95, 62, 63, + 65535, 1514, 65535, 65535, 160, 65535, 65535, 65535, 819, 96, 58, 35, 64, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 65535, 65535, 65535, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 65535, 184, 65535, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 65535, 65535, 65535, 174, + 94, 163, 165, 183, 169, 167, 182, 188, 189, 190, 91, 93, 175, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 65535, 65535, 65535, 65535, 65535, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 65535, 65535, 65535, 65535, 65535, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 65535, 65535, 65535, 65535, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 1488: 65, + 1489: 66, 1490: 67, 1491: 68, 1492: 69, 1493: 70, 1494: 71, 1495: 72, 1496: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 1497: 81, + 1498: 82, 1499: 83, 1500: 84, 1501: 85, 1502: 86, 1503: 87, 1504: 88, 1505: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 1506: 98, 1507: 99, 1508: 100, 1509: 101, 1510: 102, 1511: 103, 1512: 104, 1513: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 65535: 254, 1514: 113, + 160: 116, 819: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, + 104: 136, 105: 137, 171: 138, 187: 139, 177: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 184: 157, + 164: 159, 181: 160, 126: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 174: 175, 94: 176, 163: 177, 165: 178, 183: 179, + 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 91: 186, 93: 187, 175: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, 66: 194, 67: 195, + 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 125: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, + 82: 217, 185: 218, 92: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 48: 240, 49: 241, 50: 242, + 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 159: 255, + }, + } + case 0xbc: // 188 + return &StringConverter{ + LangID: 188, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 1106, 1107, 1105, 1108, 1109, 1110, 1111, 1112, 91, 46, 60, 40, 43, 33, + 38, 1113, 1114, 1115, 1116, 1118, 1119, 1066, 8470, 1026, 93, 36, 42, 41, 59, 94, + 45, 47, 1027, 1025, 1028, 1029, 1030, 1031, 1032, 1033, 166, 44, 37, 95, 62, 63, + 1034, 1035, 1036, 173, 1038, 1039, 1102, 1072, 1073, 96, 58, 35, 64, 39, 61, 34, + 1094, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1076, 1077, 1092, 1075, 1093, 1080, + 1081, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1082, 1083, 1084, 1085, 1086, 1087, + 1103, 126, 115, 116, 117, 118, 119, 120, 121, 122, 1088, 1089, 1090, 1091, 1078, 1074, + 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1061, 1048, 1049, 1050, 1051, 1052, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1053, 1054, 1055, 1071, 1056, 1057, + 92, 164, 83, 84, 85, 86, 87, 88, 89, 90, 1058, 1059, 1046, 1042, 1068, 1067, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1047, 1064, 1069, 1065, 1063, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 1106: 66, 1107: 67, 1105: 68, 1108: 69, 1109: 70, 1110: 71, 1111: 72, 1112: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 1113: 81, + 1114: 82, 1115: 83, 1116: 84, 1118: 85, 1119: 86, 1066: 87, 8470: 88, 1026: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 1027: 98, 1025: 99, 1028: 100, 1029: 101, 1030: 102, 1031: 103, 1032: 104, 1033: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 1034: 112, 1035: 113, + 1036: 114, 173: 115, 1038: 116, 1039: 117, 1102: 118, 1072: 119, 1073: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 1094: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1076: 138, 1077: 139, 1092: 140, 1075: 141, 1093: 142, 1080: 143, 1081: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1082: 154, 1083: 155, 1084: 156, 1085: 157, 1086: 158, 1087: 159, 1103: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 1088: 170, 1089: 171, 1090: 172, 1091: 173, 1078: 174, 1074: 175, 1100: 176, 1099: 177, + 1079: 178, 1096: 179, 1101: 180, 1097: 181, 1095: 182, 1098: 183, 1070: 184, 1040: 185, 1041: 186, 1062: 187, 1044: 188, 1045: 189, 1060: 190, 1043: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 1061: 202, 1048: 203, 1049: 204, 1050: 205, 1051: 206, 1052: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 1053: 218, 1054: 219, 1055: 220, 1071: 221, 1056: 222, 1057: 223, 92: 224, 164: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 1058: 234, 1059: 235, 1046: 236, 1042: 237, 1068: 238, 1067: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 1047: 250, 1064: 251, 1069: 252, 1065: 253, 1063: 254, 159: 255, + }, + } + case 0xbd: // 189 + return &StringConverter{ + LangID: 189, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 123, 224, 225, 227, 229, 231, 241, 196, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 126, 220, 36, 42, 41, 59, 94, + 45, 47, 194, 91, 192, 193, 195, 197, 199, 209, 246, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 167, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 181, 223, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 64, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 228, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 166, 242, 243, 245, + 252, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 125, 249, 250, 255, + 214, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 92, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 93, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 123: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 196: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 126: 89, 220: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 91: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 246: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 167: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 181: 160, 223: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 64: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 228: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 166: 204, 242: 205, 243: 206, 245: 207, 252: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 125: 220, 249: 221, 250: 222, 255: 223, 214: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 92: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 93: 252, 217: 253, 218: 254, 159: 255, 8216: 121, 8248: 95, + 8764: 89, 376: 232, + }, + } + case 0xbe: // 190 + return &StringConverter{ + LangID: 190, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 239, 238, 236, 196, 197, + 201, 230, 198, 244, 246, 242, 251, 249, 255, 214, 220, 248, 163, 216, 8359, 402, + 225, 237, 243, 250, 241, 209, 170, 186, 191, 65535, 172, 189, 188, 161, 171, 164, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 945, 946, 915, 960, 931, 963, 956, 964, 934, 920, 937, 948, 65535, 966, 949, 65535, + 65535, 177, 8805, 8804, 65535, 65535, 247, 65535, 176, 183, 65535, 65535, 65535, 178, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 236: 141, 196: 142, 197: 143, + 201: 144, 230: 145, 198: 146, 244: 147, 246: 148, 242: 149, 251: 150, 249: 151, 255: 152, 214: 153, 220: 154, 248: 155, 163: 156, 216: 157, 8359: 158, 402: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 170: 166, 186: 167, 191: 168, 65535: 255, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 164: 175, + 945: 224, 946: 225, 915: 226, 960: 227, 931: 228, 963: 229, 956: 230, 964: 231, 934: 232, 920: 233, 937: 234, 948: 235, 966: 237, 949: 238, 177: 241, 8805: 242, + 8804: 243, 247: 246, 176: 248, 183: 249, 178: 253, 8718: 254, 187: 175, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 162: 155, + 165: 157, 8356: 76, 192: 65, 193: 65, 194: 65, 200: 69, 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, + 221: 89, 253: 121, 223: 225, 63741: 159, + }, + } + case 0xbf: // 191 + return &StringConverter{ + LangID: 191, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 160, 8221, 162, 163, 164, 8222, 166, 167, 216, 169, 342, 171, 172, 173, 174, 198, + 176, 177, 178, 179, 8220, 181, 182, 183, 248, 185, 343, 187, 188, 189, 190, 230, + 260, 302, 256, 262, 196, 197, 280, 274, 268, 201, 377, 278, 290, 310, 298, 315, + 352, 323, 325, 211, 332, 213, 214, 215, 370, 321, 346, 362, 220, 379, 381, 223, + 261, 303, 257, 263, 228, 229, 281, 275, 269, 233, 378, 279, 291, 311, 299, 316, + 353, 324, 326, 243, 333, 245, 246, 247, 371, 322, 347, 363, 252, 380, 382, 8217, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 159, 160: 160, 8221: 161, 162: 162, 163: 163, 164: 164, 8222: 165, 166: 166, 167: 167, 216: 168, 169: 169, 342: 170, 171: 171, 172: 172, 173: 173, 174: 174, + 198: 175, 176: 176, 177: 177, 178: 178, 179: 179, 8220: 180, 181: 181, 182: 182, 183: 183, 248: 184, 185: 185, 343: 186, 187: 187, 188: 188, 189: 189, 190: 190, + 230: 191, 260: 192, 302: 193, 256: 194, 262: 195, 196: 196, 197: 197, 280: 198, 274: 199, 268: 200, 201: 201, 377: 202, 278: 203, 290: 204, 310: 205, 298: 206, + 315: 207, 352: 208, 323: 209, 325: 210, 211: 211, 332: 212, 213: 213, 214: 214, 215: 215, 370: 216, 321: 217, 346: 218, 362: 219, 220: 220, 379: 221, 381: 222, + 223: 223, 261: 224, 303: 225, 257: 226, 263: 227, 228: 228, 229: 229, 281: 230, 275: 231, 269: 232, 233: 233, 378: 234, 279: 235, 291: 236, 311: 237, 299: 238, + 316: 239, 353: 240, 324: 241, 326: 242, 243: 243, 333: 244, 245: 245, 246: 246, 247: 247, 371: 248, 322: 249, 347: 250, 363: 251, 252: 252, 380: 253, 382: 254, + 8217: 255, + }, + } + case 0xc0: // 192 + return &StringConverter{ + LangID: 192, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 262, 252, 233, 257, 228, 291, 229, 263, 322, 275, 279, 303, 299, 377, 196, 197, + 201, 379, 380, 333, 246, 290, 363, 346, 347, 214, 220, 324, 315, 321, 215, 269, + 256, 298, 243, 371, 260, 261, 381, 382, 280, 281, 278, 378, 268, 302, 171, 187, + 9617, 9618, 9619, 9474, 9508, 9569, 9570, 9558, 9557, 9571, 9553, 9559, 9565, 9564, 9563, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 9566, 9567, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9575, + 9576, 9572, 9573, 9561, 9560, 9554, 9555, 9579, 9578, 9496, 9484, 9608, 9604, 9612, 9616, 9600, + 211, 223, 332, 323, 245, 213, 352, 353, 310, 311, 362, 370, 316, 274, 325, 326, + 173, 177, 230, 198, 182, 164, 247, 248, 176, 216, 183, 343, 342, 8222, 8220, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 262: 128, 252: 129, 233: 130, 257: 131, 228: 132, 291: 133, 229: 134, 263: 135, 322: 136, 275: 137, 279: 138, 303: 139, 299: 140, 377: 141, 196: 142, 197: 143, + 201: 144, 379: 145, 380: 146, 333: 147, 246: 148, 290: 149, 363: 150, 346: 151, 347: 152, 214: 153, 220: 154, 324: 155, 315: 156, 321: 157, 215: 158, 269: 159, + 256: 160, 298: 161, 243: 162, 371: 163, 260: 164, 261: 165, 381: 166, 382: 167, 280: 168, 281: 169, 278: 170, 378: 171, 268: 172, 302: 173, 171: 174, 187: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 9569: 181, 9570: 182, 9558: 183, 9557: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 9564: 189, 9563: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 9566: 198, 9567: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 9575: 207, + 9576: 208, 9572: 209, 9573: 210, 9561: 211, 9560: 212, 9554: 213, 9555: 214, 9579: 215, 9578: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 9612: 221, 9616: 222, 9600: 223, + 211: 224, 223: 225, 332: 226, 323: 227, 245: 228, 213: 229, 352: 230, 353: 231, 310: 232, 311: 233, 362: 234, 370: 235, 316: 236, 274: 237, 325: 238, 326: 239, + 173: 240, 177: 241, 230: 242, 198: 243, 182: 244, 164: 245, 247: 246, 248: 247, 176: 248, 216: 249, 183: 250, 343: 251, 342: 252, 8222: 253, 8220: 254, 160: 255, + }, + } + case 0xc1: // 193 + return &StringConverter{ + LangID: 193, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 9617, 9618, 9619, 9474, 9508, 256, 65535, 326, 9557, 9571, 9553, 9559, 9565, 332, 9563, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 257, 65535, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 65535, + 352, 65535, 269, 268, 9560, 9554, 501, 298, 299, 9496, 9484, 9608, 9604, 363, 362, 9600, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, + 274, 275, 290, 311, 310, 316, 315, 382, 381, 333, 183, 8730, 325, 353, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1040: 128, 1041: 129, 1042: 130, 1043: 131, 1044: 132, 1045: 133, 1046: 134, 1047: 135, 1048: 136, 1049: 137, 1050: 138, 1051: 139, 1052: 140, 1053: 141, 1054: 142, 1055: 143, + 1056: 144, 1057: 145, 1058: 146, 1059: 147, 1060: 148, 1061: 149, 1062: 150, 1063: 151, 1064: 152, 1065: 153, 1066: 154, 1067: 155, 1068: 156, 1069: 157, 1070: 158, 1071: 159, + 1072: 160, 1073: 161, 1074: 162, 1075: 163, 1076: 164, 1077: 165, 1078: 166, 1079: 167, 1080: 168, 1081: 169, 1082: 170, 1083: 171, 1084: 172, 1085: 173, 1086: 174, 1087: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 256: 181, 65535: 255, 326: 183, 9557: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 332: 189, 9563: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 257: 198, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 352: 208, 269: 210, + 268: 211, 9560: 212, 9554: 213, 501: 214, 298: 215, 299: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 363: 221, 362: 222, 9600: 223, 1088: 224, 1089: 225, 1090: 226, + 1091: 227, 1092: 228, 1093: 229, 1094: 230, 1095: 231, 1096: 232, 1097: 233, 1098: 234, 1099: 235, 1100: 236, 1101: 237, 1102: 238, 1103: 239, 274: 240, 275: 241, 290: 242, + 311: 243, 310: 244, 316: 245, 315: 246, 382: 247, 381: 248, 333: 249, 183: 250, 8730: 251, 325: 252, 353: 253, 8718: 254, + }, + } + case 0xc2: // 194 + return &StringConverter{ + LangID: 194, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 353, 228, 261, 303, 363, 229, 275, 382, 162, 46, 60, 40, 43, 124, + 38, 233, 281, 279, 269, 371, 8222, 8220, 501, 223, 33, 36, 42, 41, 59, 172, + 45, 47, 352, 196, 260, 302, 362, 197, 274, 381, 166, 44, 37, 95, 62, 63, + 248, 201, 280, 278, 268, 370, 298, 315, 290, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 257, 380, 324, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 342, 343, 230, 311, 198, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 8221, 378, 256, 379, 323, 174, + 94, 163, 299, 183, 169, 167, 182, 188, 189, 190, 91, 93, 377, 310, 316, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 333, 246, 326, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 263, 252, 322, 347, 8217, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 332, 214, 325, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 262, 220, 321, 346, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 353: 66, 228: 67, 261: 68, 303: 69, 363: 70, 229: 71, 275: 72, 382: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 281: 82, 279: 83, 269: 84, 371: 85, 8222: 86, 8220: 87, 501: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 172: 95, 45: 96, 47: 97, + 352: 98, 196: 99, 260: 100, 302: 101, 362: 102, 197: 103, 274: 104, 381: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 280: 114, 278: 115, 268: 116, 370: 117, 298: 118, 315: 119, 290: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 257: 140, 380: 141, 324: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 342: 154, 343: 155, 230: 156, 311: 157, 198: 158, 164: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 8221: 170, 378: 171, 256: 172, 379: 173, 323: 174, 174: 175, 94: 176, 163: 177, + 299: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 91: 186, 93: 187, 377: 188, 310: 189, 316: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 333: 203, 246: 204, 326: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 263: 219, 252: 220, 322: 221, 347: 222, 8217: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 332: 235, 214: 236, 325: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 262: 251, 220: 252, 321: 253, 346: 254, 159: 255, + }, + } + case 0xc3: // 195 + return &StringConverter{ + LangID: 195, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 9617, 9618, 9619, 9474, 9508, 256, 9570, 326, 9557, 9571, 9553, 9559, 9565, 332, 9563, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 257, 9567, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9575, + 352, 9572, 269, 268, 9560, 9554, 291, 298, 299, 9496, 9484, 9608, 9604, 363, 362, 9600, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, + 274, 275, 290, 311, 310, 316, 315, 382, 381, 333, 183, 8730, 325, 353, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1040: 128, 1041: 129, 1042: 130, 1043: 131, 1044: 132, 1045: 133, 1046: 134, 1047: 135, 1048: 136, 1049: 137, 1050: 138, 1051: 139, 1052: 140, 1053: 141, 1054: 142, 1055: 143, + 1056: 144, 1057: 145, 1058: 146, 1059: 147, 1060: 148, 1061: 149, 1062: 150, 1063: 151, 1064: 152, 1065: 153, 1066: 154, 1067: 155, 1068: 156, 1069: 157, 1070: 158, 1071: 159, + 1072: 160, 1073: 161, 1074: 162, 1075: 163, 1076: 164, 1077: 165, 1078: 166, 1079: 167, 1080: 168, 1081: 169, 1082: 170, 1083: 171, 1084: 172, 1085: 173, 1086: 174, 1087: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 256: 181, 9570: 182, 326: 183, 9557: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 332: 189, 9563: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 257: 198, 9567: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 9575: 207, + 352: 208, 9572: 209, 269: 210, 268: 211, 9560: 212, 9554: 213, 291: 214, 298: 215, 299: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 363: 221, 362: 222, 9600: 223, + 1088: 224, 1089: 225, 1090: 226, 1091: 227, 1092: 228, 1093: 229, 1094: 230, 1095: 231, 1096: 232, 1097: 233, 1098: 234, 1099: 235, 1100: 236, 1101: 237, 1102: 238, 1103: 239, + 274: 240, 275: 241, 290: 242, 311: 243, 310: 244, 316: 245, 315: 246, 382: 247, 381: 248, 333: 249, 183: 250, 8730: 251, 325: 252, 353: 253, 8718: 254, 160: 255, + }, + } + case 0xc4: // 196 + return &StringConverter{ + LangID: 196, + CharWidth: 1, + eReplace: 65533, + dReplace: 148, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 9472, 9474, 9484, 9488, 9492, 9496, 9500, 9508, 9516, 9524, 9532, 9600, 9604, 9608, 9612, 9616, + 9617, 9618, 9619, 8992, 8718, 8226, 8730, 8776, 8804, 8805, 160, 8993, 176, 178, 183, 247, + 9552, 9553, 9554, 1105, 9555, 9556, 9557, 9558, 9559, 9560, 9561, 9562, 9563, 9564, 9565, 9566, + 9567, 9568, 9569, 1025, 9570, 9571, 9572, 9573, 9574, 9575, 9576, 9577, 9578, 9579, 9580, 169, + 1102, 1072, 1073, 1094, 1076, 1077, 1092, 1075, 1093, 1080, 1081, 1082, 1083, 1084, 1085, 1086, + 1087, 1103, 1088, 1089, 1090, 1091, 1078, 1074, 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, + 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, 1061, 1048, 1049, 1050, 1051, 1052, 1053, 1054, + 1055, 1071, 1056, 1057, 1058, 1059, 1046, 1042, 1068, 1067, 1047, 1064, 1069, 1065, 1063, 1066, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 9472: 128, 9474: 129, 9484: 130, 9488: 131, 9492: 132, 9496: 133, 9500: 134, 9508: 135, 9516: 136, 9524: 137, 9532: 138, 9600: 139, 9604: 140, 9608: 141, 9612: 142, 9616: 143, + 9617: 144, 9618: 145, 9619: 146, 8992: 147, 8718: 148, 8226: 149, 8730: 150, 8776: 151, 8804: 152, 8805: 153, 160: 154, 8993: 155, 176: 156, 178: 157, 183: 158, 247: 159, + 9552: 160, 9553: 161, 9554: 162, 1105: 163, 9555: 164, 9556: 165, 9557: 166, 9558: 167, 9559: 168, 9560: 169, 9561: 170, 9562: 171, 9563: 172, 9564: 173, 9565: 174, 9566: 175, + 9567: 176, 9568: 177, 9569: 178, 1025: 179, 9570: 180, 9571: 181, 9572: 182, 9573: 183, 9574: 184, 9575: 185, 9576: 186, 9577: 187, 9578: 188, 9579: 189, 9580: 190, 169: 191, + 1102: 192, 1072: 193, 1073: 194, 1094: 195, 1076: 196, 1077: 197, 1092: 198, 1075: 199, 1093: 200, 1080: 201, 1081: 202, 1082: 203, 1083: 204, 1084: 205, 1085: 206, 1086: 207, + 1087: 208, 1103: 209, 1088: 210, 1089: 211, 1090: 212, 1091: 213, 1078: 214, 1074: 215, 1100: 216, 1099: 217, 1079: 218, 1096: 219, 1101: 220, 1097: 221, 1095: 222, 1098: 223, + 1070: 224, 1040: 225, 1041: 226, 1062: 227, 1044: 228, 1045: 229, 1060: 230, 1043: 231, 1061: 232, 1048: 233, 1049: 234, 1050: 235, 1051: 236, 1052: 237, 1053: 238, 1054: 239, + 1055: 240, 1071: 241, 1056: 242, 1057: 243, 1058: 244, 1059: 245, 1046: 246, 1042: 247, 1068: 248, 1067: 249, 1047: 250, 1064: 251, 1069: 252, 1065: 253, 1063: 254, 1066: 255, + }, + } + case 0xc5: // 197 + return &StringConverter{ + LangID: 197, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 262, 252, 233, 257, 228, 291, 229, 263, 322, 275, 342, 343, 299, 377, 196, 197, + 201, 230, 198, 333, 246, 290, 162, 346, 347, 214, 220, 248, 163, 216, 215, 164, + 256, 298, 243, 379, 380, 378, 8221, 166, 169, 174, 172, 189, 188, 321, 171, 187, + 9617, 9618, 9619, 9474, 9508, 260, 268, 280, 278, 9571, 9553, 9559, 9565, 302, 352, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 370, 362, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 381, + 261, 269, 281, 279, 303, 353, 371, 363, 382, 9496, 9484, 9608, 9604, 9612, 9616, 9600, + 211, 223, 332, 323, 245, 213, 181, 324, 310, 311, 315, 316, 326, 274, 325, 8217, + 173, 177, 8220, 190, 182, 167, 247, 8222, 176, 8226, 183, 185, 179, 178, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 262: 128, 252: 129, 233: 130, 257: 131, 228: 132, 291: 133, 229: 134, 263: 135, 322: 136, 275: 137, 342: 138, 343: 139, 299: 140, 377: 141, 196: 142, 197: 143, + 201: 144, 230: 145, 198: 146, 333: 147, 246: 148, 290: 149, 162: 150, 346: 151, 347: 152, 214: 153, 220: 154, 248: 155, 163: 156, 216: 157, 215: 158, 164: 159, + 256: 160, 298: 161, 243: 162, 379: 163, 380: 164, 378: 165, 8221: 166, 166: 167, 169: 168, 174: 169, 172: 170, 189: 171, 188: 172, 321: 173, 171: 174, 187: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 260: 181, 268: 182, 280: 183, 278: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 302: 189, 352: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 370: 198, 362: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 381: 207, + 261: 208, 269: 209, 281: 210, 279: 211, 303: 212, 353: 213, 371: 214, 363: 215, 382: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 9612: 221, 9616: 222, 9600: 223, + 211: 224, 223: 225, 332: 226, 323: 227, 245: 228, 213: 229, 181: 230, 324: 231, 310: 232, 311: 233, 315: 234, 316: 235, 326: 236, 274: 237, 325: 238, 8217: 239, + 173: 240, 177: 241, 8220: 242, 190: 243, 182: 244, 167: 245, 247: 246, 8222: 247, 176: 248, 8226: 249, 183: 250, 185: 251, 179: 252, 178: 253, 8718: 254, 160: 255, + }, + } + case 0xc6: // 198 + return &StringConverter{ + LangID: 198, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 125, 231, 241, 35, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 8364, 197, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 36, 199, 209, 248, 44, 37, 95, 62, 63, + 166, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 198, 216, 39, 61, 34, + 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 123, 184, 91, 93, + 181, 252, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 230, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 229, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 126, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 125: 71, 231: 72, 241: 73, 35: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 8364: 90, 197: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 36: 103, 199: 104, 209: 105, 248: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 166: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 198: 123, 216: 124, 39: 125, 61: 126, 34: 127, 64: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 123: 156, 184: 157, 91: 158, 93: 159, 181: 160, 252: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 230: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 229: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 126: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0xc7: // 199 + return &StringConverter{ + LangID: 199, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 123, 224, 225, 227, 125, 231, 241, 167, 46, 60, 40, 43, 33, + 38, 96, 234, 235, 232, 237, 238, 239, 236, 223, 8364, 197, 42, 41, 59, 94, + 45, 47, 194, 35, 192, 193, 195, 36, 199, 209, 246, 44, 37, 95, 62, 63, + 248, 92, 202, 203, 200, 205, 206, 207, 204, 233, 58, 196, 214, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 93, + 181, 252, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 91, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 228, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 166, 242, 243, 245, + 229, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 126, 249, 250, 255, + 201, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 64, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 123: 67, 224: 68, 225: 69, 227: 70, 125: 71, 231: 72, 241: 73, 167: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 96: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 8364: 90, 197: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 35: 99, 192: 100, 193: 101, 195: 102, 36: 103, 199: 104, 209: 105, 246: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 92: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 233: 121, 58: 122, 196: 123, 214: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 93: 159, 181: 160, 252: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 91: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 228: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 166: 204, 242: 205, 243: 206, 245: 207, 229: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 126: 220, 249: 221, 250: 222, 255: 223, 201: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 64: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0xc8: // 200 + return &StringConverter{ + LangID: 200, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 123, 225, 227, 229, 92, 241, 176, 46, 60, 40, 43, 33, + 38, 93, 234, 235, 125, 237, 238, 239, 126, 223, 233, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 242, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 249, 58, 163, 167, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 91, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 181, 236, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 35, 165, 183, 169, 64, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 224, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 166, 243, 245, + 232, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 96, 250, 255, + 231, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 123: 68, 225: 69, 227: 70, 229: 71, 92: 72, 241: 73, 176: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 93: 81, + 234: 82, 235: 83, 125: 84, 237: 85, 238: 86, 239: 87, 126: 88, 223: 89, 233: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 242: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 249: 121, 58: 122, 163: 123, 167: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 91: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 181: 160, 236: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 35: 177, + 165: 178, 183: 179, 169: 180, 64: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, 224: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 166: 205, 243: 206, 245: 207, 232: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 96: 221, 250: 222, 255: 223, 231: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 8216: 221, 8248: 95, + 8764: 88, 376: 232, + }, + } + case 0xc9: // 201 + return &StringConverter{ + LangID: 201, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 224, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 176, 231, 167, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 233, 249, 232, 168, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 224, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 176, 231, 167, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 233, 249, 232, 168, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 224: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 176: 219, 231: 220, 167: 221, 94: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 233: 251, 249: 252, 232: 253, 168: 254, 127: 255, + 64: 64, 91: 91, 92: 92, 93: 93, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 124, + 180: 39, 8248: 94, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, + 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 225: 97, 226: 97, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, 243: 111, 244: 111, 250: 117, 251: 117, + }, + } + case 0xca: // 202 + return &StringConverter{ + LangID: 202, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 161, 209, 191, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 180, 241, 231, 168, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 161, 209, 191, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 180, 241, 231, 168, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 64: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 161: 219, 209: 220, 191: 221, 94: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 180: 251, 241: 252, 231: 253, 168: 254, 127: 255, + 91: 91, 92: 92, 93: 93, 123: 123, 124: 124, 125: 125, 126: 126, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 124, 8248: 94, 165: 89, + 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, 211: 79, 212: 79, 217: 85, + 218: 85, 219: 85, 224: 97, 225: 97, 226: 97, 232: 101, 233: 101, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, 243: 111, 244: 111, 249: 117, 250: 117, + 251: 117, + }, + } + case 0xcb: // 203 + return &StringConverter{ + LangID: 203, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 164, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 201, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 197, 220, 95, + 233, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 229, 252, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 164, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 201, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 197, 220, 95, + 233, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 229, 252, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 164: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 201: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 196: 219, 214: 220, 197: 221, 220: 222, 95: 223, + 233: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 228: 251, 246: 252, 229: 253, 252: 254, 127: 255, + 36: 36, 64: 64, 91: 91, 92: 92, 93: 93, 94: 94, 96: 96, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, + 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 202: 69, 204: 73, 205: 73, + 206: 73, 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 224: 97, 225: 98, 226: 99, 231: 99, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, + 243: 111, 244: 111, 249: 117, 250: 117, 251: 117, + }, + } + case 0xcc: // 204 + return &StringConverter{ + LangID: 204, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 198, 216, 197, 220, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 230, 248, 229, 252, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 198, 216, 197, 220, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 230, 248, 229, 252, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 64: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 198: 219, 216: 220, 197: 221, 220: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 230: 251, 248: 252, 229: 253, 252: 254, 127: 255, + 91: 91, 92: 92, 93: 93, 94: 94, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 180: 39, + 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, 211: 79, 212: 79, + 217: 85, 218: 85, 219: 85, 224: 97, 225: 98, 226: 99, 231: 99, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, 243: 111, 244: 111, 249: 117, 250: 117, + 251: 117, + }, + } + case 0xcd: // 205 + return &StringConverter{ + LangID: 205, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 198, 216, 197, 220, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 230, 248, 229, 252, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 198, 216, 197, 220, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 230, 248, 229, 252, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 64: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 198: 219, 216: 220, 197: 221, 220: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 230: 251, 248: 252, 229: 253, 252: 254, 127: 255, + 91: 91, 92: 92, 93: 93, 94: 94, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 180: 39, + 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, 211: 79, 212: 79, + 217: 85, 218: 85, 219: 85, 224: 97, 225: 98, 226: 99, 231: 99, 234: 101, 236: 105, 237: 105, 238: 105, 242: 111, 243: 111, 244: 111, 249: 117, 250: 117, + 251: 117, + }, + } + case 0xce: // 206 + return &StringConverter{ + LangID: 206, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 176, 231, 233, 94, 95, + 249, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 224, 242, 232, 236, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 163, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 176, 231, 233, 94, 95, + 249, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 224, 242, 232, 236, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 163: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 167: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 176: 219, 231: 220, 233: 221, 94: 222, 95: 223, + 249: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 224: 251, 242: 252, 232: 253, 236: 254, 127: 255, + 35: 35, 64: 64, 91: 91, 92: 92, 93: 93, 96: 96, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, + 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 204: 73, + 205: 73, 206: 73, 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 225: 97, 226: 97, 234: 101, 237: 105, 238: 105, 243: 111, 244: 111, 250: 117, + 251: 117, + }, + } + case 0xcf: // 207 + return &StringConverter{ + LangID: 207, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 220, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 252, 223, 127, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 167, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 196, 214, 220, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 228, 246, 252, 223, 127, + }, + eBuffer: map[int]int{ + 0: 128, 1: 129, 2: 130, 3: 131, 4: 132, 5: 133, 6: 134, 7: 135, 8: 136, 9: 137, 10: 138, 11: 139, 12: 140, 13: 141, 14: 142, 15: 143, + 16: 144, 17: 145, 18: 146, 19: 147, 20: 148, 21: 149, 22: 150, 23: 151, 24: 152, 25: 153, 26: 154, 27: 155, 28: 156, 29: 157, 30: 158, 31: 159, + 32: 160, 33: 161, 34: 162, 35: 163, 36: 164, 37: 165, 38: 166, 39: 167, 40: 168, 41: 169, 42: 170, 43: 171, 44: 172, 45: 173, 46: 174, 47: 175, + 48: 176, 49: 177, 50: 178, 51: 179, 52: 180, 53: 181, 54: 182, 55: 183, 56: 184, 57: 185, 58: 186, 59: 187, 60: 188, 61: 189, 62: 190, 63: 191, + 167: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 202, 75: 203, 76: 204, 77: 205, 78: 206, 79: 207, + 80: 208, 81: 209, 82: 210, 83: 211, 84: 212, 85: 213, 86: 214, 87: 215, 88: 216, 89: 217, 90: 218, 196: 219, 214: 220, 220: 221, 94: 222, 95: 223, + 96: 224, 97: 225, 98: 226, 99: 227, 100: 228, 101: 229, 102: 230, 103: 231, 104: 232, 105: 233, 106: 234, 107: 235, 108: 236, 109: 237, 110: 238, 111: 239, + 112: 240, 113: 241, 114: 242, 115: 243, 116: 244, 117: 245, 118: 246, 119: 247, 120: 248, 121: 249, 122: 250, 228: 251, 246: 252, 252: 253, 223: 254, 127: 255, + 64: 64, 91: 91, 92: 92, 93: 93, 123: 123, 124: 124, 125: 125, 126: 126, 161: 33, 171: 60, 187: 62, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 124, + 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 192: 65, 193: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 204: 73, 205: 73, 206: 73, + 210: 79, 211: 79, 212: 79, 217: 85, 218: 85, 219: 85, 224: 97, 225: 97, 226: 97, 231: 99, 232: 101, 233: 101, 234: 101, 236: 105, 237: 105, 238: 105, + 242: 111, 243: 111, 244: 111, 249: 117, 250: 117, 251: 117, 946: 126, + }, + } + case 0xd0: // 208 + return &StringConverter{ + LangID: 208, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 64, 225, 227, 229, 92, 241, 176, 46, 60, 40, 43, 33, + 38, 123, 234, 235, 125, 237, 238, 239, 236, 223, 167, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 249, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 181, 58, 163, 224, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 91, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 8364, + 96, 168, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 35, 165, 183, 169, 93, 182, 188, 189, 190, 172, 124, 175, 126, 180, 215, + 233, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 232, 74, 75, 76, 77, 78, 79, 80, 81, 82, 65535, 251, 252, 166, 250, 255, + 231, 247, 83, 84, 85, 86, 87, 88, 89, 90, 65535, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65535, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 64: 68, 225: 69, 227: 70, 229: 71, 92: 72, 241: 73, 176: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 123: 81, + 234: 82, 235: 83, 125: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 167: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 249: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 181: 121, 58: 122, 163: 123, 224: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, 91: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 8364: 159, 96: 160, 168: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, 162: 176, 35: 177, + 165: 178, 183: 179, 169: 180, 93: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 126: 189, 180: 190, 215: 191, 233: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, 245: 207, 232: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 65535: 250, 251: 219, 252: 220, 166: 221, 250: 222, 255: 223, 231: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, 50: 242, + 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, + }, + } + case 0xd2: // 210 + return &StringConverter{ + LangID: 210, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 91, 46, 60, 40, 43, 33, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 93, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 124, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 166, 175, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 255, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 91: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 33: 79, 38: 80, 233: 81, 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 93: 90, 36: 91, 42: 92, 41: 93, + 59: 94, 94: 95, 45: 96, 47: 97, 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 124: 106, 44: 107, 37: 108, 95: 109, + 62: 110, 63: 111, 248: 112, 201: 113, 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, + 61: 126, 34: 127, 216: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, + 254: 142, 177: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, + 198: 158, 164: 159, 181: 160, 126: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, + 222: 174, 174: 175, 162: 176, 163: 177, 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 166: 187, 175: 188, 168: 189, + 180: 190, 215: 191, 123: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, + 243: 206, 245: 207, 125: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, + 250: 222, 255: 223, 92: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, + 211: 238, 213: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, + 218: 254, 8216: 121, 8248: 95, 8764: 161, 376: 232, + }, + } + case 0xd3: // 211 + return &StringConverter{ + LangID: 211, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 902, 904, 905, 906, 908, 910, 911, 912, 91, 46, 60, 40, 43, 33, + 38, 913, 914, 915, 916, 917, 918, 919, 920, 921, 93, 36, 42, 41, 59, 94, + 45, 47, 922, 923, 924, 925, 926, 927, 928, 929, 124, 44, 37, 95, 62, 63, + 8216, 8217, 931, 932, 933, 934, 935, 936, 937, 96, 58, 35, 64, 39, 61, 34, + 900, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 938, 939, 940, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 941, 942, 943, 944, 945, 946, + 901, 126, 115, 116, 117, 118, 119, 120, 121, 122, 947, 948, 949, 950, 951, 952, + 65535, 163, 65535, 183, 169, 167, 65535, 65535, 189, 65535, 172, 166, 8213, 168, 953, 954, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 955, 956, 957, 958, 959, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 960, 961, 962, 963, 964, 965, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 178, 966, 967, 968, 969, 970, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 971, 972, 973, 974, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 255, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 902: 66, 904: 67, 905: 68, 906: 69, 908: 70, 910: 71, 911: 72, 912: 73, 91: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 33: 79, 38: 80, 913: 81, 914: 82, 915: 83, 916: 84, 917: 85, 918: 86, 919: 87, 920: 88, 921: 89, 93: 90, 36: 91, 42: 92, 41: 93, + 59: 94, 94: 95, 45: 96, 47: 97, 922: 98, 923: 99, 924: 100, 925: 101, 926: 102, 927: 103, 928: 104, 929: 105, 124: 106, 44: 107, 37: 108, 95: 109, + 62: 110, 63: 111, 8216: 112, 8217: 113, 931: 114, 932: 115, 933: 116, 934: 117, 935: 118, 936: 119, 937: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, + 61: 126, 34: 127, 900: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 938: 140, 939: 141, + 940: 142, 177: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 941: 154, 942: 155, 943: 156, 944: 157, + 945: 158, 946: 159, 901: 160, 126: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 947: 170, 948: 171, 949: 172, 950: 173, + 951: 174, 952: 175, 163: 177, 183: 179, 169: 180, 167: 181, 189: 184, 172: 186, 166: 187, 8213: 188, 168: 189, 953: 190, 954: 191, 123: 192, 65: 193, 66: 194, + 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 955: 203, 956: 204, 957: 205, 958: 206, 959: 207, 125: 208, 74: 209, 75: 210, + 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 960: 218, 961: 219, 962: 220, 963: 221, 964: 222, 965: 223, 92: 224, 83: 226, 84: 227, + 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 966: 235, 967: 236, 968: 237, 969: 238, 970: 239, 48: 240, 49: 241, 50: 242, 51: 243, + 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 971: 251, 972: 252, 973: 253, 974: 254, + }, + } + case 0xdd: // 221 + return &StringConverter{ + LangID: 221, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 96, 46, 60, 40, 43, 124, + 38, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 33, 36, 42, 41, 59, 65535, + 45, 47, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 94, 44, 37, 95, 62, 63, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 58, 35, 64, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 91, 92, 93, 65535, 65535, + 65535, 65, 66, 67, 68, 69, 70, 71, 72, 73, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 74, 75, 76, 77, 78, 79, 80, 81, 82, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 65535, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65535, 123, 65535, 125, 65535, 172, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 254, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 96: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 45: 96, + 47: 97, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 97: 129, 98: 130, 99: 131, + 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 115: 162, + 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 91: 187, 92: 188, 93: 189, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, + 71: 199, 72: 200, 73: 201, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 83: 226, 84: 227, 85: 228, 86: 229, + 87: 230, 88: 231, 89: 232, 90: 233, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 123: 251, 125: 253, + 172: 255, 161: 90, 171: 76, 187: 110, 8216: 74, 8213: 96, 180: 125, 8248: 106, 165: 232, 63741: 134, 8356: 211, 192: 193, 193: 193, 194: 193, 199: 195, 200: 197, + 201: 197, 202: 197, 204: 201, 205: 201, 206: 201, 210: 214, 211: 214, 212: 214, 217: 228, 218: 228, 219: 228, 224: 129, 225: 129, 226: 129, 231: 131, 232: 133, + 233: 133, 234: 133, 236: 137, 237: 137, 238: 137, 242: 150, 243: 150, 244: 150, 249: 164, 250: 164, 251: 164, + }, + } + case 0xde: // 222 + return &StringConverter{ + LangID: 222, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 96, 46, 60, 40, 43, 246, + 38, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 33, 36, 42, 41, 59, 65535, + 45, 47, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 94, 44, 37, 95, 62, 63, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 58, 35, 167, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 196, 214, 220, 65535, 65535, + 65535, 65, 66, 67, 68, 69, 70, 71, 72, 73, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 74, 75, 76, 77, 78, 79, 80, 81, 82, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 65535, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65535, 228, 65535, 252, 65535, 223, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 254, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 96: 74, 46: 75, 60: 76, 40: 77, 43: 78, 246: 79, 38: 80, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 45: 96, + 47: 97, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 58: 122, 35: 123, 167: 124, 39: 125, 61: 126, 34: 127, 97: 129, 98: 130, 99: 131, + 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 115: 162, + 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 196: 187, 214: 188, 220: 189, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, + 71: 199, 72: 200, 73: 201, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 83: 226, 84: 227, 85: 228, 86: 229, + 87: 230, 88: 231, 89: 232, 90: 233, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 228: 251, 252: 253, + 223: 255, 64: 124, 91: 187, 92: 188, 93: 189, 123: 251, 124: 79, 125: 253, 161: 90, 171: 76, 187: 110, 8216: 74, 8213: 96, 180: 125, 8248: 106, 164: 91, + 165: 232, 63741: 134, 8356: 211, 172: 255, 192: 193, 193: 193, 194: 193, 199: 195, 200: 197, 201: 197, 202: 197, 204: 201, 205: 201, 206: 201, 210: 214, 211: 214, + 212: 214, 217: 228, 218: 228, 219: 228, 224: 129, 225: 129, 226: 129, 231: 131, 232: 133, 233: 133, 234: 133, 236: 137, 237: 137, 238: 137, 242: 150, 243: 150, + 244: 150, 249: 164, 250: 164, 251: 164, + }, + } + case 0xdf: // 223 + return &StringConverter{ + LangID: 223, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 96, 46, 60, 40, 43, 249, + 38, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 33, 36, 42, 41, 59, 65535, + 45, 47, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 94, 44, 37, 95, 62, 63, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 58, 35, 224, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 176, 231, 167, 65535, 65535, + 65535, 65, 66, 67, 68, 69, 70, 71, 72, 73, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 74, 75, 76, 77, 78, 79, 80, 81, 82, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 65535, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65535, 233, 65535, 232, 65535, 168, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 254, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 96: 74, 46: 75, 60: 76, 40: 77, 43: 78, 249: 79, 38: 80, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 45: 96, + 47: 97, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 58: 122, 35: 123, 224: 124, 39: 125, 61: 126, 34: 127, 97: 129, 98: 130, 99: 131, + 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 115: 162, + 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 176: 187, 231: 188, 167: 189, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, + 71: 199, 72: 200, 73: 201, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 83: 226, 84: 227, 85: 228, 86: 229, + 87: 230, 88: 231, 89: 232, 90: 233, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 233: 251, 232: 253, + 168: 255, 64: 124, 91: 187, 92: 188, 93: 189, 123: 251, 124: 79, 125: 253, 161: 90, 171: 76, 187: 110, 8216: 74, 8213: 96, 180: 125, 8248: 106, 164: 91, + 165: 232, 63741: 134, 8356: 211, 172: 255, 192: 193, 193: 193, 194: 193, 199: 195, 200: 197, 201: 197, 202: 197, 204: 201, 205: 201, 206: 201, 210: 214, 211: 214, + 212: 214, 217: 228, 218: 228, 219: 228, 225: 129, 226: 129, 234: 133, 236: 137, 237: 137, 238: 137, 242: 150, 243: 150, 244: 150, 250: 164, 251: 164, + }, + } + case 0xe0: // 224 + return &StringConverter{ + LangID: 224, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 65535, 225, 233, 237, 243, 250, 252, 65535, 65535, 96, 46, 60, 40, 43, 241, + 38, 65535, 193, 201, 205, 211, 218, 220, 65535, 65535, 33, 36, 42, 41, 59, 65535, + 45, 47, 224, 232, 236, 242, 249, 65535, 65535, 65535, 94, 44, 37, 95, 62, 63, + 65535, 65535, 192, 200, 204, 210, 217, 65535, 65535, 65535, 58, 35, 64, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 161, 209, 191, 65535, 65535, + 65535, 65, 66, 67, 68, 69, 70, 71, 72, 73, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 74, 75, 76, 77, 78, 79, 80, 81, 82, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 65535, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65535, 180, 65535, 231, 65535, 168, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 254, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 225: 66, 233: 67, 237: 68, 243: 69, 250: 70, 252: 71, 96: 74, 46: 75, 60: 76, 40: 77, 43: 78, 241: 79, 38: 80, + 193: 82, 201: 83, 205: 84, 211: 85, 218: 86, 220: 87, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 45: 96, 47: 97, 224: 98, 232: 99, 236: 100, + 242: 101, 249: 102, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 192: 114, 200: 115, 204: 116, 210: 117, 217: 118, 58: 122, 35: 123, 64: 124, + 39: 125, 61: 126, 34: 127, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 106: 145, 107: 146, 108: 147, 109: 148, + 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 187, 209: 188, 191: 189, + 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, + 81: 216, 82: 217, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, + 54: 246, 55: 247, 56: 248, 57: 249, 180: 251, 231: 253, 168: 255, 91: 187, 92: 188, 93: 189, 123: 251, 124: 79, 125: 253, 171: 76, 187: 110, 8216: 74, + 8213: 96, 8248: 106, 164: 91, 165: 232, 63741: 134, 8356: 211, 172: 255, 194: 193, 199: 195, 202: 197, 206: 201, 212: 214, 219: 228, 226: 129, 234: 133, 238: 137, + 244: 150, 251: 164, + }, + } + case 0xe1: // 225 + return &StringConverter{ + LangID: 225, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 96, 46, 60, 40, 43, 248, + 38, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 33, 36, 42, 41, 59, 65535, + 45, 47, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 220, 44, 37, 95, 62, 63, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 58, 35, 167, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 198, 216, 197, 65535, 65535, + 65535, 65, 66, 67, 68, 69, 70, 71, 72, 73, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 74, 75, 76, 77, 78, 79, 80, 81, 82, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 65535, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65535, 230, 65535, 229, 65535, 252, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 254, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 96: 74, 46: 75, 60: 76, 40: 77, 43: 78, 248: 79, 38: 80, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 45: 96, + 47: 97, 220: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 58: 122, 35: 123, 167: 124, 39: 125, 61: 126, 34: 127, 97: 129, 98: 130, 99: 131, + 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 115: 162, + 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 198: 187, 216: 188, 197: 189, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, + 71: 199, 72: 200, 73: 201, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 83: 226, 84: 227, 85: 228, 86: 229, + 87: 230, 88: 231, 89: 232, 90: 233, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 230: 251, 229: 253, + 252: 255, 64: 124, 91: 187, 92: 188, 93: 189, 123: 251, 124: 79, 125: 253, 161: 90, 171: 76, 187: 110, 8216: 74, 8213: 96, 180: 125, 8248: 106, 164: 91, + 165: 232, 63741: 134, 8356: 211, 172: 255, 192: 193, 193: 193, 194: 193, 199: 195, 200: 197, 201: 197, 202: 197, 204: 201, 205: 201, 206: 201, 210: 214, 211: 214, + 212: 214, 217: 228, 218: 228, 219: 228, 224: 129, 225: 129, 226: 129, 231: 131, 232: 133, 233: 133, 234: 133, 236: 137, 237: 137, 238: 137, 242: 150, 243: 150, + 244: 150, 249: 164, 250: 164, 251: 164, + }, + } + case 0xe2: // 226 + return &StringConverter{ + LangID: 226, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 65535, 29, 30, 31, + 65535, 65535, 28, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 226, 123, 224, 225, 227, 125, 231, 241, 35, 46, 60, 40, 43, 33, + 38, 96, 234, 235, 232, 237, 238, 239, 236, 223, 36, 197, 42, 41, 59, 220, + 45, 47, 194, 65535, 192, 193, 195, 65535, 199, 209, 246, 44, 37, 95, 62, 63, + 248, 92, 202, 203, 200, 205, 206, 207, 204, 233, 58, 196, 214, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 93, + 181, 252, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 91, 182, 188, 189, 190, 172, 124, 175, 168, 180, 215, + 228, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 166, 242, 243, 245, + 229, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 126, 249, 250, 255, + 201, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 64, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 65535, 217, 218, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 255, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 29: 29, 30: 30, 31: 31, 28: 34, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 226: 66, 123: 67, 224: 68, 225: 69, 227: 70, 125: 71, 231: 72, 241: 73, 35: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 33: 79, 38: 80, 96: 81, 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 36: 90, 197: 91, 42: 92, 41: 93, + 59: 94, 220: 95, 45: 96, 47: 97, 194: 98, 192: 100, 193: 101, 195: 102, 199: 104, 209: 105, 246: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, + 248: 112, 92: 113, 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 233: 121, 58: 122, 196: 123, 214: 124, 39: 125, 61: 126, 34: 127, + 216: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, 177: 143, + 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 93: 159, + 181: 160, 252: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, 174: 175, + 162: 176, 163: 177, 165: 178, 183: 179, 169: 180, 91: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 124: 187, 175: 188, 168: 189, 180: 190, 215: 191, + 228: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 166: 204, 242: 205, 243: 206, 245: 207, + 229: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 126: 220, 249: 221, 250: 222, 255: 223, + 201: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 64: 236, 210: 237, 211: 238, 213: 239, + 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 217: 253, 218: 254, + }, + } + case 0xe6: // 230 + return &StringConverter{ + LangID: 230, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 96, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 65535, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 94, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 353, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 382, 198, 8364, + 181, 175, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 338, 339, 376, 172, 91, 92, 93, 381, 215, + 352, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 166, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 219, 250, 255, + 217, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 123, 220, 125, 218, 126, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 95, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 96: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 124: 79, 38: 80, 233: 81, 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, + 59: 94, 45: 96, 47: 97, 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, + 63: 111, 248: 112, 201: 113, 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 353: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, + 34: 127, 216: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, + 177: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 382: 157, 198: 158, + 8364: 159, 181: 160, 175: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, + 174: 175, 162: 176, 163: 177, 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 338: 183, 339: 184, 376: 185, 172: 186, 91: 187, 92: 188, 93: 189, 381: 190, + 215: 191, 352: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, + 245: 207, 166: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 219: 221, 250: 222, + 255: 223, 217: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, + 213: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 123: 251, 220: 252, 125: 253, 218: 254, + 126: 255, 8248: 106, 8764: 255, + }, + } + case 0xe7: // 231 + return &StringConverter{ + LangID: 231, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 96, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 65535, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 94, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 168, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 240, 253, 254, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 175, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 208, 221, 222, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 91, 92, 93, 180, 215, + 249, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 166, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 219, 250, 255, + 217, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 123, 220, 125, 218, 126, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 95, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 96: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 124: 79, 38: 80, 233: 81, 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, + 59: 94, 45: 96, 47: 97, 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, + 63: 111, 248: 112, 201: 113, 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 168: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, + 34: 127, 216: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 240: 140, 253: 141, 254: 142, + 177: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, + 164: 159, 181: 160, 175: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 208: 172, 221: 173, 222: 174, + 174: 175, 162: 176, 163: 177, 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 91: 187, 92: 188, 93: 189, 180: 190, + 215: 191, 249: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, + 245: 207, 166: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 219: 221, 250: 222, + 255: 223, 217: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, + 213: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 123: 251, 220: 252, 125: 253, 218: 254, + 126: 255, 8248: 106, 8764: 255, + }, + } + case 0xe8: // 232 + return &StringConverter{ + LangID: 232, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 226, 228, 259, 261, 263, 269, 231, 215, 96, 46, 60, 40, 43, 124, + 38, 281, 280, 235, 203, 283, 238, 282, 206, 167, 33, 36, 42, 41, 59, 65535, + 45, 47, 194, 196, 258, 260, 262, 268, 199, 168, 94, 44, 37, 95, 62, 63, + 345, 225, 233, 237, 243, 246, 337, 250, 252, 369, 58, 35, 64, 39, 61, 34, + 344, 97, 98, 99, 100, 101, 102, 103, 104, 105, 323, 271, 273, 253, 355, 357, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 318, 317, 341, 184, 340, 164, + 711, 223, 115, 116, 117, 118, 119, 120, 121, 122, 321, 270, 208, 221, 354, 356, + 728, 193, 201, 205, 211, 214, 336, 218, 220, 368, 731, 91, 92, 93, 180, 382, + 367, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 324, 328, 347, 353, + 733, 74, 75, 76, 77, 78, 79, 80, 81, 82, 314, 351, 378, 350, 380, 381, + 366, 247, 83, 84, 85, 86, 87, 88, 89, 90, 729, 212, 323, 327, 346, 352, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 313, 123, 377, 125, 379, 126, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 95, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 226: 66, 228: 67, 259: 68, 261: 69, 263: 70, 269: 71, 231: 72, 215: 73, 96: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 124: 79, 38: 80, 281: 81, 280: 82, 235: 83, 203: 84, 283: 85, 238: 86, 282: 87, 206: 88, 167: 89, 33: 90, 36: 91, 42: 92, 41: 93, + 59: 94, 45: 96, 47: 97, 194: 98, 196: 99, 258: 100, 260: 101, 262: 102, 268: 103, 199: 104, 168: 105, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, + 63: 111, 345: 112, 225: 113, 233: 114, 237: 115, 243: 116, 246: 117, 337: 118, 250: 119, 252: 120, 369: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, + 34: 127, 344: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 323: 236, 271: 139, 273: 140, 253: 141, 355: 142, + 357: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 318: 154, 317: 155, 341: 156, 184: 157, 340: 158, + 164: 159, 711: 160, 223: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 321: 170, 270: 171, 208: 172, 221: 173, 354: 174, + 356: 175, 728: 176, 193: 177, 201: 178, 205: 179, 211: 180, 214: 181, 336: 182, 218: 183, 220: 184, 368: 185, 731: 186, 91: 187, 92: 188, 93: 189, 180: 190, + 382: 191, 367: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 324: 204, 328: 205, 347: 206, + 353: 207, 733: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 314: 218, 351: 219, 378: 220, 350: 221, 380: 222, + 381: 223, 366: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 729: 234, 212: 235, 327: 237, 346: 238, 352: 239, + 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 313: 250, 123: 251, 377: 252, 125: 253, 379: 254, 126: 255, + 8248: 106, 8764: 255, + }, + } + case 0xe9: // 233 + return &StringConverter{ + LangID: 233, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 226, 228, 341, 225, 259, 314, 231, 324, 96, 46, 60, 40, 43, 124, + 38, 233, 281, 235, 269, 237, 238, 271, 283, 223, 33, 36, 42, 41, 59, 65535, + 45, 47, 194, 196, 340, 193, 258, 313, 199, 323, 94, 44, 37, 95, 62, 63, + 345, 201, 280, 203, 268, 205, 206, 270, 282, 168, 58, 35, 64, 39, 61, 34, + 344, 97, 98, 99, 100, 101, 102, 103, 104, 105, 356, 357, 273, 253, 355, 261, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 350, 351, 263, 184, 262, 164, + 318, 379, 115, 116, 117, 118, 119, 120, 121, 122, 260, 380, 272, 221, 354, 381, + 728, 321, 317, 711, 352, 167, 347, 378, 733, 382, 377, 91, 92, 93, 180, 215, + 367, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 328, 243, 337, + 346, 74, 75, 76, 77, 78, 79, 80, 81, 82, 353, 369, 252, 368, 250, 729, + 366, 247, 83, 84, 85, 86, 87, 88, 89, 90, 731, 212, 214, 327, 211, 336, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 322, 123, 220, 125, 218, 126, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 95, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 226: 66, 228: 67, 341: 68, 225: 69, 259: 70, 314: 71, 231: 72, 324: 73, 96: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 124: 79, 38: 80, 233: 81, 281: 82, 235: 83, 269: 84, 237: 85, 238: 86, 271: 87, 283: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, + 59: 94, 45: 96, 47: 97, 194: 98, 196: 99, 340: 100, 193: 101, 258: 102, 313: 103, 199: 104, 323: 105, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, + 63: 111, 345: 112, 201: 113, 280: 114, 203: 115, 268: 116, 205: 117, 206: 118, 270: 119, 282: 120, 168: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, + 34: 127, 344: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 356: 138, 357: 139, 273: 140, 253: 141, 355: 142, + 261: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 350: 154, 351: 155, 263: 156, 184: 157, 262: 158, + 164: 159, 318: 160, 379: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 260: 170, 380: 171, 272: 172, 221: 173, 354: 174, + 381: 175, 728: 176, 321: 177, 317: 178, 711: 179, 352: 180, 167: 181, 347: 182, 378: 183, 733: 184, 382: 185, 377: 186, 91: 187, 92: 188, 93: 189, 180: 190, + 215: 191, 367: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 328: 205, 243: 206, + 337: 207, 346: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 353: 218, 369: 219, 252: 220, 368: 221, 250: 222, + 729: 223, 366: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 731: 234, 212: 235, 214: 236, 327: 237, 211: 238, + 336: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 322: 250, 123: 251, 220: 252, 125: 253, 218: 254, + 126: 255, 8248: 106, 8764: 255, + }, + } + case 0xeb: // 235 + return &StringConverter{ + LangID: 235, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 96, 46, 60, 40, 43, 124, + 38, 8470, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 33, 36, 42, 41, 59, 65535, + 45, 47, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 94, 44, 37, 95, 62, 63, + 1106, 1105, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 58, 35, 64, 39, 61, 34, + 1107, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1040, 1041, 1042, 1043, 1044, 1045, + 1108, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1046, 1047, 1048, 1049, 1050, 1051, + 1109, 126, 115, 116, 117, 118, 119, 120, 121, 122, 1052, 1053, 1054, 1055, 1056, 1057, + 1026, 1025, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1027, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 1110, 1111, 1112, 1113, 1114, + 1028, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1115, 1116, 1118, 1119, 1030, 1031, + 1029, 167, 83, 84, 85, 86, 87, 88, 89, 90, 1032, 1033, 1034, 1035, 1036, 1038, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1039, 91, 123, 93, 125, 92, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 95, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 1072: 66, 1073: 67, 1074: 68, 1075: 69, 1076: 70, 1077: 71, 1078: 72, 1079: 73, 96: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 124: 79, 38: 80, 8470: 81, 1080: 82, 1081: 83, 1082: 84, 1083: 85, 1084: 86, 1085: 87, 1086: 88, 1087: 89, 33: 90, 36: 91, 42: 92, 41: 93, + 59: 94, 45: 96, 47: 97, 1088: 98, 1089: 99, 1090: 100, 1091: 101, 1092: 102, 1093: 103, 1094: 104, 1095: 105, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, + 63: 111, 1106: 112, 1105: 113, 1096: 114, 1097: 115, 1098: 116, 1099: 117, 1100: 118, 1101: 119, 1102: 120, 1103: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, + 34: 127, 1107: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1040: 138, 1041: 139, 1042: 140, 1043: 141, 1044: 142, + 1045: 143, 1108: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1046: 154, 1047: 155, 1048: 156, 1049: 157, 1050: 158, + 1051: 159, 1109: 160, 126: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 1052: 170, 1053: 171, 1054: 172, 1055: 173, 1056: 174, + 1057: 175, 1026: 176, 1025: 177, 1058: 178, 1059: 179, 1060: 180, 1061: 181, 1062: 182, 1063: 183, 1064: 184, 1065: 185, 1066: 186, 1067: 187, 1068: 188, 1069: 189, 1070: 190, + 1071: 191, 1027: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 1110: 203, 1111: 204, 1112: 205, 1113: 206, + 1114: 207, 1028: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 1115: 218, 1116: 219, 1118: 220, 1119: 221, 1030: 222, + 1031: 223, 1029: 224, 167: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 1032: 234, 1033: 235, 1034: 236, 1035: 237, 1036: 238, + 1038: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 1039: 250, 91: 251, 123: 252, 93: 253, 125: 254, + 92: 255, + }, + } + case 0xef: // 239 + return &StringConverter{ + LangID: 239, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 28, 29, 30, 31, + 65535, 65535, 65535, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 231, 241, 96, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 65535, + 45, 47, 194, 196, 192, 193, 195, 197, 199, 209, 94, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 168, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 287, 305, 351, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 175, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 286, 304, 350, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 91, 92, 93, 180, 215, + 249, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 242, 243, 245, + 166, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 219, 250, 255, + 217, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 123, 220, 125, 218, 126, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 95, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 28: 28, 29: 29, 30: 30, 31: 31, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 231: 72, 241: 73, 96: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 124: 79, 38: 80, 233: 81, 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, + 59: 94, 45: 96, 47: 97, 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 199: 104, 209: 105, 94: 106, 44: 107, 37: 108, 95: 109, 62: 110, + 63: 111, 248: 112, 201: 113, 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 168: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, + 34: 127, 216: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 287: 140, 305: 141, 351: 142, + 177: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, + 164: 159, 181: 160, 175: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 286: 172, 304: 173, 350: 174, + 174: 175, 162: 176, 163: 177, 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 91: 187, 92: 188, 93: 189, 180: 190, + 215: 191, 249: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 242: 205, 243: 206, + 245: 207, 166: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 219: 221, 250: 222, + 255: 223, 217: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, + 213: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 123: 251, 220: 252, 125: 253, 218: 254, + 126: 255, 8248: 106, 8764: 255, 63738: 201, 63736: 137, + }, + } + case 0xf1: // 241 + return &StringConverter{ + LangID: 241, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 167, 65535, 65535, 65535, 8593, + 193, 192, 194, 196, 195, 197, 198, 199, 201, 200, 202, 203, 205, 204, 206, 207, + 209, 211, 210, 212, 214, 213, 216, 338, 218, 217, 219, 220, 65535, 65535, 65535, 65535, + 225, 224, 226, 228, 227, 229, 230, 231, 233, 232, 234, 235, 237, 236, 238, 239, + 241, 243, 242, 244, 246, 245, 248, 339, 250, 249, 251, 252, 223, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 167: 187, 8593: 191, 193: 192, 192: 193, 194: 194, 196: 195, 195: 196, 197: 197, 198: 198, 199: 199, 201: 200, 200: 201, 202: 202, 203: 203, 205: 204, + 204: 205, 206: 206, 207: 207, 209: 208, 211: 209, 210: 210, 212: 211, 214: 212, 213: 213, 216: 214, 338: 215, 218: 216, 217: 217, 219: 218, 220: 219, 225: 224, + 224: 225, 226: 226, 228: 227, 227: 228, 229: 229, 230: 230, 231: 231, 233: 232, 232: 233, 234: 234, 235: 235, 237: 236, 236: 237, 238: 238, 239: 239, 241: 240, + 243: 241, 242: 242, 244: 243, 246: 244, 245: 245, 248: 246, 339: 247, 250: 248, 249: 249, 251: 250, 252: 251, 223: 252, 161: 33, 171: 60, 187: 62, 8216: 96, + 8213: 45, 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 165: 89, 63741: 102, 8356: 76, 221: 89, 253: 121, + }, + } + case 0xfb: // 251 + return &StringConverter{ + LangID: 251, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 161, 162, 163, 65535, 165, 65535, 167, 164, 169, 170, 171, 65535, 65535, 65535, 65535, + 176, 177, 178, 179, 65535, 181, 182, 183, 65535, 185, 186, 187, 188, 189, 65535, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 65535, 209, 210, 211, 212, 213, 214, 338, 216, 217, 218, 219, 220, 376, 65535, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 65535, 241, 242, 243, 244, 245, 246, 339, 248, 249, 250, 251, 252, 255, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 161: 161, 162: 162, 163: 163, 165: 165, 167: 167, 164: 168, 169: 169, 170: 170, 171: 171, 176: 176, 177: 177, 178: 178, 179: 179, 181: 181, 182: 182, + 183: 183, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 191: 191, 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, + 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 338: 215, 216: 216, 217: 217, + 218: 218, 219: 219, 220: 220, 376: 221, 223: 223, 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, + 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 339: 247, 248: 248, 249: 249, 250: 250, 251: 251, + 252: 252, 255: 253, 8216: 96, 8213: 45, 175: 45, 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, 63741: 102, 8356: 76, 221: 89, 253: 121, 946: 223, + }, + } + case 0x105: // 261 + return &StringConverter{ + LangID: 261, + CharWidth: 1, + eReplace: 65533, + dReplace: 252, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 192, 194, 200, 202, 203, 206, 207, 180, 8216, 8248, 168, 8764, 217, 219, 8356, + 175, 221, 253, 176, 199, 231, 209, 241, 161, 191, 164, 163, 165, 167, 402, 162, + 226, 234, 244, 251, 225, 233, 243, 250, 224, 232, 242, 249, 228, 235, 246, 252, + 197, 238, 216, 198, 229, 237, 248, 230, 196, 236, 214, 220, 201, 239, 223, 212, + 193, 195, 227, 208, 240, 205, 204, 211, 210, 213, 245, 352, 353, 218, 376, 255, + 222, 254, 183, 181, 182, 65535, 8213, 188, 189, 170, 186, 171, 8718, 187, 177, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 192: 161, 194: 162, 200: 163, 202: 164, 203: 165, 206: 166, 207: 167, 180: 168, 8216: 169, 8248: 170, 168: 171, 8764: 172, 217: 173, 219: 174, 8356: 175, + 175: 176, 221: 177, 253: 178, 176: 179, 199: 180, 231: 181, 209: 182, 241: 183, 161: 184, 191: 185, 164: 186, 163: 187, 165: 188, 167: 189, 402: 190, 162: 191, + 226: 192, 234: 193, 244: 194, 251: 195, 225: 196, 233: 197, 243: 198, 250: 199, 224: 200, 232: 201, 242: 202, 249: 203, 228: 204, 235: 205, 246: 206, 252: 207, + 197: 208, 238: 209, 216: 210, 198: 211, 229: 212, 237: 213, 248: 214, 230: 215, 196: 216, 236: 217, 214: 218, 220: 219, 201: 220, 239: 221, 223: 222, 212: 223, + 193: 224, 195: 225, 227: 226, 208: 227, 240: 228, 205: 229, 204: 230, 211: 231, 210: 232, 213: 233, 245: 234, 352: 235, 353: 236, 218: 237, 376: 238, 255: 239, + 222: 240, 254: 241, 183: 242, 181: 243, 182: 244, 8213: 246, 188: 247, 189: 248, 170: 249, 186: 250, 171: 251, 8718: 252, 187: 253, 177: 254, 160: 32, 173: 45, + 166: 124, 272: 227, 273: 228, 63741: 190, + }, + } + case 0x106: // 262 + return &StringConverter{ + LangID: 262, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 256, 257, 201, 260, 214, 220, 225, 261, 268, 228, 269, 262, 263, 233, 377, + 378, 270, 237, 271, 274, 275, 278, 243, 279, 244, 246, 245, 250, 282, 283, 252, + 65535, 176, 280, 163, 167, 183, 182, 223, 174, 169, 8482, 281, 168, 8800, 65535, 302, + 303, 298, 8804, 8805, 299, 310, 948, 931, 322, 315, 316, 317, 318, 313, 314, 325, + 326, 323, 172, 65535, 324, 327, 916, 171, 187, 65535, 160, 328, 336, 213, 337, 332, + 65535, 8213, 8220, 8221, 8216, 8217, 247, 65535, 333, 340, 341, 344, 65535, 65535, 345, 342, + 343, 352, 65535, 65535, 353, 346, 347, 193, 356, 357, 205, 381, 382, 362, 211, 212, + 363, 366, 218, 367, 368, 369, 370, 371, 221, 253, 311, 379, 321, 380, 65535, 711, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 256: 129, 257: 130, 201: 131, 260: 132, 214: 133, 220: 134, 225: 135, 261: 136, 268: 137, 228: 138, 269: 139, 262: 140, 263: 141, 233: 142, 377: 143, + 378: 144, 270: 145, 237: 146, 271: 147, 274: 148, 275: 149, 278: 150, 243: 151, 279: 152, 244: 153, 246: 154, 245: 155, 250: 156, 282: 157, 283: 158, 252: 159, + 65535: 254, 176: 161, 280: 162, 163: 163, 167: 164, 183: 165, 182: 166, 223: 167, 174: 168, 169: 169, 8482: 170, 281: 171, 168: 172, 8800: 173, 302: 175, 303: 176, + 298: 177, 8804: 178, 8805: 179, 299: 180, 310: 181, 948: 182, 931: 183, 322: 184, 315: 185, 316: 186, 317: 187, 318: 188, 313: 189, 314: 190, 325: 191, 326: 192, + 323: 193, 172: 194, 324: 196, 327: 197, 916: 198, 171: 199, 187: 200, 160: 202, 328: 203, 336: 204, 213: 205, 337: 206, 332: 207, 8213: 209, 8220: 210, 8221: 211, + 8216: 212, 8217: 213, 247: 214, 333: 216, 340: 217, 341: 218, 344: 219, 345: 222, 342: 223, 343: 224, 352: 225, 353: 228, 346: 229, 347: 230, 193: 231, 356: 232, + 357: 233, 205: 234, 381: 235, 382: 236, 362: 237, 211: 238, 212: 239, 363: 240, 366: 241, 218: 242, 367: 243, 368: 244, 369: 245, 370: 246, 371: 247, 221: 248, + 253: 249, 311: 250, 379: 251, 321: 252, 380: 253, 711: 255, + }, + } + case 0x107: // 263 + return &StringConverter{ + LangID: 263, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 65535, 176, 162, 163, 167, 183, 182, 223, 174, 350, 8482, 180, 168, 8800, 381, 216, + 65535, 177, 8804, 8805, 165, 181, 948, 931, 928, 351, 65535, 170, 186, 8486, 382, 248, + 191, 161, 172, 65535, 402, 8764, 262, 171, 268, 65535, 160, 192, 195, 213, 338, 339, + 272, 8213, 8220, 8221, 8216, 8217, 247, 65535, 65535, 169, 65535, 65535, 65535, 65535, 198, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 263, 65535, 269, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 273, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 960, 65535, 65535, 65535, 65535, 230, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 65535: 255, 176: 161, 162: 162, 163: 163, 167: 164, 183: 165, 182: 166, 223: 167, 174: 168, 350: 169, 8482: 170, 180: 171, 168: 172, 8800: 173, 381: 174, 216: 175, + 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 948: 182, 931: 183, 928: 184, 351: 185, 170: 187, 186: 188, 8486: 189, 382: 190, 248: 191, 191: 192, 161: 193, + 172: 194, 402: 196, 8764: 197, 262: 198, 171: 199, 268: 200, 160: 202, 192: 203, 195: 204, 213: 205, 338: 206, 339: 207, 272: 208, 8213: 209, 8220: 210, 8221: 211, + 8216: 212, 8217: 213, 247: 214, 169: 217, 198: 222, 187: 223, 263: 230, 269: 232, 273: 240, 960: 249, 230: 254, 63741: 196, + }, + } + case 0x108: // 264 + return &StringConverter{ + LangID: 264, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 8224, 176, 162, 163, 167, 8226, 182, 223, 174, 169, 8482, 180, 168, 8800, 198, 216, + 8734, 177, 8804, 8805, 165, 181, 948, 931, 928, 960, 8747, 170, 186, 8486, 230, 248, + 191, 161, 172, 8730, 402, 8776, 8710, 171, 187, 8230, 160, 192, 195, 213, 338, 339, + 8211, 8213, 8220, 8221, 8216, 8217, 247, 9674, 255, 376, 286, 287, 304, 305, 350, 351, + 8225, 183, 8218, 8222, 8240, 194, 202, 193, 203, 200, 205, 206, 207, 204, 211, 212, + 65535, 210, 218, 219, 217, 65535, 710, 732, 713, 728, 729, 730, 184, 733, 731, 711, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 8224: 160, 176: 161, 162: 162, 163: 163, 167: 164, 8226: 165, 182: 166, 223: 167, 174: 168, 169: 169, 8482: 170, 180: 171, 168: 172, 8800: 173, 198: 174, 216: 175, + 8734: 176, 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 948: 182, 931: 183, 928: 184, 960: 185, 8747: 186, 170: 187, 186: 188, 8486: 189, 230: 190, 248: 191, + 191: 192, 161: 193, 172: 194, 8730: 195, 402: 196, 8776: 197, 8710: 198, 171: 199, 187: 200, 8230: 201, 160: 202, 192: 203, 195: 204, 213: 205, 338: 206, 339: 207, + 8211: 208, 8213: 209, 8220: 210, 8221: 211, 8216: 212, 8217: 213, 247: 214, 9674: 215, 255: 216, 376: 217, 286: 218, 287: 219, 304: 220, 305: 221, 350: 222, 351: 223, + 8225: 224, 183: 225, 8218: 226, 8222: 227, 8240: 228, 194: 229, 202: 230, 193: 231, 203: 232, 200: 233, 205: 234, 206: 235, 207: 236, 204: 237, 211: 238, 212: 239, + 65535: 245, 210: 241, 218: 242, 219: 243, 217: 244, 710: 246, 732: 247, 713: 248, 728: 249, 729: 250, 730: 251, 184: 252, 733: 253, 731: 254, 711: 255, 175: 248, + 173: 225, 166: 124, 8764: 197, 215: 42, 63738: 73, 63736: 105, 916: 198, 63740: 240, 63741: 196, + }, + } + case 0x109: // 265 + return &StringConverter{ + LangID: 265, + CharWidth: 1, + eReplace: 65533, + dReplace: 192, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 8764, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 221, 176, 162, 163, 167, 65535, 182, 223, 174, 169, 8482, 180, 168, 8800, 198, 216, + 65535, 177, 8804, 8805, 165, 181, 948, 931, 928, 960, 65535, 170, 186, 8486, 230, 248, + 191, 161, 172, 65535, 402, 65535, 916, 171, 187, 65535, 160, 192, 195, 213, 338, 339, + 65535, 8213, 8220, 8221, 8216, 8217, 247, 65535, 255, 376, 65535, 164, 208, 240, 222, 254, + 253, 183, 65535, 65535, 65535, 194, 202, 193, 203, 200, 205, 206, 207, 204, 211, 212, + 65535, 210, 218, 219, 217, 305, 8248, 126, 713, 728, 729, 730, 184, 733, 731, 711, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 8764: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 221: 160, 176: 161, 162: 162, 163: 163, 167: 164, 65535: 240, 182: 166, 223: 167, 174: 168, 169: 169, 8482: 170, 180: 171, 168: 172, 8800: 173, 198: 174, 216: 175, + 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 948: 182, 931: 183, 928: 184, 960: 185, 170: 187, 186: 188, 8486: 189, 230: 190, 248: 191, 191: 192, 161: 193, + 172: 194, 402: 196, 916: 198, 171: 199, 187: 200, 160: 202, 192: 203, 195: 204, 213: 205, 338: 206, 339: 207, 8213: 209, 8220: 210, 8221: 211, 8216: 212, 8217: 213, + 247: 214, 255: 216, 376: 217, 164: 219, 208: 220, 240: 221, 222: 222, 254: 223, 253: 224, 183: 225, 194: 229, 202: 230, 193: 231, 203: 232, 200: 233, 205: 234, + 206: 235, 207: 236, 204: 237, 211: 238, 212: 239, 210: 241, 218: 242, 219: 243, 217: 244, 305: 245, 8248: 246, 126: 247, 713: 248, 728: 249, 729: 250, 730: 251, + 184: 252, 733: 253, 731: 254, 711: 255, 63741: 196, + }, + } + case 0x10a: // 266 + return &StringConverter{ + LangID: 266, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 65535, 8216, 8217, 163, 174, 247, 166, 167, 168, 169, 8482, 171, 172, 65535, 65535, 8213, + 176, 177, 178, 179, 900, 901, 902, 183, 904, 905, 906, 187, 908, 189, 910, 911, + 970, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, + 928, 929, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 971, + 912, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, + 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 65535, 65535, 972, 973, 974, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 65535: 255, 8216: 161, 8217: 162, 163: 163, 174: 164, 247: 165, 166: 166, 167: 167, 168: 168, 169: 169, 8482: 170, 171: 171, 172: 172, 8213: 175, 176: 176, 177: 177, + 178: 178, 179: 179, 900: 180, 901: 181, 902: 182, 183: 183, 904: 184, 905: 185, 906: 186, 187: 187, 908: 188, 189: 189, 910: 190, 911: 191, 970: 192, 913: 193, + 914: 194, 915: 195, 916: 196, 917: 197, 918: 198, 919: 199, 920: 200, 921: 201, 922: 202, 923: 203, 924: 204, 925: 205, 926: 206, 927: 207, 928: 208, 929: 209, + 931: 210, 932: 211, 933: 212, 934: 213, 935: 214, 936: 215, 937: 216, 938: 217, 939: 218, 940: 219, 941: 220, 942: 221, 943: 222, 971: 223, 912: 224, 945: 225, + 946: 226, 947: 227, 948: 228, 949: 229, 950: 230, 951: 231, 952: 232, 953: 233, 954: 234, 955: 235, 956: 236, 957: 237, 958: 238, 959: 239, 960: 240, 961: 241, + 962: 242, 963: 243, 964: 244, 965: 245, 966: 246, 967: 247, 968: 248, 969: 249, 972: 252, 973: 253, 974: 254, + }, + } + case 0x10b: // 267 + return &StringConverter{ + LangID: 267, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 64287, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 63713, 63712, 63711, 63710, 63709, 63708, 8362, 63707, 63706, 63705, 63704, 63703, 63702, 63701, 63700, 63699, + 63698, 63697, 63696, 63695, 63694, 63693, 63692, 63691, 63690, 63689, 63688, 63687, 63684, 63685, 63686, 63674, + 64316, 8222, 65535, 65535, 65535, 65535, 1468, 64331, 64309, 8230, 160, 1464, 1463, 1461, 1462, 1460, + 8211, 8213, 8220, 8221, 8216, 8217, 64298, 64299, 63682, 63730, 1458, 1457, 1467, 1465, 1464, 1459, + 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, + 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 63678, 63683, 63676, 63676, 63677, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 64287: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 63713: 160, 63712: 161, 63711: 162, 63710: 163, 63709: 164, 63708: 165, 8362: 166, 63707: 167, 63706: 168, 63705: 169, 63704: 170, 63703: 171, 63702: 172, 63701: 173, 63700: 174, 63699: 175, + 63698: 176, 63697: 177, 63696: 178, 63695: 179, 63694: 180, 63693: 181, 63692: 182, 63691: 183, 63690: 184, 63689: 185, 63688: 186, 63687: 187, 63684: 188, 63685: 189, 63686: 190, 63674: 191, + 64316: 192, 8222: 193, 65535: 197, 1468: 198, 64331: 199, 64309: 200, 8230: 201, 160: 202, 1464: 222, 1463: 204, 1461: 205, 1462: 206, 1460: 207, 8211: 208, 8213: 209, 8220: 210, + 8221: 211, 8216: 212, 8217: 213, 64298: 214, 64299: 215, 63682: 216, 63730: 217, 1458: 218, 1457: 219, 1467: 220, 1465: 221, 1459: 223, 1488: 224, 1489: 225, 1490: 226, 1491: 227, + 1492: 228, 1493: 229, 1494: 230, 1495: 231, 1496: 232, 1497: 233, 1498: 234, 1499: 235, 1500: 236, 1501: 237, 1502: 238, 1503: 239, 1504: 240, 1505: 241, 1506: 242, 1507: 243, + 1508: 244, 1509: 245, 1510: 246, 1511: 247, 1512: 248, 1513: 249, 1514: 250, 63678: 251, 63683: 252, 63676: 254, 63677: 255, + }, + } + case 0x115: // 277 + return &StringConverter{ + LangID: 277, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 65535, 29, 30, 31, + 65535, 65535, 28, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 91, 46, 60, 40, 43, 33, + 38, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 93, 36, 42, 41, 59, 94, + 45, 47, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 124, 44, 37, 95, 62, 63, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 96, 58, 163, 64, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 126, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 65535, 65535, 65535, 65535, 65535, 65535, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 65535, 65535, 65535, 65535, 65535, 65535, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 65535, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65535, 65535, 65535, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 255, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 29: 29, 30: 30, 31: 31, 28: 34, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, + 45: 96, 47: 97, 124: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 96: 121, 58: 122, 163: 123, 64: 124, 39: 125, 61: 126, 34: 127, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, + 114: 153, 126: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 123: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, + 70: 198, 71: 199, 72: 200, 73: 201, 125: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 92: 224, 83: 226, + 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, + 57: 249, + }, + } + case 0x116: // 278 + return &StringConverter{ + LangID: 278, + CharWidth: 1, + eReplace: 65533, + dReplace: 117, + dBuffer: []int{ + 0, 1, 2, 3, 65535, 9, 65535, 127, 65535, 65535, 65535, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 65535, 10, 8, 65535, 24, 25, 65535, 65535, 65535, 29, 30, 31, + 65535, 65535, 28, 65535, 65535, 10, 23, 27, 65535, 65535, 65535, 65535, 65535, 5, 6, 7, + 65535, 65535, 22, 65535, 65535, 65535, 65535, 4, 65535, 65535, 65535, 65535, 20, 21, 65535, 26, + 32, 160, 161, 162, 35, 164, 165, 166, 167, 168, 91, 46, 60, 40, 43, 33, + 38, 169, 170, 171, 172, 173, 174, 126, 176, 177, 93, 36, 42, 41, 59, 94, + 45, 47, 178, 179, 180, 181, 182, 183, 184, 185, 124, 44, 37, 95, 62, 63, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 96, 58, 163, 64, 39, 61, 34, + 195, 97, 98, 99, 100, 101, 102, 103, 104, 105, 196, 197, 198, 199, 200, 201, + 202, 106, 107, 108, 109, 110, 111, 112, 113, 114, 203, 204, 205, 206, 207, 208, + 209, 175, 115, 116, 117, 118, 119, 120, 121, 122, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 232, 233, 234, 235, 236, 237, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 238, 239, 240, 241, 242, 243, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 244, 245, 246, 247, 248, 249, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 250, 251, 252, 253, 254, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 65535: 225, 9: 5, 127: 7, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, + 10: 37, 8: 22, 24: 24, 25: 25, 29: 29, 30: 30, 31: 31, 28: 34, 23: 38, 27: 39, 5: 45, 6: 46, 7: 47, 22: 50, 4: 55, 20: 60, + 21: 61, 26: 63, 32: 64, 160: 65, 161: 66, 162: 67, 35: 68, 164: 69, 165: 70, 166: 71, 167: 72, 168: 73, 91: 74, 46: 75, 60: 76, 40: 77, + 43: 78, 33: 79, 38: 80, 169: 81, 170: 82, 171: 83, 172: 84, 173: 85, 174: 86, 126: 87, 176: 88, 177: 89, 93: 90, 36: 91, 42: 92, 41: 93, + 59: 94, 94: 95, 45: 96, 47: 97, 178: 98, 179: 99, 180: 100, 181: 101, 182: 102, 183: 103, 184: 104, 185: 105, 124: 106, 44: 107, 37: 108, 95: 109, + 62: 110, 63: 111, 186: 112, 187: 113, 188: 114, 189: 115, 190: 116, 191: 117, 192: 118, 193: 119, 194: 120, 96: 121, 58: 122, 163: 123, 64: 124, 39: 125, + 61: 126, 34: 127, 195: 128, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 196: 138, 197: 139, 198: 140, 199: 141, + 200: 142, 201: 143, 202: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 203: 154, 204: 155, 205: 156, 206: 157, + 207: 158, 208: 159, 209: 160, 175: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 210: 170, 211: 171, 212: 172, 213: 173, + 214: 174, 215: 175, 216: 176, 217: 177, 218: 178, 219: 179, 220: 180, 221: 181, 222: 182, 223: 183, 224: 184, 225: 185, 226: 186, 227: 187, 228: 188, 229: 189, + 230: 190, 231: 191, 123: 192, 65: 193, 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 232: 202, 233: 203, 234: 204, 235: 205, + 236: 206, 237: 207, 125: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 238: 218, 239: 219, 240: 220, 241: 221, + 242: 222, 243: 223, 92: 224, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 244: 234, 245: 235, 246: 236, 247: 237, 248: 238, + 249: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 250: 250, 251: 251, 252: 252, 253: 253, 254: 254, + 255: 255, + }, + } + case 0x117: // 279 + return &StringConverter{ + LangID: 279, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 92, 163, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 36, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 160, 161, 162, 65535, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 92: 35, 163: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 36: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 163, 160: 160, 161: 161, 162: 162, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, + 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, + 208: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 221: 221, 222: 222, 223: 223, + 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, + 240: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 253: 253, 254: 254, 255: 255, + 35: 36, + }, + } + case 0x12d: // 301 + return &StringConverter{ + LangID: 301, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 355, 225, 259, 269, 231, 263, 321, 46, 60, 40, 43, 124, + 38, 233, 281, 235, 367, 237, 238, 318, 314, 223, 33, 36, 42, 41, 59, 729, + 45, 47, 194, 196, 733, 193, 258, 268, 199, 262, 323, 44, 37, 95, 62, 63, + 711, 201, 280, 203, 366, 205, 206, 317, 313, 96, 58, 35, 64, 39, 61, 34, + 728, 97, 98, 99, 100, 101, 102, 103, 104, 105, 347, 328, 273, 253, 345, 351, + 730, 106, 107, 108, 109, 110, 111, 112, 113, 114, 322, 324, 353, 184, 731, 164, + 261, 126, 115, 116, 117, 118, 119, 120, 121, 122, 346, 327, 272, 221, 344, 350, + 94, 260, 380, 354, 379, 167, 382, 378, 381, 377, 91, 93, 352, 168, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 341, 243, 337, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 282, 369, 252, 357, 250, 283, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 271, 212, 214, 340, 211, 336, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 270, 368, 220, 356, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 355: 68, 225: 69, 259: 70, 269: 71, 231: 72, 263: 73, 321: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 281: 82, 235: 83, 367: 84, 237: 85, 238: 86, 318: 87, 314: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 729: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 733: 100, 193: 101, 258: 102, 268: 103, 199: 104, 262: 105, 323: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 711: 112, 201: 113, + 280: 114, 203: 115, 366: 116, 205: 117, 206: 118, 317: 119, 313: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 728: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 347: 138, 328: 139, 273: 140, 253: 141, 345: 142, 351: 143, 730: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 322: 154, 324: 155, 353: 156, 184: 157, 731: 158, 164: 159, 261: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 346: 170, 327: 171, 272: 172, 221: 173, 344: 174, 350: 175, 94: 176, 260: 177, + 380: 178, 354: 179, 379: 180, 167: 181, 382: 182, 378: 183, 381: 184, 377: 185, 91: 186, 93: 187, 352: 188, 168: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 341: 205, 243: 206, 337: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 282: 218, 369: 219, 252: 220, 357: 221, 250: 222, 283: 223, 92: 224, 65535: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 271: 234, 212: 235, 214: 236, 340: 237, 211: 238, 336: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 270: 250, 368: 251, 220: 252, 356: 253, 218: 254, 159: 255, 176: 144, + }, + } + case 0x137: // 311 + return &StringConverter{ + LangID: 311, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 913, 914, 915, 916, 917, 918, 919, 920, 921, 65535, 46, 60, 40, 43, 124, + 38, 922, 923, 924, 925, 926, 927, 928, 929, 931, 33, 36, 42, 41, 59, 94, + 45, 47, 932, 933, 934, 935, 936, 937, 938, 939, 166, 44, 37, 95, 62, 63, + 168, 902, 904, 905, 65535, 906, 908, 910, 911, 96, 58, 35, 64, 39, 61, 34, + 901, 97, 98, 99, 100, 101, 102, 103, 104, 105, 945, 946, 947, 948, 949, 950, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 951, 952, 953, 954, 955, 956, + 900, 126, 115, 116, 117, 118, 119, 120, 121, 122, 957, 958, 959, 91, 961, 963, + 163, 940, 941, 942, 970, 943, 972, 973, 971, 974, 962, 964, 965, 93, 967, 968, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 969, 912, 944, 8216, 8213, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 177, 189, 960, 183, 8217, 65535, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 178, 167, 966, 65535, 171, 172, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 169, 65535, 65535, 187, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 913: 65, + 914: 66, 915: 67, 916: 68, 917: 69, 918: 70, 919: 71, 920: 72, 921: 73, 65535: 253, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 922: 81, + 923: 82, 924: 83, 925: 84, 926: 85, 927: 86, 928: 87, 929: 88, 931: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 932: 98, 933: 99, 934: 100, 935: 101, 936: 102, 937: 103, 938: 104, 939: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 168: 112, 902: 113, + 904: 114, 905: 115, 906: 117, 908: 118, 910: 119, 911: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 901: 128, 97: 129, 98: 130, + 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 945: 138, 946: 139, 947: 140, 948: 141, 949: 142, 950: 143, 176: 144, 106: 145, 107: 146, + 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 951: 154, 952: 155, 953: 156, 954: 157, 955: 158, 956: 159, 900: 160, 126: 161, 115: 162, + 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 957: 170, 958: 171, 959: 172, 91: 173, 961: 174, 963: 175, 163: 176, 940: 177, 941: 178, + 942: 179, 970: 180, 943: 181, 972: 182, 973: 183, 971: 184, 974: 185, 962: 186, 964: 187, 965: 188, 93: 189, 967: 190, 968: 191, 123: 192, 65: 193, 66: 194, + 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 969: 203, 912: 204, 944: 205, 8216: 206, 8213: 207, 125: 208, 74: 209, 75: 210, + 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 177: 218, 189: 219, 960: 220, 183: 221, 8217: 222, 92: 224, 83: 226, 84: 227, 85: 228, + 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 167: 235, 966: 236, 171: 238, 172: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, + 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 169: 251, 187: 254, 159: 255, 8248: 95, 8764: 161, 376: 232, + }, + } + case 0x138: // 312 + return &StringConverter{ + LangID: 312, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 224, 225, 227, 229, 123, 241, 199, 46, 60, 40, 43, 124, + 38, 233, 234, 235, 232, 237, 238, 239, 236, 223, 33, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 192, 193, 195, 197, 304, 209, 351, 44, 37, 95, 62, 63, + 248, 201, 202, 203, 200, 205, 206, 207, 204, 305, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 125, 96, 166, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 170, 186, 230, 184, 198, 164, + 181, 246, 115, 116, 117, 118, 119, 120, 121, 122, 161, 191, 168, 91, 350, 174, + 162, 163, 165, 183, 169, 167, 182, 188, 189, 190, 172, 286, 175, 93, 180, 215, + 231, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 126, 242, 243, 245, + 287, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 251, 252, 249, 250, 255, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 212, 214, 210, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 219, 220, 217, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 224: 68, 225: 69, 227: 70, 229: 71, 123: 72, 241: 73, 199: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 234: 82, 235: 83, 232: 84, 237: 85, 238: 86, 239: 87, 236: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 192: 100, 193: 101, 195: 102, 197: 103, 304: 104, 209: 105, 351: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 202: 114, 203: 115, 200: 116, 205: 117, 206: 118, 207: 119, 204: 120, 305: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 125: 140, 96: 141, 166: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 170: 154, 186: 155, 230: 156, 184: 157, 198: 158, 164: 159, 181: 160, 246: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 161: 170, 191: 171, 168: 172, 91: 173, 350: 174, 174: 175, 162: 176, 163: 177, + 165: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 172: 186, 286: 187, 175: 188, 93: 189, 180: 190, 215: 191, 231: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 126: 204, 242: 205, 243: 206, 245: 207, 287: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 251: 219, 252: 220, 249: 221, 250: 222, 255: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 212: 235, 214: 236, 210: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 219: 251, 220: 252, 217: 253, 218: 254, 159: 255, 63738: 201, 63736: 137, + }, + } + case 0x13a: // 314 + return &StringConverter{ + LangID: 314, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 353, 228, 261, 303, 363, 229, 275, 382, 162, 46, 60, 40, 43, 124, + 38, 233, 281, 279, 269, 371, 8222, 8220, 291, 223, 33, 36, 42, 41, 59, 94, + 45, 47, 352, 196, 260, 302, 362, 197, 274, 381, 166, 44, 37, 95, 62, 63, + 248, 201, 280, 278, 268, 370, 298, 315, 290, 96, 58, 35, 64, 39, 61, 34, + 216, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 257, 380, 324, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 342, 343, 230, 311, 198, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 8221, 378, 256, 91, 323, 174, + 172, 163, 299, 183, 169, 167, 182, 188, 189, 190, 379, 310, 377, 93, 316, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 333, 246, 326, 243, 245, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 263, 252, 322, 347, 8217, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 332, 214, 325, 211, 213, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 262, 220, 321, 346, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 353: 66, 228: 67, 261: 68, 303: 69, 363: 70, 229: 71, 275: 72, 382: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 281: 82, 279: 83, 269: 84, 371: 85, 8222: 86, 8220: 87, 291: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 352: 98, 196: 99, 260: 100, 302: 101, 362: 102, 197: 103, 274: 104, 381: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 248: 112, 201: 113, + 280: 114, 278: 115, 268: 116, 370: 117, 298: 118, 315: 119, 290: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 216: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 171: 138, 187: 139, 257: 140, 380: 141, 324: 142, 177: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 342: 154, 343: 155, 230: 156, 311: 157, 198: 158, 164: 159, 181: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 8221: 170, 378: 171, 256: 172, 91: 173, 323: 174, 174: 175, 172: 176, 163: 177, + 299: 178, 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 379: 186, 310: 187, 377: 188, 93: 189, 316: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 333: 203, 246: 204, 326: 205, 243: 206, 245: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 185: 218, 263: 219, 252: 220, 322: 221, 347: 222, 8217: 223, 92: 224, 247: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 332: 235, 214: 236, 325: 237, 211: 238, 213: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 262: 251, 220: 252, 321: 253, 346: 254, 159: 255, + }, + } + case 0x13b: // 315 + return &StringConverter{ + LangID: 315, + CharWidth: 1, + eReplace: 65533, + dReplace: 171, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 162, 46, 60, 40, 43, 124, + 38, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 33, 36, 42, 41, 59, 94, + 45, 47, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 166, 44, 37, 95, 62, 63, + 65535, 1514, 65535, 65535, 160, 65535, 65535, 65535, 819, 96, 58, 35, 64, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 171, 187, 65535, 65535, 65535, 177, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 65535, 184, 65535, 164, + 181, 126, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 65535, 91, 65535, 174, + 172, 163, 165, 183, 169, 167, 182, 188, 189, 190, 65535, 168, 175, 93, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 65535, 65535, 65535, 65535, 65535, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 185, 65535, 65535, 65535, 65535, 65535, + 92, 247, 83, 84, 85, 86, 87, 88, 89, 90, 178, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 65535, 65535, 65535, 65535, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 1488: 65, + 1489: 66, 1490: 67, 1491: 68, 1492: 69, 1493: 70, 1494: 71, 1495: 72, 1496: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 1497: 81, + 1498: 82, 1499: 83, 1500: 84, 1501: 85, 1502: 86, 1503: 87, 1504: 88, 1505: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 1506: 98, 1507: 99, 1508: 100, 1509: 101, 1510: 102, 1511: 103, 1512: 104, 1513: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 65535: 254, 1514: 113, + 160: 116, 819: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, + 104: 136, 105: 137, 171: 138, 187: 139, 177: 143, 176: 144, 106: 145, 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 184: 157, + 164: 159, 181: 160, 126: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 91: 173, 174: 175, 172: 176, 163: 177, 165: 178, + 183: 179, 169: 180, 167: 181, 182: 182, 188: 183, 189: 184, 190: 185, 168: 187, 175: 188, 93: 189, 180: 190, 215: 191, 123: 192, 65: 193, 66: 194, 67: 195, + 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 125: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, + 82: 217, 185: 218, 92: 224, 247: 225, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 48: 240, 49: 241, 50: 242, + 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 159: 255, + }, + } + case 0x13c: // 316 + return &StringConverter{ + LangID: 316, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 226, 228, 355, 225, 259, 269, 231, 263, 221, 46, 60, 40, 43, 124, + 38, 233, 281, 235, 367, 237, 238, 318, 314, 223, 33, 36, 42, 41, 59, 94, + 45, 47, 194, 196, 733, 193, 258, 268, 199, 262, 168, 44, 37, 95, 62, 63, + 711, 201, 280, 203, 366, 205, 206, 317, 313, 96, 58, 35, 64, 39, 61, 34, + 728, 97, 98, 99, 100, 101, 102, 103, 104, 105, 347, 328, 273, 253, 345, 351, + 730, 106, 107, 108, 109, 110, 111, 112, 113, 114, 322, 324, 353, 184, 731, 164, + 261, 126, 115, 116, 117, 118, 119, 120, 121, 122, 346, 327, 272, 91, 344, 350, + 729, 260, 380, 354, 379, 167, 382, 378, 381, 377, 321, 323, 352, 93, 180, 215, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 244, 246, 341, 243, 337, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 282, 369, 252, 357, 250, 283, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 271, 212, 214, 340, 211, 336, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 270, 368, 220, 356, 218, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 226: 66, 228: 67, 355: 68, 225: 69, 259: 70, 269: 71, 231: 72, 263: 73, 221: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 233: 81, + 281: 82, 235: 83, 367: 84, 237: 85, 238: 86, 318: 87, 314: 88, 223: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 194: 98, 196: 99, 733: 100, 193: 101, 258: 102, 268: 103, 199: 104, 262: 105, 168: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 711: 112, 201: 113, + 280: 114, 203: 115, 366: 116, 205: 117, 206: 118, 317: 119, 313: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 728: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 347: 138, 328: 139, 273: 140, 253: 141, 345: 142, 351: 143, 730: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 322: 154, 324: 155, 353: 156, 184: 157, 731: 158, 164: 159, 261: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 346: 170, 327: 171, 272: 172, 91: 173, 344: 174, 350: 175, 729: 176, 260: 177, + 380: 178, 354: 179, 379: 180, 167: 181, 382: 182, 378: 183, 381: 184, 377: 185, 321: 186, 323: 187, 352: 188, 93: 189, 180: 190, 215: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 244: 203, 246: 204, 341: 205, 243: 206, 337: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 282: 218, 369: 219, 252: 220, 357: 221, 250: 222, 283: 223, 92: 224, 65535: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 271: 234, 212: 235, 214: 236, 340: 237, 211: 238, 336: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 270: 250, 368: 251, 220: 252, 356: 253, 218: 254, 159: 255, 176: 144, + }, + } + case 0x13d: // 317 + return &StringConverter{ + LangID: 317, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 1106, 1107, 1105, 1108, 1109, 1110, 1111, 1112, 1091, 46, 60, 40, 43, 124, + 38, 1113, 1114, 1115, 1116, 1118, 1119, 1066, 8470, 1026, 33, 36, 42, 41, 59, 94, + 45, 47, 1027, 1025, 1028, 1029, 1030, 1031, 1032, 1033, 1045, 44, 37, 95, 62, 63, + 1034, 1035, 1036, 173, 1038, 1039, 1102, 1072, 1073, 96, 58, 35, 64, 39, 61, 34, + 1094, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1076, 1077, 1092, 1075, 1093, 1080, + 1081, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1082, 1083, 1084, 1085, 1086, 1087, + 1103, 126, 115, 116, 117, 118, 119, 120, 121, 122, 1088, 1089, 1090, 91, 1078, 1074, + 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, 1070, 1040, 1041, 1062, 1044, 93, 1060, 1043, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1061, 1048, 1049, 1050, 1051, 1052, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1053, 1054, 1055, 1071, 1056, 1057, + 92, 167, 83, 84, 85, 86, 87, 88, 89, 90, 1058, 1059, 1046, 1042, 1068, 1067, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1047, 1064, 1069, 1065, 1063, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 1106: 66, 1107: 67, 1105: 68, 1108: 69, 1109: 70, 1110: 71, 1111: 72, 1112: 73, 1091: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 1113: 81, + 1114: 82, 1115: 83, 1116: 84, 1118: 85, 1119: 86, 1066: 87, 8470: 88, 1026: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 1027: 98, 1025: 99, 1028: 100, 1029: 101, 1030: 102, 1031: 103, 1032: 104, 1033: 105, 1045: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 1034: 112, 1035: 113, + 1036: 114, 173: 115, 1038: 116, 1039: 117, 1102: 118, 1072: 119, 1073: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 1094: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1076: 138, 1077: 139, 1092: 140, 1075: 141, 1093: 142, 1080: 143, 1081: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1082: 154, 1083: 155, 1084: 156, 1085: 157, 1086: 158, 1087: 159, 1103: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 1088: 170, 1089: 171, 1090: 172, 91: 173, 1078: 174, 1074: 175, 1100: 176, 1099: 177, + 1079: 178, 1096: 179, 1101: 180, 1097: 181, 1095: 182, 1098: 183, 1070: 184, 1040: 185, 1041: 186, 1062: 187, 1044: 188, 93: 189, 1060: 190, 1043: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 1061: 202, 1048: 203, 1049: 204, 1050: 205, 1051: 206, 1052: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 1053: 218, 1054: 219, 1055: 220, 1071: 221, 1056: 222, 1057: 223, 92: 224, 167: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 1058: 234, 1059: 235, 1046: 236, 1042: 237, 1068: 238, 1067: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 1047: 250, 1064: 251, 1069: 252, 1065: 253, 1063: 254, 159: 255, + }, + } + case 0x13f: // 319 + return &StringConverter{ + LangID: 319, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 65535, 3585, 3586, 3587, 3588, 3589, 3590, 3591, 3628, 162, 46, 60, 40, 43, 124, + 38, 65535, 3592, 3593, 3594, 3595, 3596, 3597, 3598, 3634, 33, 36, 42, 41, 59, 94, + 45, 47, 3599, 3600, 3601, 3602, 3603, 3604, 3605, 3664, 166, 44, 37, 95, 62, 63, + 3647, 3662, 3606, 3607, 3608, 3609, 3610, 3611, 3612, 96, 58, 35, 64, 39, 61, 34, + 3663, 97, 98, 99, 100, 101, 102, 103, 104, 105, 3613, 3614, 3615, 3616, 3617, 3618, + 3674, 106, 107, 108, 109, 110, 111, 112, 113, 114, 3619, 3620, 3621, 3622, 3623, 3624, + 3675, 126, 115, 116, 117, 118, 119, 120, 121, 122, 3625, 3626, 3627, 91, 3629, 3630, + 172, 3665, 3666, 3667, 3668, 3669, 3670, 3671, 3672, 3673, 3631, 3632, 3633, 93, 3635, 3636, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 65535, 3637, 3638, 3639, 3640, 3641, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 3642, 3648, 3649, 3650, 3651, 3652, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 3653, 3654, 3655, 3656, 3657, 3658, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 3659, 3660, 3661, 65535, 65535, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 65535: 254, + 3585: 66, 3586: 67, 3587: 68, 3588: 69, 3589: 70, 3590: 71, 3591: 72, 3628: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 3592: 82, + 3593: 83, 3594: 84, 3595: 85, 3596: 86, 3597: 87, 3598: 88, 3634: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, 3599: 98, + 3600: 99, 3601: 100, 3602: 101, 3603: 102, 3604: 103, 3605: 104, 3664: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 3647: 112, 3662: 113, 3606: 114, + 3607: 115, 3608: 116, 3609: 117, 3610: 118, 3611: 119, 3612: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 3663: 128, 97: 129, 98: 130, + 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 3613: 138, 3614: 139, 3615: 140, 3616: 141, 3617: 142, 3618: 143, 3674: 144, 106: 145, 107: 146, + 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 3619: 154, 3620: 155, 3621: 156, 3622: 157, 3623: 158, 3624: 159, 3675: 160, 126: 161, 115: 162, + 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 3625: 170, 3626: 171, 3627: 172, 91: 173, 3629: 174, 3630: 175, 172: 176, 3665: 177, 3666: 178, + 3667: 179, 3668: 180, 3669: 181, 3670: 182, 3671: 183, 3672: 184, 3673: 185, 3631: 186, 3632: 187, 3633: 188, 93: 189, 3635: 190, 3636: 191, 123: 192, 65: 193, 66: 194, + 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 3637: 203, 3638: 204, 3639: 205, 3640: 206, 3641: 207, 125: 208, 74: 209, 75: 210, 76: 211, + 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 3642: 218, 3648: 219, 3649: 220, 3650: 221, 3651: 222, 3652: 223, 92: 224, 83: 226, 84: 227, 85: 228, + 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 3653: 234, 3654: 235, 3655: 236, 3656: 237, 3657: 238, 3658: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, + 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 3659: 250, 3660: 251, 3661: 252, 159: 255, + }, + } + case 0x140: // 320 + return &StringConverter{ + LangID: 320, + CharWidth: 1, + eReplace: 65533, + dReplace: 123, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 1617, 65535, 1600, 65535, 1569, 1570, 65535, 1571, 162, 46, 60, 40, 43, 124, + 38, 65535, 1572, 65535, 65535, 1574, 1575, 65535, 65535, 1576, 33, 36, 42, 41, 59, 94, + 45, 47, 1577, 65535, 1578, 65535, 1579, 65535, 1580, 65535, 166, 44, 37, 95, 62, 63, + 1581, 65535, 1582, 1583, 1584, 1585, 1586, 65535, 1587, 1548, 58, 35, 64, 39, 61, 34, + 65535, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1588, 65535, 1589, 65535, 1590, 1591, + 1592, 106, 107, 108, 109, 110, 111, 112, 113, 114, 65535, 65535, 1593, 65535, 65535, 65535, + 1594, 247, 115, 116, 117, 118, 119, 120, 121, 122, 65535, 65535, 1601, 91, 1602, 65535, + 172, 65535, 65535, 65535, 65535, 65535, 1603, 215, 65535, 65535, 1604, 65535, 1605, 93, 1606, 65535, + 1563, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 1607, 65535, 65535, 65535, 1608, + 1567, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1609, 65535, 65535, 65535, 1610, 65535, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 65535, 65535, 65535, 65535, 65535, 65535, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65535, 65535, 65535, 65535, 65535, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 1617: 66, 65535: 254, 1600: 68, 1569: 70, 1570: 71, 1571: 73, 162: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 1572: 82, 1574: 85, 1575: 86, + 1576: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, 1577: 98, 1578: 100, 1579: 102, 1580: 104, 166: 106, 44: 107, 37: 108, + 95: 109, 62: 110, 63: 111, 1581: 112, 1582: 114, 1583: 115, 1584: 116, 1585: 117, 1586: 118, 1587: 120, 1548: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, + 34: 127, 97: 129, 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1588: 138, 1589: 140, 1590: 142, 1591: 143, 1592: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1593: 156, 1594: 160, 247: 161, 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, + 120: 167, 121: 168, 122: 169, 1601: 172, 91: 173, 1602: 174, 172: 176, 1603: 182, 215: 183, 1604: 186, 1605: 188, 93: 189, 1606: 190, 1563: 192, 65: 193, 66: 194, + 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 1607: 203, 1608: 207, 1567: 208, 74: 209, 75: 210, 76: 211, 77: 212, 78: 213, + 79: 214, 80: 215, 81: 216, 82: 217, 1609: 218, 1610: 222, 92: 224, 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 48: 240, + 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 159: 255, + }, + } + case 0x142: // 322 + return &StringConverter{ + LangID: 322, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 1106, 1107, 1105, 1108, 1109, 1110, 1111, 1112, 1041, 46, 60, 40, 43, 124, + 38, 1113, 1114, 1115, 1116, 1118, 1119, 1066, 8470, 1026, 33, 36, 42, 41, 59, 1100, + 45, 47, 1027, 1025, 1028, 1029, 1030, 1031, 1032, 1033, 1062, 44, 37, 95, 62, 63, + 1034, 1035, 1036, 173, 1038, 1039, 1102, 1072, 1073, 96, 58, 35, 64, 39, 61, 34, + 1094, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1076, 1077, 1092, 1075, 1093, 1080, + 1081, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1082, 1083, 1084, 1085, 1086, 1087, + 1103, 126, 115, 116, 117, 118, 119, 120, 121, 122, 1088, 1089, 1090, 1091, 1078, 1074, + 94, 1099, 1079, 1096, 1101, 1097, 1095, 1098, 1070, 1040, 91, 93, 1044, 1045, 1060, 1043, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1061, 1048, 1049, 1050, 1051, 1052, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1053, 1054, 1055, 1071, 1056, 1057, + 92, 167, 83, 84, 85, 86, 87, 88, 89, 90, 1058, 1059, 1046, 1042, 1068, 1067, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1047, 1064, 1069, 1065, 1063, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 1106: 66, 1107: 67, 1105: 68, 1108: 69, 1109: 70, 1110: 71, 1111: 72, 1112: 73, 1041: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 1113: 81, + 1114: 82, 1115: 83, 1116: 84, 1118: 85, 1119: 86, 1066: 87, 8470: 88, 1026: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 1100: 95, 45: 96, 47: 97, + 1027: 98, 1025: 99, 1028: 100, 1029: 101, 1030: 102, 1031: 103, 1032: 104, 1033: 105, 1062: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 1034: 112, 1035: 113, + 1036: 114, 173: 115, 1038: 116, 1039: 117, 1102: 118, 1072: 119, 1073: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 1094: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1076: 138, 1077: 139, 1092: 140, 1075: 141, 1093: 142, 1080: 143, 1081: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1082: 154, 1083: 155, 1084: 156, 1085: 157, 1086: 158, 1087: 159, 1103: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 1088: 170, 1089: 171, 1090: 172, 1091: 173, 1078: 174, 1074: 175, 94: 176, 1099: 177, + 1079: 178, 1096: 179, 1101: 180, 1097: 181, 1095: 182, 1098: 183, 1070: 184, 1040: 185, 91: 186, 93: 187, 1044: 188, 1045: 189, 1060: 190, 1043: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 1061: 202, 1048: 203, 1049: 204, 1050: 205, 1051: 206, 1052: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 1053: 218, 1054: 219, 1055: 220, 1071: 221, 1056: 222, 1057: 223, 92: 224, 167: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 1058: 234, 1059: 235, 1046: 236, 1042: 237, 1068: 238, 1067: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 1047: 250, 1064: 251, 1069: 252, 1065: 253, 1063: 254, 159: 255, + }, + } + case 0x143: // 323 + return &StringConverter{ + LangID: 323, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 1072, 1073, 1074, 1075, 1076, 1077, 1105, 1078, 1079, 46, 60, 40, 43, 124, + 38, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 8470, 1087, 33, 36, 42, 41, 59, 94, + 45, 47, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 166, 44, 37, 95, 62, 63, + 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1106, 96, 58, 35, 64, 39, 61, 34, + 1107, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1108, 1109, 1110, 1111, 1112, 1113, + 1114, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1115, 1116, 1118, 1119, 1040, 164, + 1041, 126, 115, 116, 117, 118, 119, 120, 121, 122, 1042, 1043, 1044, 91, 1045, 1025, + 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 93, 1059, 1060, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1061, 1062, 1063, 1064, 1065, 1066, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1067, 1068, 1069, 1070, 1071, 1026, + 92, 1027, 83, 84, 85, 86, 87, 88, 89, 90, 1028, 1029, 1030, 1031, 1032, 1033, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1034, 1035, 1036, 1038, 1039, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 1072: 66, 1073: 67, 1074: 68, 1075: 69, 1076: 70, 1077: 71, 1105: 72, 1078: 73, 1079: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 1080: 81, + 1081: 82, 1082: 83, 1083: 84, 1084: 85, 1085: 86, 1086: 87, 8470: 88, 1087: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 1088: 98, 1089: 99, 1090: 100, 1091: 101, 1092: 102, 1093: 103, 1094: 104, 1095: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 1096: 112, 1097: 113, + 1098: 114, 1099: 115, 1100: 116, 1101: 117, 1102: 118, 1103: 119, 1106: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 1107: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1108: 138, 1109: 139, 1110: 140, 1111: 141, 1112: 142, 1113: 143, 1114: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1115: 154, 1116: 155, 1118: 156, 1119: 157, 1040: 158, 164: 159, 1041: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 1042: 170, 1043: 171, 1044: 172, 91: 173, 1045: 174, 1025: 175, 1046: 176, 1047: 177, + 1048: 178, 1049: 179, 1050: 180, 1051: 181, 1052: 182, 1053: 183, 1054: 184, 1055: 185, 1056: 186, 1057: 187, 1058: 188, 93: 189, 1059: 190, 1060: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 1061: 202, 1062: 203, 1063: 204, 1064: 205, 1065: 206, 1066: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 1067: 218, 1068: 219, 1069: 220, 1070: 221, 1071: 222, 1026: 223, 92: 224, 1027: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 1028: 234, 1029: 235, 1030: 236, 1031: 237, 1032: 238, 1033: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 1034: 250, 1035: 251, 1036: 252, 1038: 253, 1039: 254, 159: 255, + }, + } + case 0x144: // 324 + return &StringConverter{ + LangID: 324, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 913, 914, 915, 916, 917, 918, 919, 920, 921, 46, 60, 40, 43, 124, + 38, 922, 923, 924, 925, 926, 927, 928, 929, 931, 33, 36, 42, 41, 59, 94, + 45, 47, 932, 933, 934, 935, 936, 937, 938, 939, 166, 44, 37, 95, 62, 63, + 168, 902, 904, 905, 906, 908, 910, 911, 901, 96, 58, 35, 64, 39, 61, 34, + 945, 97, 98, 99, 100, 101, 102, 103, 104, 105, 946, 947, 948, 949, 950, 951, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 952, 953, 954, 955, 956, 900, + 957, 126, 115, 116, 117, 118, 119, 120, 121, 122, 958, 959, 960, 91, 961, 963, + 163, 940, 941, 942, 970, 943, 972, 973, 971, 974, 962, 964, 965, 93, 966, 967, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 968, 969, 912, 8216, 8213, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 177, 189, 944, 183, 8217, 8364, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 178, 167, 65535, 65535, 171, 172, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 169, 65535, 65535, 187, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 913: 66, 914: 67, 915: 68, 916: 69, 917: 70, 918: 71, 919: 72, 920: 73, 921: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 922: 81, + 923: 82, 924: 83, 925: 84, 926: 85, 927: 86, 928: 87, 929: 88, 931: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 932: 98, 933: 99, 934: 100, 935: 101, 936: 102, 937: 103, 938: 104, 939: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 168: 112, 902: 113, + 904: 114, 905: 115, 906: 116, 908: 117, 910: 118, 911: 119, 901: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 945: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 946: 138, 947: 139, 948: 140, 949: 141, 950: 142, 951: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 952: 154, 953: 155, 954: 156, 955: 157, 956: 158, 900: 159, 957: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 958: 170, 959: 171, 960: 172, 91: 173, 961: 174, 963: 175, 163: 176, 940: 177, + 941: 178, 942: 179, 970: 180, 943: 181, 972: 182, 973: 183, 971: 184, 974: 185, 962: 186, 964: 187, 965: 188, 93: 189, 966: 190, 967: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 968: 203, 969: 204, 912: 205, 8216: 206, 8213: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 177: 218, 189: 219, 944: 220, 183: 221, 8217: 222, 8364: 223, 92: 224, 65535: 253, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 167: 235, 171: 238, 172: 239, 48: 240, 49: 241, 50: 242, 51: 243, + 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 169: 251, 187: 254, 159: 255, 8248: 95, 8764: 161, 376: 232, + }, + } + case 0x145: // 325 + return &StringConverter{ + LangID: 325, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 1106, 1169, 1105, 1108, 1109, 1110, 1111, 1112, 91, 46, 60, 40, 43, 33, + 38, 1113, 1114, 1115, 1116, 1118, 1119, 1066, 8470, 1026, 93, 36, 42, 41, 59, 94, + 45, 47, 1168, 1025, 1028, 1029, 1030, 1031, 1032, 1033, 124, 44, 37, 95, 62, 63, + 1034, 1035, 1036, 173, 1038, 1039, 1102, 1072, 1073, 96, 58, 35, 64, 39, 61, 34, + 1094, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1076, 1077, 1092, 1075, 1093, 1080, + 1081, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1082, 1083, 1084, 1085, 1086, 1087, + 1103, 126, 115, 116, 117, 118, 119, 120, 121, 122, 1088, 1089, 1090, 1091, 1078, 1074, + 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1061, 1048, 1049, 1050, 1051, 1052, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1053, 1054, 1055, 1071, 1056, 1057, + 92, 8364, 83, 84, 85, 86, 87, 88, 89, 90, 1058, 1059, 1046, 1042, 1068, 1067, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1047, 1064, 1069, 1065, 1063, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 1106: 66, 1169: 67, 1105: 68, 1108: 69, 1109: 70, 1110: 71, 1111: 72, 1112: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 1113: 81, + 1114: 82, 1115: 83, 1116: 84, 1118: 85, 1119: 86, 1066: 87, 8470: 88, 1026: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 1168: 98, 1025: 99, 1028: 100, 1029: 101, 1030: 102, 1031: 103, 1032: 104, 1033: 105, 124: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 1034: 112, 1035: 113, + 1036: 114, 173: 115, 1038: 116, 1039: 117, 1102: 118, 1072: 119, 1073: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 1094: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1076: 138, 1077: 139, 1092: 140, 1075: 141, 1093: 142, 1080: 143, 1081: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1082: 154, 1083: 155, 1084: 156, 1085: 157, 1086: 158, 1087: 159, 1103: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 1088: 170, 1089: 171, 1090: 172, 1091: 173, 1078: 174, 1074: 175, 1100: 176, 1099: 177, + 1079: 178, 1096: 179, 1101: 180, 1097: 181, 1095: 182, 1098: 183, 1070: 184, 1040: 185, 1041: 186, 1062: 187, 1044: 188, 1045: 189, 1060: 190, 1043: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 1061: 202, 1048: 203, 1049: 204, 1050: 205, 1051: 206, 1052: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 1053: 218, 1054: 219, 1055: 220, 1071: 221, 1056: 222, 1057: 223, 92: 224, 8364: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 1058: 234, 1059: 235, 1046: 236, 1042: 237, 1068: 238, 1067: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 1047: 250, 1064: 251, 1069: 252, 1065: 253, 1063: 254, 159: 255, + }, + } + case 0x146: // 326 + return &StringConverter{ + LangID: 326, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 160, 1072, 1073, 1074, 1075, 1076, 1077, 1105, 1078, 1079, 46, 60, 40, 43, 124, + 38, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 8470, 1087, 33, 36, 42, 41, 59, 94, + 45, 47, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 166, 44, 37, 95, 62, 63, + 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1106, 96, 58, 35, 64, 39, 61, 34, + 1169, 97, 98, 99, 100, 101, 102, 103, 104, 105, 1108, 1109, 1110, 1111, 1112, 1113, + 1114, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1115, 1116, 1118, 1119, 1040, 8364, + 1041, 126, 115, 116, 117, 118, 119, 120, 121, 122, 1042, 1043, 1044, 91, 1045, 1025, + 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 93, 1059, 1060, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1061, 1062, 1063, 1064, 1065, 1066, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1067, 1068, 1069, 1070, 1071, 1026, + 92, 1168, 83, 84, 85, 86, 87, 88, 89, 90, 1028, 1029, 1030, 1031, 1032, 1033, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 1034, 1035, 1036, 1038, 1039, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 160: 65, + 1072: 66, 1073: 67, 1074: 68, 1075: 69, 1076: 70, 1077: 71, 1105: 72, 1078: 73, 1079: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 1080: 81, + 1081: 82, 1082: 83, 1083: 84, 1084: 85, 1085: 86, 1086: 87, 8470: 88, 1087: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 1088: 98, 1089: 99, 1090: 100, 1091: 101, 1092: 102, 1093: 103, 1094: 104, 1095: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 1096: 112, 1097: 113, + 1098: 114, 1099: 115, 1100: 116, 1101: 117, 1102: 118, 1103: 119, 1106: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 1169: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 1108: 138, 1109: 139, 1110: 140, 1111: 141, 1112: 142, 1113: 143, 1114: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 1115: 154, 1116: 155, 1118: 156, 1119: 157, 1040: 158, 8364: 159, 1041: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 1042: 170, 1043: 171, 1044: 172, 91: 173, 1045: 174, 1025: 175, 1046: 176, 1047: 177, + 1048: 178, 1049: 179, 1050: 180, 1051: 181, 1052: 182, 1053: 183, 1054: 184, 1055: 185, 1056: 186, 1057: 187, 1058: 188, 93: 189, 1059: 190, 1060: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 1061: 202, 1062: 203, 1063: 204, 1064: 205, 1065: 206, 1066: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 1067: 218, 1068: 219, 1069: 220, 1070: 221, 1071: 222, 1026: 223, 92: 224, 1168: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 1028: 234, 1029: 235, 1030: 236, 1031: 237, 1032: 238, 1033: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 1034: 250, 1035: 251, 1036: 252, 1038: 253, 1039: 254, 159: 255, + }, + } + case 0x147: // 327 + return &StringConverter{ + LangID: 327, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 167, 913, 914, 915, 916, 917, 918, 919, 920, 921, 46, 60, 40, 43, 124, + 38, 922, 923, 924, 925, 926, 927, 928, 929, 931, 33, 36, 42, 41, 59, 94, + 45, 47, 932, 933, 934, 935, 936, 937, 196, 214, 166, 44, 37, 95, 62, 63, + 220, 902, 904, 905, 906, 908, 910, 911, 168, 96, 58, 35, 64, 39, 61, 34, + 184, 97, 98, 99, 100, 101, 102, 103, 104, 105, 945, 946, 947, 948, 949, 950, + 951, 106, 107, 108, 109, 110, 111, 112, 113, 114, 952, 953, 954, 955, 956, 900, + 957, 126, 115, 116, 117, 118, 119, 120, 121, 122, 958, 959, 960, 91, 961, 963, + 163, 940, 941, 942, 970, 943, 972, 973, 971, 974, 962, 964, 965, 93, 966, 967, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 968, 969, 226, 224, 228, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 234, 233, 232, 235, 238, 239, + 92, 176, 83, 84, 85, 86, 87, 88, 89, 90, 189, 246, 244, 251, 249, 252, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 255, 231, 199, 8364, 177, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 167: 65, + 913: 66, 914: 67, 915: 68, 916: 69, 917: 70, 918: 71, 919: 72, 920: 73, 921: 74, 46: 75, 60: 76, 40: 77, 43: 78, 124: 79, 38: 80, 922: 81, + 923: 82, 924: 83, 925: 84, 926: 85, 927: 86, 928: 87, 929: 88, 931: 89, 33: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 932: 98, 933: 99, 934: 100, 935: 101, 936: 102, 937: 103, 196: 104, 214: 105, 166: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 220: 112, 902: 113, + 904: 114, 905: 115, 906: 116, 908: 117, 910: 118, 911: 119, 168: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 184: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 945: 138, 946: 139, 947: 140, 948: 141, 949: 142, 950: 143, 951: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 952: 154, 953: 155, 954: 156, 955: 157, 956: 158, 900: 159, 957: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 958: 170, 959: 171, 960: 172, 91: 173, 961: 174, 963: 175, 163: 176, 940: 177, + 941: 178, 942: 179, 970: 180, 943: 181, 972: 182, 973: 183, 971: 184, 974: 185, 962: 186, 964: 187, 965: 188, 93: 189, 966: 190, 967: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 968: 203, 969: 204, 226: 205, 224: 206, 228: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 234: 218, 233: 219, 232: 220, 235: 221, 238: 222, 239: 223, 92: 224, 176: 225, + 83: 226, 84: 227, 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 189: 234, 246: 235, 244: 236, 251: 237, 249: 238, 252: 239, 48: 240, 49: 241, + 50: 242, 51: 243, 52: 244, 53: 245, 54: 246, 55: 247, 56: 248, 57: 249, 255: 250, 231: 251, 199: 252, 8364: 253, 177: 254, 159: 255, 8248: 95, 8764: 161, + 376: 232, + }, + } + case 0x15f: // 351 + return &StringConverter{ + LangID: 351, + CharWidth: 1, + eReplace: 65533, + dReplace: 192, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 8224, 176, 162, 163, 167, 8226, 182, 223, 174, 169, 8482, 180, 168, 8800, 198, 216, + 8734, 177, 8804, 8805, 165, 181, 8706, 8721, 8719, 960, 8747, 170, 186, 937, 230, 248, + 191, 161, 172, 8730, 402, 8776, 8710, 171, 187, 8230, 160, 192, 195, 213, 338, 339, + 8211, 8212, 8220, 8221, 8216, 8217, 247, 9674, 255, 376, 8260, 8364, 8249, 8250, 64257, 64258, + 8225, 183, 8218, 8222, 8240, 194, 202, 193, 203, 200, 205, 206, 207, 204, 211, 212, + 63743, 210, 218, 219, 217, 305, 710, 732, 175, 728, 729, 730, 184, 733, 731, 711, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 8224: 160, 176: 161, 162: 162, 163: 163, 167: 164, 8226: 165, 182: 166, 223: 167, 174: 168, 169: 169, 8482: 170, 180: 171, 168: 172, 8800: 173, 198: 174, 216: 175, + 8734: 176, 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 8706: 182, 8721: 183, 8719: 184, 960: 185, 8747: 186, 170: 187, 186: 188, 937: 189, 230: 190, 248: 191, + 191: 192, 161: 193, 172: 194, 8730: 195, 402: 196, 8776: 197, 8710: 198, 171: 199, 187: 200, 8230: 201, 160: 202, 192: 203, 195: 204, 213: 205, 338: 206, 339: 207, + 8211: 208, 8212: 209, 8220: 210, 8221: 211, 8216: 212, 8217: 213, 247: 214, 9674: 215, 255: 216, 376: 217, 8260: 218, 8364: 219, 8249: 220, 8250: 221, 64257: 222, 64258: 223, + 8225: 224, 183: 225, 8218: 226, 8222: 227, 8240: 228, 194: 229, 202: 230, 193: 231, 203: 232, 200: 233, 205: 234, 206: 235, 207: 236, 204: 237, 211: 238, 212: 239, + 63743: 240, 210: 241, 218: 242, 219: 243, 217: 244, 305: 245, 710: 246, 732: 247, 175: 248, 728: 249, 729: 250, 730: 251, 184: 252, 733: 253, 731: 254, 711: 255, + 8486: 189, 173: 208, 8213: 209, 164: 219, 8248: 246, 8764: 247, 713: 248, 63740: 240, 63741: 196, + }, + } + case 0x160: // 352 + return &StringConverter{ + LangID: 352, + CharWidth: 1, + eReplace: 65533, + dReplace: 192, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, + 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, + 8224, 176, 162, 163, 167, 8226, 182, 223, 174, 169, 8482, 180, 168, 8800, 198, 216, + 8734, 177, 8804, 8805, 165, 181, 8706, 8721, 8719, 960, 8747, 170, 186, 937, 230, 248, + 191, 161, 172, 8730, 402, 8776, 8710, 171, 187, 8230, 160, 192, 195, 213, 338, 339, + 8211, 8212, 8220, 8221, 8216, 8217, 247, 9674, 255, 376, 8260, 8364, 8249, 8250, 64257, 64258, + 8225, 183, 8218, 8222, 8240, 194, 202, 193, 203, 200, 205, 206, 207, 204, 211, 212, + 63743, 210, 218, 219, 217, 305, 710, 732, 175, 728, 729, 730, 184, 733, 731, 711, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 197: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 227: 139, 229: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 237: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 242: 152, 244: 153, 246: 154, 245: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 8224: 160, 176: 161, 162: 162, 163: 163, 167: 164, 8226: 165, 182: 166, 223: 167, 174: 168, 169: 169, 8482: 170, 180: 171, 168: 172, 8800: 173, 198: 174, 216: 175, + 8734: 176, 177: 177, 8804: 178, 8805: 179, 165: 180, 181: 181, 8706: 182, 8721: 183, 8719: 184, 960: 185, 8747: 186, 170: 187, 186: 188, 937: 189, 230: 190, 248: 191, + 191: 192, 161: 193, 172: 194, 8730: 195, 402: 196, 8776: 197, 8710: 198, 171: 199, 187: 200, 8230: 201, 160: 202, 192: 203, 195: 204, 213: 205, 338: 206, 339: 207, + 8211: 208, 8212: 209, 8220: 210, 8221: 211, 8216: 212, 8217: 213, 247: 214, 9674: 215, 255: 216, 376: 217, 8260: 218, 8364: 219, 8249: 220, 8250: 221, 64257: 222, 64258: 223, + 8225: 224, 183: 225, 8218: 226, 8222: 227, 8240: 228, 194: 229, 202: 230, 193: 231, 203: 232, 200: 233, 205: 234, 206: 235, 207: 236, 204: 237, 211: 238, 212: 239, + 63743: 240, 210: 241, 218: 242, 219: 243, 217: 244, 305: 245, 710: 246, 732: 247, 175: 248, 728: 249, 729: 250, 730: 251, 184: 252, 733: 253, 731: 254, 711: 255, + 8486: 189, 173: 208, 8213: 209, 164: 219, 8248: 246, 8764: 247, 713: 248, 63740: 240, 63741: 196, + }, + } + case 0x161: // 353 + return &StringConverter{ + LangID: 353, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 171, 187, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 8220, 8221, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 8216, 8217, 65535, + 160, 3585, 3586, 3587, 3588, 3589, 3590, 3591, 3592, 3593, 3594, 3595, 3596, 3597, 3598, 3599, + 3600, 3601, 3602, 3603, 3604, 3605, 3606, 3607, 3608, 3609, 3610, 3611, 3612, 3613, 3614, 3615, + 3616, 3617, 3618, 3619, 3620, 3621, 3622, 3623, 3624, 3625, 3626, 3627, 3628, 3629, 3630, 3631, + 3632, 3633, 3634, 3635, 3636, 3637, 3638, 3639, 3640, 3641, 65535, 65535, 65535, 173, 8213, 3647, + 3648, 3649, 3650, 3651, 3652, 3653, 3654, 3655, 3656, 3657, 3658, 3659, 3660, 3661, 8482, 3663, + 3664, 3665, 3666, 3667, 3668, 3669, 3670, 3671, 3672, 3673, 174, 169, 65535, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 171: 128, 187: 129, 65535: 255, 8220: 141, 8221: 142, 8216: 157, 8217: 158, 160: 160, 3585: 161, 3586: 162, 3587: 163, 3588: 164, 3589: 165, 3590: 166, 3591: 167, 3592: 168, + 3593: 169, 3594: 170, 3595: 171, 3596: 172, 3597: 173, 3598: 174, 3599: 175, 3600: 176, 3601: 177, 3602: 178, 3603: 179, 3604: 180, 3605: 181, 3606: 182, 3607: 183, 3608: 184, + 3609: 185, 3610: 186, 3611: 187, 3612: 188, 3613: 189, 3614: 190, 3615: 191, 3616: 192, 3617: 193, 3618: 194, 3619: 195, 3620: 196, 3621: 197, 3622: 198, 3623: 199, 3624: 200, + 3625: 201, 3626: 202, 3627: 203, 3628: 204, 3629: 205, 3630: 206, 3631: 207, 3632: 208, 3633: 209, 3634: 210, 3635: 211, 3636: 212, 3637: 213, 3638: 214, 3639: 215, 3640: 216, + 3641: 217, 173: 221, 8213: 222, 3647: 223, 3648: 224, 3649: 225, 3650: 226, 3651: 227, 3652: 228, 3653: 229, 3654: 230, 3655: 231, 3656: 232, 3657: 233, 3658: 234, 3659: 235, + 3660: 236, 3661: 237, 8482: 238, 3663: 239, 3664: 240, 3665: 241, 3666: 242, 3667: 243, 3668: 244, 3669: 245, 3670: 246, 3671: 247, 3672: 248, 3673: 249, 174: 250, 169: 251, + }, + } + case 0x162: // 354 + return &StringConverter{ + LangID: 354, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 171, 187, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 8220, 8221, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 8216, 8217, 65535, + 160, 3585, 3586, 3587, 3588, 3589, 3590, 3591, 3592, 3593, 3594, 3595, 3596, 3597, 3598, 3599, + 3600, 3601, 3602, 3603, 3604, 3605, 3606, 3607, 3608, 3609, 3610, 3611, 3612, 3613, 3614, 3615, + 3616, 3617, 3618, 3619, 3620, 3621, 3622, 3623, 3624, 3625, 3626, 3627, 3628, 3629, 3630, 3631, + 3632, 3633, 3634, 3635, 3636, 3637, 3638, 3639, 3640, 3641, 65535, 65535, 65535, 173, 8213, 3647, + 3648, 3649, 3650, 3651, 3652, 3653, 3654, 3655, 3656, 3657, 3658, 3659, 3660, 3661, 8482, 3663, + 3664, 3665, 3666, 3667, 3668, 3669, 3670, 3671, 3672, 3673, 174, 169, 65535, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 171: 128, 187: 129, 65535: 255, 8220: 141, 8221: 142, 8216: 157, 8217: 158, 160: 160, 3585: 161, 3586: 162, 3587: 163, 3588: 164, 3589: 165, 3590: 166, 3591: 167, 3592: 168, + 3593: 169, 3594: 170, 3595: 171, 3596: 172, 3597: 173, 3598: 174, 3599: 175, 3600: 176, 3601: 177, 3602: 178, 3603: 179, 3604: 180, 3605: 181, 3606: 182, 3607: 183, 3608: 184, + 3609: 185, 3610: 186, 3611: 187, 3612: 188, 3613: 189, 3614: 190, 3615: 191, 3616: 192, 3617: 193, 3618: 194, 3619: 195, 3620: 196, 3621: 197, 3622: 198, 3623: 199, 3624: 200, + 3625: 201, 3626: 202, 3627: 203, 3628: 204, 3629: 205, 3630: 206, 3631: 207, 3632: 208, 3633: 209, 3634: 210, 3635: 211, 3636: 212, 3637: 213, 3638: 214, 3639: 215, 3640: 216, + 3641: 217, 173: 221, 8213: 222, 3647: 223, 3648: 224, 3649: 225, 3650: 226, 3651: 227, 3652: 228, 3653: 229, 3654: 230, 3655: 231, 3656: 232, 3657: 233, 3658: 234, 3659: 235, + 3660: 236, 3661: 237, 8482: 238, 3663: 239, 3664: 240, 3665: 241, 3666: 242, 3667: 243, 3668: 244, 3669: 245, 3670: 246, 3671: 247, 3672: 248, 3673: 249, 174: 250, 169: 251, + }, + } + case 0x170: // 368 + return &StringConverter{ + LangID: 368, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 239, 238, 205, 196, 193, + 201, 230, 198, 337, 246, 211, 369, 218, 368, 214, 220, 162, 163, 165, 8359, 402, + 225, 237, 243, 250, 241, 209, 170, 336, 191, 65535, 172, 189, 188, 161, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 945, 946, 915, 960, 931, 963, 956, 964, 934, 920, 937, 948, 65535, 966, 949, 65535, + 65535, 177, 8805, 8804, 65535, 65535, 247, 65535, 176, 183, 65535, 65535, 65535, 178, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 205: 141, 196: 142, 193: 143, + 201: 144, 230: 145, 198: 146, 337: 147, 246: 148, 211: 149, 369: 150, 218: 151, 368: 152, 214: 153, 220: 154, 162: 155, 163: 156, 165: 157, 8359: 158, 402: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 170: 166, 336: 167, 191: 168, 65535: 255, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 187: 175, + 945: 224, 946: 225, 915: 226, 960: 227, 931: 228, 963: 229, 956: 230, 964: 231, 934: 232, 920: 233, 937: 234, 948: 235, 966: 237, 949: 238, 177: 241, 8805: 242, + 8804: 243, 247: 246, 176: 248, 183: 249, 178: 253, 8718: 254, 8216: 96, 8213: 45, 160: 32, 173: 45, 180: 39, 8248: 94, 8764: 126, 8356: 76, 194: 65, 206: 73, + 212: 79, 221: 89, 253: 121, 223: 225, 63741: 159, + }, + } + case 0x17c: // 380 + return &StringConverter{ + LangID: 380, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, + 929, 931, 932, 933, 934, 935, 936, 937, 945, 946, 947, 948, 949, 950, 951, 952, + 953, 954, 955, 956, 957, 958, 959, 960, 961, 963, 962, 964, 965, 966, 967, 968, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 969, 940, 941, 942, 970, 943, 972, 973, 971, 974, 902, 904, 905, 906, 908, 910, + 911, 177, 8805, 8804, 65535, 65535, 247, 65535, 176, 65535, 183, 65535, 65535, 178, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 913: 128, 914: 129, 915: 130, 916: 131, 917: 132, 918: 133, 919: 134, 920: 135, 921: 136, 922: 137, 923: 138, 924: 139, 925: 140, 926: 141, 927: 142, 928: 143, + 929: 144, 931: 145, 932: 146, 933: 147, 934: 148, 935: 149, 936: 150, 937: 151, 945: 152, 946: 153, 947: 154, 948: 155, 949: 156, 950: 157, 951: 158, 952: 159, + 953: 160, 954: 161, 955: 162, 956: 163, 957: 164, 958: 165, 959: 166, 960: 167, 961: 168, 963: 169, 962: 170, 964: 171, 965: 172, 966: 173, 967: 174, 968: 175, + 65535: 255, 969: 224, 940: 225, 941: 226, 942: 227, 970: 228, 943: 229, 972: 230, 973: 231, 971: 232, 974: 233, 902: 234, 904: 235, 905: 236, 906: 237, 908: 238, + 910: 239, 911: 240, 177: 241, 8805: 242, 8804: 243, 247: 246, 176: 248, 183: 250, 178: 253, 8718: 254, 8216: 96, 8217: 39, 8213: 45, 160: 32, 173: 45, 180: 39, + 8248: 94, 8764: 126, 168: 34, 8356: 76, 192: 65, 193: 65, 194: 65, 200: 69, 202: 69, 204: 73, 205: 73, 206: 73, 210: 79, 211: 79, 212: 79, 217: 85, + 218: 85, 219: 85, 221: 89, 253: 121, 938: 136, 939: 147, 912: 228, 944: 232, 900: 96, + }, + } + case 0x17d: // 381 + return &StringConverter{ + LangID: 381, + CharWidth: 1, + eReplace: 65533, + dReplace: 111, + dBuffer: []int{ + 0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 157, 10, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31, + 128, 129, 28, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7, + 144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26, + 32, 913, 914, 915, 916, 917, 918, 919, 920, 921, 91, 46, 60, 40, 43, 33, + 38, 922, 923, 924, 925, 926, 927, 928, 929, 931, 93, 36, 42, 41, 59, 94, + 45, 47, 932, 933, 934, 935, 936, 937, 938, 939, 124, 44, 37, 95, 62, 63, + 168, 902, 904, 905, 65535, 906, 908, 910, 911, 96, 58, 35, 64, 39, 61, 34, + 901, 97, 98, 99, 100, 101, 102, 103, 104, 105, 945, 946, 947, 948, 949, 950, + 176, 106, 107, 108, 109, 110, 111, 112, 113, 114, 951, 952, 953, 954, 955, 956, + 900, 126, 115, 116, 117, 118, 119, 120, 121, 122, 957, 958, 959, 960, 961, 963, + 163, 940, 941, 942, 970, 943, 972, 973, 971, 974, 962, 964, 965, 966, 967, 968, + 123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 173, 969, 912, 944, 8216, 8213, + 125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 177, 189, 65535, 183, 8217, 166, + 92, 65535, 83, 84, 85, 86, 87, 88, 89, 90, 178, 167, 65535, 65535, 171, 172, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 179, 169, 65535, 65535, 187, 159, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 156: 4, 9: 5, 134: 6, 127: 7, 151: 8, 141: 9, 142: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 157: 20, 10: 37, 8: 22, 135: 23, 24: 24, 25: 25, 146: 26, 143: 27, 28: 34, 29: 29, 30: 30, 31: 31, + 128: 32, 129: 33, 131: 35, 132: 36, 23: 38, 27: 39, 136: 40, 137: 41, 138: 42, 139: 43, 140: 44, 5: 45, 6: 46, 7: 47, 144: 48, 145: 49, + 22: 50, 147: 51, 148: 52, 149: 53, 150: 54, 4: 55, 152: 56, 153: 57, 154: 58, 155: 59, 20: 60, 21: 61, 158: 62, 26: 63, 32: 64, 913: 65, + 914: 66, 915: 67, 916: 68, 917: 69, 918: 70, 919: 71, 920: 72, 921: 73, 91: 74, 46: 75, 60: 76, 40: 77, 43: 78, 33: 79, 38: 80, 922: 81, + 923: 82, 924: 83, 925: 84, 926: 85, 927: 86, 928: 87, 929: 88, 931: 89, 93: 90, 36: 91, 42: 92, 41: 93, 59: 94, 94: 95, 45: 96, 47: 97, + 932: 98, 933: 99, 934: 100, 935: 101, 936: 102, 937: 103, 938: 104, 939: 105, 124: 106, 44: 107, 37: 108, 95: 109, 62: 110, 63: 111, 168: 112, 902: 113, + 904: 114, 905: 115, 65535: 253, 906: 117, 908: 118, 910: 119, 911: 120, 96: 121, 58: 122, 35: 123, 64: 124, 39: 125, 61: 126, 34: 127, 901: 128, 97: 129, + 98: 130, 99: 131, 100: 132, 101: 133, 102: 134, 103: 135, 104: 136, 105: 137, 945: 138, 946: 139, 947: 140, 948: 141, 949: 142, 950: 143, 176: 144, 106: 145, + 107: 146, 108: 147, 109: 148, 110: 149, 111: 150, 112: 151, 113: 152, 114: 153, 951: 154, 952: 155, 953: 156, 954: 157, 955: 158, 956: 159, 900: 160, 126: 161, + 115: 162, 116: 163, 117: 164, 118: 165, 119: 166, 120: 167, 121: 168, 122: 169, 957: 170, 958: 171, 959: 172, 960: 173, 961: 174, 963: 175, 163: 176, 940: 177, + 941: 178, 942: 179, 970: 180, 943: 181, 972: 182, 973: 183, 971: 184, 974: 185, 962: 186, 964: 187, 965: 188, 966: 189, 967: 190, 968: 191, 123: 192, 65: 193, + 66: 194, 67: 195, 68: 196, 69: 197, 70: 198, 71: 199, 72: 200, 73: 201, 173: 202, 969: 203, 912: 204, 944: 205, 8216: 206, 8213: 207, 125: 208, 74: 209, + 75: 210, 76: 211, 77: 212, 78: 213, 79: 214, 80: 215, 81: 216, 82: 217, 177: 218, 189: 219, 183: 221, 8217: 222, 166: 223, 92: 224, 83: 226, 84: 227, + 85: 228, 86: 229, 87: 230, 88: 231, 89: 232, 90: 233, 178: 234, 167: 235, 171: 238, 172: 239, 48: 240, 49: 241, 50: 242, 51: 243, 52: 244, 53: 245, + 54: 246, 55: 247, 56: 248, 57: 249, 179: 250, 169: 251, 187: 254, 159: 255, 8248: 95, 8764: 161, 376: 232, + }, + } + case 0x17e: // 382 + return &StringConverter{ + LangID: 382, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, + 929, 931, 932, 933, 934, 935, 936, 937, 945, 946, 947, 948, 949, 950, 951, 952, + 953, 954, 955, 956, 957, 958, 959, 960, 961, 963, 962, 964, 965, 966, 967, 968, + 9617, 9618, 9619, 9474, 9508, 9569, 9570, 9558, 9557, 9571, 9553, 9559, 9565, 9564, 9563, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 9566, 9567, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9575, + 9576, 9572, 9573, 9561, 9560, 9554, 9555, 9579, 9578, 9496, 9484, 9608, 9604, 9612, 9616, 9600, + 969, 940, 941, 942, 970, 943, 972, 973, 971, 974, 902, 904, 905, 906, 908, 910, + 911, 177, 8805, 8804, 938, 939, 247, 8776, 176, 8226, 183, 8730, 8319, 178, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 913: 128, 914: 129, 915: 130, 916: 131, 917: 132, 918: 133, 919: 134, 920: 135, 921: 136, 922: 137, 923: 138, 924: 139, 925: 140, 926: 141, 927: 142, 928: 143, + 929: 144, 931: 145, 932: 146, 933: 147, 934: 148, 935: 149, 936: 150, 937: 151, 945: 152, 946: 153, 947: 154, 948: 155, 949: 156, 950: 157, 951: 158, 952: 159, + 953: 160, 954: 161, 955: 162, 956: 163, 957: 164, 958: 165, 959: 166, 960: 167, 961: 168, 963: 169, 962: 170, 964: 171, 965: 172, 966: 173, 967: 174, 968: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 9569: 181, 9570: 182, 9558: 183, 9557: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 9564: 189, 9563: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 9566: 198, 9567: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 9575: 207, + 9576: 208, 9572: 209, 9573: 210, 9561: 211, 9560: 212, 9554: 213, 9555: 214, 9579: 215, 9578: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 9612: 221, 9616: 222, 9600: 223, + 969: 224, 940: 225, 941: 226, 942: 227, 970: 228, 943: 229, 972: 230, 973: 231, 971: 232, 974: 233, 902: 234, 904: 235, 905: 236, 906: 237, 908: 238, 910: 239, + 911: 240, 177: 241, 8805: 242, 8804: 243, 938: 244, 939: 245, 247: 246, 8776: 247, 176: 248, 8226: 249, 183: 250, 8730: 251, 8319: 252, 178: 253, 8718: 254, 160: 255, + }, + } + case 0x17f: // 383 + return &StringConverter{ + LangID: 383, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, + 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, + 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, + 65535, 65535, 65535, 65535, 65535, 260, 268, 280, 278, 65535, 65535, 65535, 65535, 302, 352, 172, + 65535, 65535, 65535, 65535, 65535, 65535, 370, 362, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 381, + 261, 269, 281, 279, 303, 353, 371, 363, 382, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, + 1025, 1105, 8805, 8804, 8220, 8221, 247, 65535, 176, 729, 183, 65535, 8470, 178, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1040: 128, 1041: 129, 1042: 130, 1043: 131, 1044: 132, 1045: 133, 1046: 134, 1047: 135, 1048: 136, 1049: 137, 1050: 138, 1051: 139, 1052: 140, 1053: 141, 1054: 142, 1055: 143, + 1056: 144, 1057: 145, 1058: 146, 1059: 147, 1060: 148, 1061: 149, 1062: 150, 1063: 151, 1064: 152, 1065: 153, 1066: 154, 1067: 155, 1068: 156, 1069: 157, 1070: 158, 1071: 159, + 1072: 160, 1073: 161, 1074: 162, 1075: 163, 1076: 164, 1077: 165, 1078: 166, 1079: 167, 1080: 168, 1081: 169, 1082: 170, 1083: 171, 1084: 172, 1085: 173, 1086: 174, 1087: 175, + 65535: 255, 260: 181, 268: 182, 280: 183, 278: 184, 302: 189, 352: 190, 172: 191, 370: 198, 362: 199, 381: 207, 261: 208, 269: 209, 281: 210, 279: 211, 303: 212, + 353: 213, 371: 214, 363: 215, 382: 216, 1088: 224, 1089: 225, 1090: 226, 1091: 227, 1092: 228, 1093: 229, 1094: 230, 1095: 231, 1096: 232, 1097: 233, 1098: 234, 1099: 235, + 1100: 236, 1101: 237, 1102: 238, 1103: 239, 1025: 240, 1105: 241, 8805: 242, 8804: 243, 8220: 244, 8221: 245, 247: 246, 176: 248, 729: 249, 183: 250, 8470: 252, 178: 253, + 8718: 254, 160: 32, 173: 45, + }, + } + case 0x180: // 384 + return &StringConverter{ + LangID: 384, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 239, 238, 236, 196, 197, + 201, 230, 198, 244, 246, 242, 251, 249, 255, 214, 220, 162, 163, 165, 8359, 402, + 225, 237, 243, 250, 241, 209, 170, 186, 191, 65535, 172, 189, 188, 161, 171, 187, + 65535, 65535, 65535, 65535, 65535, 260, 268, 280, 278, 65535, 65535, 65535, 65535, 302, 352, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 370, 362, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 381, + 261, 269, 281, 279, 303, 353, 371, 363, 382, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 945, 946, 915, 960, 931, 963, 956, 964, 934, 920, 937, 948, 65535, 216, 65535, 65535, + 65535, 177, 8805, 8804, 65535, 65535, 247, 65535, 176, 729, 183, 65535, 65535, 178, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 236: 141, 196: 142, 197: 143, + 201: 144, 230: 145, 198: 146, 244: 147, 246: 148, 242: 149, 251: 150, 249: 151, 255: 152, 214: 153, 220: 154, 162: 155, 163: 156, 165: 157, 8359: 158, 402: 159, + 225: 160, 237: 161, 243: 162, 250: 163, 241: 164, 209: 165, 170: 166, 186: 167, 191: 168, 65535: 255, 172: 170, 189: 171, 188: 172, 161: 173, 171: 174, 187: 175, + 260: 181, 268: 182, 280: 183, 278: 184, 302: 189, 352: 190, 370: 198, 362: 199, 381: 207, 261: 208, 269: 209, 281: 210, 279: 211, 303: 212, 353: 213, 371: 214, + 363: 215, 382: 216, 945: 224, 946: 225, 915: 226, 960: 227, 931: 228, 963: 229, 956: 230, 964: 231, 934: 232, 920: 233, 937: 234, 948: 235, 216: 237, 177: 241, + 8805: 242, 8804: 243, 247: 246, 176: 248, 729: 249, 183: 250, 178: 253, 8718: 254, 8216: 96, 8213: 45, 160: 32, 173: 45, 166: 124, 180: 39, 8248: 94, 8764: 126, + 8356: 76, 192: 65, 193: 65, 194: 65, 195: 65, 256: 65, 272: 68, 200: 69, 202: 69, 203: 69, 274: 69, 204: 73, 205: 73, 206: 73, 296: 73, 298: 73, + 310: 75, 315: 76, 325: 78, 210: 79, 211: 79, 212: 79, 213: 79, 332: 79, 342: 82, 358: 84, 217: 85, 218: 85, 219: 85, 360: 85, 221: 89, 290: 71, + 227: 97, 257: 97, 273: 100, 275: 101, 297: 105, 299: 105, 311: 107, 316: 108, 326: 110, 245: 111, 333: 111, 343: 114, 359: 116, 361: 117, 253: 121, 501: 103, + 223: 225, 63741: 159, + }, + } + case 0x181: // 385 + return &StringConverter{ + LangID: 385, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 902, 65535, 183, 172, 166, 8216, 8217, 904, 8213, 905, + 906, 938, 908, 65535, 65535, 910, 939, 169, 911, 178, 179, 940, 163, 941, 942, 943, + 970, 912, 972, 973, 913, 914, 915, 916, 917, 918, 919, 189, 920, 921, 171, 187, + 9617, 9618, 9619, 9474, 9508, 922, 923, 924, 925, 9571, 9553, 9559, 9565, 926, 927, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 928, 929, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 931, + 932, 933, 934, 935, 936, 937, 945, 946, 947, 9496, 9484, 9608, 9604, 948, 949, 9600, + 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 963, 962, 964, 180, + 173, 177, 965, 966, 967, 167, 968, 901, 176, 168, 969, 971, 944, 974, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 148, 902: 134, 183: 136, 172: 137, 166: 138, 8216: 139, 8217: 140, 904: 141, 8213: 142, 905: 143, 906: 144, 938: 145, 908: 146, 910: 149, 939: 150, 169: 151, + 911: 152, 178: 153, 179: 154, 940: 155, 163: 156, 941: 157, 942: 158, 943: 159, 970: 160, 912: 161, 972: 162, 973: 163, 913: 164, 914: 165, 915: 166, 916: 167, + 917: 168, 918: 169, 919: 170, 189: 171, 920: 172, 921: 173, 171: 174, 187: 175, 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 922: 181, 923: 182, 924: 183, + 925: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 926: 189, 927: 190, 9488: 191, 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 928: 198, 929: 199, + 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 931: 207, 932: 208, 933: 209, 934: 210, 935: 211, 936: 212, 937: 213, 945: 214, 946: 215, + 947: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 948: 221, 949: 222, 9600: 223, 950: 224, 951: 225, 952: 226, 953: 227, 954: 228, 955: 229, 956: 230, 957: 231, + 958: 232, 959: 233, 960: 234, 961: 235, 963: 236, 962: 237, 964: 238, 180: 239, 173: 240, 177: 241, 965: 242, 966: 243, 967: 244, 167: 245, 968: 246, 901: 247, + 176: 248, 168: 249, 969: 250, 971: 251, 944: 252, 974: 253, 8718: 254, 160: 255, 63742: 136, + }, + } + case 0x182: // 386 + return &StringConverter{ + LangID: 386, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 902, 231, 234, 235, 232, 239, 238, 904, 196, 905, + 906, 65535, 908, 244, 246, 910, 251, 249, 911, 214, 220, 940, 163, 941, 942, 943, + 970, 912, 972, 973, 913, 914, 915, 916, 917, 918, 919, 189, 920, 921, 171, 187, + 9617, 9618, 9619, 9474, 9508, 922, 923, 924, 925, 9571, 9553, 9559, 9565, 926, 927, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 928, 929, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 931, + 932, 933, 934, 935, 936, 937, 945, 946, 947, 9496, 9484, 9608, 9604, 948, 949, 9600, + 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 963, 962, 964, 180, + 173, 177, 965, 966, 967, 167, 968, 184, 176, 168, 969, 971, 944, 974, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 902: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 904: 141, 196: 142, 905: 143, + 906: 144, 65535: 145, 908: 146, 244: 147, 246: 148, 910: 149, 251: 150, 249: 151, 911: 152, 214: 153, 220: 154, 940: 155, 163: 156, 941: 157, 942: 158, 943: 159, + 970: 160, 912: 161, 972: 162, 973: 163, 913: 164, 914: 165, 915: 166, 916: 167, 917: 168, 918: 169, 919: 170, 189: 171, 920: 172, 921: 173, 171: 174, 187: 175, + 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 922: 181, 923: 182, 924: 183, 925: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 926: 189, 927: 190, 9488: 191, + 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 928: 198, 929: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 931: 207, + 932: 208, 933: 209, 934: 210, 935: 211, 936: 212, 937: 213, 945: 214, 946: 215, 947: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 948: 221, 949: 222, 9600: 223, + 950: 224, 951: 225, 952: 226, 953: 227, 954: 228, 955: 229, 956: 230, 957: 231, 958: 232, 959: 233, 960: 234, 961: 235, 963: 236, 962: 237, 964: 238, 180: 239, + 173: 240, 177: 241, 965: 242, 966: 243, 967: 244, 167: 245, 968: 246, 184: 247, 176: 248, 168: 249, 969: 250, 971: 251, 944: 252, 974: 253, 8718: 254, 160: 255, + }, + } + case 0x186: // 390 + return &StringConverter{ + LangID: 390, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 194, 224, 182, 231, 234, 235, 232, 239, 238, 819, 192, 167, + 201, 200, 202, 244, 203, 207, 251, 249, 164, 212, 220, 162, 163, 217, 219, 402, + 166, 180, 243, 250, 168, 184, 179, 713, 206, 65535, 172, 189, 188, 190, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 945, 946, 915, 960, 931, 963, 956, 964, 934, 920, 937, 948, 65535, 966, 949, 65535, + 65535, 177, 8805, 8804, 65535, 65535, 247, 65535, 176, 183, 65535, 65535, 65535, 178, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 194: 132, 224: 133, 182: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 819: 141, 192: 142, 167: 143, + 201: 144, 200: 145, 202: 146, 244: 147, 203: 148, 207: 149, 251: 150, 249: 151, 164: 152, 212: 153, 220: 154, 162: 155, 163: 156, 217: 157, 219: 158, 402: 159, + 166: 160, 180: 161, 243: 162, 250: 163, 168: 164, 184: 165, 179: 166, 713: 167, 206: 168, 65535: 255, 172: 170, 189: 171, 188: 172, 190: 173, 171: 174, 187: 175, + 945: 224, 946: 225, 915: 226, 960: 227, 931: 228, 963: 229, 956: 230, 964: 231, 934: 232, 920: 233, 937: 234, 948: 235, 966: 237, 949: 238, 177: 241, 8805: 242, + 8804: 243, 247: 246, 176: 248, 183: 249, 178: 253, 8718: 254, 8216: 96, 181: 230, 8213: 45, 175: 167, 160: 32, 173: 45, 8248: 94, 8764: 126, 8356: 76, 193: 65, + 195: 65, 197: 65, 204: 73, 205: 73, 210: 79, 211: 79, 213: 79, 352: 83, 218: 85, 221: 89, 376: 89, 225: 97, 227: 97, 229: 97, 236: 105, 237: 105, + 242: 111, 245: 111, 353: 115, 253: 121, 255: 121, 223: 225, 63741: 159, + }, + } + case 0x191: // 401 + return &StringConverter{ + LangID: 401, + CharWidth: 1, + eReplace: 65533, + dReplace: 254, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 188, 170, 226, 228, 193, 201, 205, 211, 214, 336, 218, 220, 368, 196, 197, + 229, 230, 198, 172, 174, 242, 161, 249, 255, 235, 238, 248, 163, 216, 215, 402, + 209, 186, 191, 189, 241, 225, 233, 237, 243, 246, 337, 250, 252, 369, 171, 187, + 65535, 65535, 65535, 65535, 65535, 224, 194, 192, 169, 65535, 65535, 65535, 65535, 162, 165, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 227, 195, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 164, + 240, 208, 202, 203, 200, 305, 231, 206, 207, 65535, 65535, 65535, 65535, 166, 204, 65535, + 234, 223, 232, 210, 245, 213, 181, 254, 222, 239, 236, 217, 253, 221, 175, 180, + 173, 177, 65535, 190, 182, 167, 247, 184, 176, 168, 183, 185, 179, 178, 8718, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 188: 129, 170: 130, 226: 131, 228: 132, 193: 133, 201: 134, 205: 135, 211: 136, 214: 137, 336: 138, 218: 139, 220: 140, 368: 141, 196: 142, 197: 143, + 229: 144, 230: 145, 198: 146, 172: 147, 174: 148, 242: 149, 161: 150, 249: 151, 255: 152, 235: 153, 238: 154, 248: 155, 163: 156, 216: 157, 215: 158, 402: 159, + 209: 160, 186: 161, 191: 162, 189: 163, 241: 164, 225: 165, 233: 166, 237: 167, 243: 168, 246: 169, 337: 170, 250: 171, 252: 172, 369: 173, 171: 174, 187: 175, + 65535: 242, 224: 181, 194: 182, 192: 183, 169: 184, 162: 189, 165: 190, 227: 198, 195: 199, 164: 207, 240: 208, 208: 209, 202: 210, 203: 211, 200: 212, 305: 213, + 231: 214, 206: 215, 207: 216, 166: 221, 204: 222, 234: 224, 223: 225, 232: 226, 210: 227, 245: 228, 213: 229, 181: 230, 254: 231, 222: 232, 239: 233, 236: 234, + 217: 235, 253: 236, 221: 237, 175: 238, 180: 239, 173: 240, 177: 241, 190: 243, 182: 244, 167: 245, 247: 246, 184: 247, 176: 248, 168: 249, 183: 250, 185: 251, + 179: 252, 178: 253, 8718: 254, 160: 255, 63741: 159, + }, + } + case 0x1f4: // 500 + return &StringConverter{ + LangID: 500, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 199, 252, 233, 226, 228, 224, 229, 231, 234, 235, 232, 239, 238, 236, 65535, 65535, + 65535, 65535, 65535, 244, 246, 242, 251, 249, 174, 8482, 65535, 65535, 65535, 65535, 65535, 65535, + 160, 161, 162, 402, 164, 165, 166, 167, 168, 169, 8248, 65535, 1548, 173, 171, 187, + 176, 177, 178, 179, 65535, 65535, 182, 945, 966, 185, 8764, 1563, 188, 189, 190, 1567, + 65535, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 65535, 65535, 65535, 65535, 191, + 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 65535, 65535, 65535, 65535, 65535, 65535, 215, 247, 946, 956, 163, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 199: 128, 252: 129, 233: 130, 226: 131, 228: 132, 224: 133, 229: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 236: 141, 65535: 255, 244: 147, + 246: 148, 242: 149, 251: 150, 249: 151, 174: 152, 8482: 153, 160: 160, 161: 161, 162: 162, 402: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, + 8248: 170, 1548: 172, 173: 173, 171: 174, 187: 175, 176: 176, 177: 177, 178: 178, 179: 179, 182: 182, 945: 183, 966: 184, 185: 185, 8764: 186, 1563: 187, 188: 188, + 189: 189, 190: 190, 1567: 191, 1569: 193, 1570: 194, 1571: 195, 1572: 196, 1573: 197, 1574: 198, 1575: 199, 1576: 200, 1577: 201, 1578: 202, 1579: 203, 1580: 204, 1581: 205, + 1582: 206, 1583: 207, 1584: 208, 1585: 209, 1586: 210, 1587: 211, 1588: 212, 1589: 213, 1590: 214, 1591: 215, 1592: 216, 1593: 217, 1594: 218, 191: 223, 1600: 224, 1601: 225, + 1602: 226, 1603: 227, 1604: 228, 1605: 229, 1606: 230, 1607: 231, 1608: 232, 1609: 233, 1610: 234, 1611: 235, 1612: 236, 1613: 237, 1614: 238, 1615: 239, 1616: 240, 1617: 241, + 1618: 242, 215: 249, 247: 250, 946: 251, 956: 252, 163: 253, 8718: 254, 63741: 163, + }, + } + case 0x1f8: // 504 + return &StringConverter{ + LangID: 504, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 160, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 1618, 1617, 1614, 64608, 1611, 63731, 1615, 64609, 1612, + 64606, 1616, 64610, 1613, 64607, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1600, 1601, 1602, 1603, 1604, 1605, 65535, 1606, 1607, 65535, 1608, 1609, 1610, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 160: 131, 1618: 151, 1617: 152, 1614: 153, 64608: 154, 1611: 155, 63731: 156, 1615: 157, 64609: 158, 1612: 159, 64606: 160, 1616: 161, 64610: 162, 1613: 163, 64607: 164, + 1569: 165, 1570: 166, 1571: 167, 1572: 168, 1573: 169, 1574: 170, 1575: 171, 1576: 172, 1577: 173, 171: 174, 187: 175, 1578: 224, 1579: 225, 1580: 226, 1581: 227, 1582: 228, + 1583: 229, 1584: 230, 1585: 231, 1586: 232, 1587: 233, 1588: 234, 1589: 235, 1590: 236, 1591: 237, 1592: 238, 1593: 239, 1594: 240, 1600: 241, 1601: 242, 1602: 243, 1603: 244, + 1604: 245, 1605: 246, 1606: 248, 1607: 249, 1608: 251, 1609: 252, 1610: 253, 8718: 254, + }, + } + case 0x1f9: // 505 + return &StringConverter{ + LangID: 505, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 233, 226, 65535, 224, 65535, 231, 234, 235, 232, 239, 238, 65535, 65535, 65535, + 65535, 65535, 65535, 244, 65535, 65535, 251, 249, 65535, 65535, 65535, 65535, 65535, 1611, 1612, 1613, + 1614, 1615, 1616, 1617, 1618, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 65535, 160, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 176, 1608, 1609, 1610, 1600, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 233: 130, 226: 131, 224: 133, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 244: 147, 251: 150, 249: 151, 1611: 157, 1612: 158, 1613: 159, + 1614: 160, 1615: 161, 1616: 162, 1617: 163, 1618: 164, 1569: 165, 1570: 166, 1571: 167, 1572: 168, 1573: 169, 1574: 170, 1575: 171, 1576: 172, 1577: 173, 160: 175, 1578: 224, + 1579: 225, 1580: 226, 1581: 227, 1582: 228, 1583: 229, 1584: 230, 1585: 231, 1586: 232, 1587: 233, 1588: 234, 1589: 235, 1590: 236, 1591: 237, 1592: 238, 1593: 239, 1594: 240, + 1601: 241, 1602: 242, 1603: 243, 1604: 244, 1605: 245, 1606: 246, 1607: 247, 176: 248, 1608: 249, 1609: 250, 1610: 251, 1600: 252, + }, + } + case 0x1fa: // 506 + return &StringConverter{ + LangID: 506, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 65535, 1579, 1580, 65535, 1581, 1582, + 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1601, 1602, 1603, 1604, + 1605, 1606, 1607, 1608, 1609, 1610, 1600, 1548, 1563, 1567, 65535, 65535, 65535, 65535, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 160, 65535, 65535, 65535, 65535, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1569: 128, 1570: 129, 1571: 130, 1572: 131, 1573: 132, 1574: 133, 1575: 134, 1576: 135, 1577: 136, 1578: 137, 65535: 255, 1579: 139, 1580: 140, 1581: 142, 1582: 143, 1583: 144, + 1584: 145, 1585: 146, 1586: 147, 1587: 148, 1588: 149, 1589: 150, 1590: 151, 1591: 152, 1592: 153, 1593: 154, 1594: 155, 1601: 156, 1602: 157, 1603: 158, 1604: 159, 1605: 160, + 1606: 161, 1607: 162, 1608: 163, 1609: 164, 1610: 165, 1600: 166, 1548: 167, 1563: 168, 1567: 169, 171: 174, 187: 175, 160: 249, 8718: 254, + }, + } + case 0x1fb: // 507 + return &StringConverter{ + LangID: 507, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1611, 1612, 233, 226, 1613, 224, 1614, 231, 234, 235, 232, 239, 238, 1615, 1616, 1617, + 1618, 63731, 64606, 244, 64607, 64608, 251, 249, 64609, 64610, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1600, 65535, 65535, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1611: 128, 1612: 129, 233: 130, 226: 131, 1613: 132, 224: 133, 1614: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 1615: 141, 1616: 142, 1617: 143, + 1618: 144, 63731: 145, 64606: 146, 244: 147, 64607: 148, 64608: 149, 251: 150, 249: 151, 64609: 152, 64610: 153, 65535: 255, 1569: 165, 1570: 166, 1571: 167, 1572: 168, 1573: 169, + 1574: 170, 1575: 171, 1576: 172, 1577: 173, 171: 174, 187: 175, 1578: 224, 1579: 225, 1580: 226, 1581: 227, 1582: 228, 1583: 229, 1584: 230, 1585: 231, 1586: 232, 1587: 233, + 1588: 234, 1589: 235, 1590: 236, 1591: 237, 1592: 238, 1593: 239, 1594: 240, 1601: 241, 1602: 242, 1603: 243, 1604: 244, 1605: 245, 1606: 246, 1607: 247, 1608: 248, 1609: 249, + 1610: 250, 1600: 251, 8718: 254, + }, + } + case 0x1fc: // 508 + return &StringConverter{ + LangID: 508, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 233, 226, 160, 224, 231, 234, 235, 232, 239, 238, 65535, 65535, 65535, 65535, + 65535, 1617, 1618, 244, 164, 1600, 251, 249, 1569, 1570, 1571, 1572, 163, 1573, 1574, 1575, + 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1590, 1591, 1592, 1593, 1594, 1601, 956, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, + 65535, 1611, 1612, 1613, 1614, 1615, 1616, 65535, 176, 65535, 65535, 65535, 65535, 178, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 233: 130, 226: 131, 160: 132, 224: 133, 231: 134, 234: 135, 235: 136, 232: 137, 239: 138, 238: 139, 1617: 145, 1618: 146, 244: 147, 164: 148, 1600: 149, + 251: 150, 249: 151, 1569: 152, 1570: 153, 1571: 154, 1572: 155, 163: 156, 1573: 157, 1574: 158, 1575: 159, 1576: 160, 1577: 161, 1578: 162, 1579: 163, 1580: 164, 1581: 165, + 1582: 166, 1583: 167, 1584: 168, 1585: 169, 1586: 170, 1587: 171, 1588: 172, 1589: 173, 171: 174, 187: 175, 1590: 224, 1591: 225, 1592: 226, 1593: 227, 1594: 228, 1601: 229, + 956: 230, 1602: 231, 1603: 232, 1604: 233, 1605: 234, 1606: 235, 1607: 236, 1608: 237, 1609: 238, 1610: 239, 1611: 241, 1612: 242, 1613: 243, 1614: 244, 1615: 245, 1616: 246, + 176: 248, 178: 253, 8718: 254, + }, + } + case 0x1fd: // 509 + return &StringConverter{ + LangID: 509, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 1600, 1617, 1618, 1614, 64608, 1611, 63731, 1615, 64609, 1612, 64606, 1616, 64610, 1613, 64607, + 65535, 1569, 1570, 1571, 1572, 1573, 1574, 65535, 1575, 1576, 65535, 1577, 1578, 65535, 1579, 1580, + 65535, 1581, 1582, 65535, 1583, 65535, 1584, 1585, 65535, 1586, 65535, 1587, 1588, 1589, 1590, 1591, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1592, 1593, 1594, 65535, 1601, 65535, 1602, 1603, 65535, 65535, 1604, 65269, 65271, 65273, 65275, 1605, + 1606, 65535, 65535, 1607, 1608, 65535, 1609, 65535, 1610, 247, 215, 65535, 171, 187, 65535, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 254, 1600: 129, 1617: 130, 1618: 131, 1614: 132, 64608: 133, 1611: 134, 63731: 135, 1615: 136, 64609: 137, 1612: 138, 64606: 139, 1616: 140, 64610: 141, 1613: 142, 64607: 143, + 1569: 145, 1570: 146, 1571: 147, 1572: 148, 1573: 149, 1574: 150, 1575: 152, 1576: 153, 1577: 155, 1578: 156, 1579: 158, 1580: 159, 1581: 161, 1582: 162, 1583: 164, 1584: 166, + 1585: 167, 1586: 169, 1587: 171, 1588: 172, 1589: 173, 1590: 174, 1591: 175, 1592: 224, 1593: 225, 1594: 226, 1601: 228, 1602: 230, 1603: 231, 1604: 234, 65269: 235, 65271: 236, + 65273: 237, 65275: 238, 1605: 239, 1606: 240, 1607: 243, 1608: 244, 1609: 246, 1610: 248, 247: 249, 215: 250, 171: 252, 187: 253, 160: 255, + }, + } + case 0x1ff: // 511 + return &StringConverter{ + LangID: 511, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 233, 226, 65535, 224, 65535, 231, 234, 235, 232, 239, 238, 65535, 65535, 160, + 65535, 65535, 65535, 244, 164, 1618, 251, 249, 1617, 1614, 64608, 1611, 63731, 1615, 64609, 1612, + 64606, 1616, 64610, 1613, 64607, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1600, 1601, 1602, 1603, 1604, 1605, 65535, 1606, 1607, 65535, 1608, 1609, 1610, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 233: 130, 226: 131, 224: 133, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 160: 143, 244: 147, 164: 148, 1618: 149, 251: 150, 249: 151, + 1617: 152, 1614: 153, 64608: 154, 1611: 155, 63731: 156, 1615: 157, 64609: 158, 1612: 159, 64606: 160, 1616: 161, 64610: 162, 1613: 163, 64607: 164, 1569: 165, 1570: 166, 1571: 167, + 1572: 168, 1573: 169, 1574: 170, 1575: 171, 1576: 172, 1577: 173, 171: 174, 187: 175, 1578: 224, 1579: 225, 1580: 226, 1581: 227, 1582: 228, 1583: 229, 1584: 230, 1585: 231, + 1586: 232, 1587: 233, 1588: 234, 1589: 235, 1590: 236, 1591: 237, 1592: 238, 1593: 239, 1594: 240, 1600: 241, 1601: 242, 1602: 243, 1603: 244, 1604: 245, 1605: 246, 1606: 248, + 1607: 249, 1608: 251, 1609: 252, 1610: 253, 8718: 254, + }, + } + case 0x202: // 514 + return &StringConverter{ + LangID: 514, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 63713, 63712, 63711, 63710, 63709, 1642, 63675, 63707, 63705, 63706, 63704, 63703, 1548, 63701, 63700, 63699, + 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 63688, 1563, 63686, 63685, 63684, 1567, + 63673, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 63683, 63682, 63681, 63680, 63679, + 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 65535, 65535, 65535, 64608, 64609, 64610, 65535, 65535, 63678, 63677, 63676, 63672, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 63713: 160, 63712: 161, 63711: 162, 63710: 163, 63709: 164, 1642: 165, 63675: 166, 63707: 167, 63705: 168, 63706: 169, 63704: 170, 63703: 171, 1548: 172, 63701: 173, 63700: 174, + 63699: 175, 1632: 176, 1633: 177, 1634: 178, 1635: 179, 1636: 180, 1637: 181, 1638: 182, 1639: 183, 1640: 184, 1641: 185, 63688: 186, 1563: 187, 63686: 188, 63685: 189, 63684: 190, + 1567: 191, 63673: 192, 1569: 193, 1570: 194, 1571: 195, 1572: 196, 1573: 197, 1574: 198, 1575: 199, 1576: 200, 1577: 201, 1578: 202, 1579: 203, 1580: 204, 1581: 205, 1582: 206, + 1583: 207, 1584: 208, 1585: 209, 1586: 210, 1587: 211, 1588: 212, 1589: 213, 1590: 214, 1591: 215, 1592: 216, 1593: 217, 1594: 218, 63683: 219, 63682: 220, 63681: 221, 63680: 222, + 63679: 223, 1600: 224, 1601: 225, 1602: 226, 1603: 227, 1604: 228, 1605: 229, 1606: 230, 1607: 231, 1608: 232, 1609: 233, 1610: 234, 1611: 235, 1612: 236, 1613: 237, 1614: 238, + 1615: 239, 1616: 240, 1617: 241, 1618: 242, 64608: 246, 64609: 247, 64610: 248, 63678: 251, 63677: 252, 63676: 253, 63672: 254, + }, + } + case 0x22a: // 554 + return &StringConverter{ + LangID: 554, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 160, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 1618, 1617, 1614, 65535, 1611, 65535, 1615, 65535, 1612, + 65535, 1616, 65535, 1613, 65535, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1600, 1601, 1602, 1603, 1604, 1605, 65535, 1606, 1607, 65535, 1608, 1609, 1610, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 160: 131, 1618: 151, 1617: 152, 1614: 153, 1611: 155, 1615: 157, 1612: 159, 1616: 161, 1613: 163, 1569: 165, 1570: 166, 1571: 167, 1572: 168, 1573: 169, 1574: 170, + 1575: 171, 1576: 172, 1577: 173, 171: 174, 187: 175, 1578: 224, 1579: 225, 1580: 226, 1581: 227, 1582: 228, 1583: 229, 1584: 230, 1585: 231, 1586: 232, 1587: 233, 1588: 234, + 1589: 235, 1590: 236, 1591: 237, 1592: 238, 1593: 239, 1594: 240, 1600: 241, 1601: 242, 1602: 243, 1603: 244, 1604: 245, 1605: 246, 1606: 248, 1607: 249, 1608: 251, 1609: 252, + 1610: 253, 8718: 254, + }, + } + case 0x22b: // 555 + return &StringConverter{ + LangID: 555, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 233, 226, 65535, 224, 65535, 231, 234, 235, 232, 239, 238, 65535, 65535, 65535, + 65535, 65535, 65535, 244, 65535, 65535, 251, 249, 65535, 65535, 65535, 65535, 65535, 1611, 1612, 1613, + 1614, 1615, 1616, 1617, 1618, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 65535, 160, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 176, 1608, 1609, 1610, 1600, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 233: 130, 226: 131, 224: 133, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 244: 147, 251: 150, 249: 151, 1611: 157, 1612: 158, 1613: 159, + 1614: 160, 1615: 161, 1616: 162, 1617: 163, 1618: 164, 1569: 165, 1570: 166, 1571: 167, 1572: 168, 1573: 169, 1574: 170, 1575: 171, 1576: 172, 1577: 173, 160: 175, 1578: 224, + 1579: 225, 1580: 226, 1581: 227, 1582: 228, 1583: 229, 1584: 230, 1585: 231, 1586: 232, 1587: 233, 1588: 234, 1589: 235, 1590: 236, 1591: 237, 1592: 238, 1593: 239, 1594: 240, + 1601: 241, 1602: 242, 1603: 243, 1604: 244, 1605: 245, 1606: 246, 1607: 247, 176: 248, 1608: 249, 1609: 250, 1610: 251, 1600: 252, + }, + } + case 0x22c: // 556 + return &StringConverter{ + LangID: 556, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 65535, 1579, 1580, 65535, 1581, 1582, + 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1601, 1602, 1603, 1604, + 1605, 1606, 1607, 1608, 1609, 1610, 1600, 1548, 1563, 1567, 65535, 65535, 65535, 65535, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 160, 65535, 65535, 65535, 65535, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1569: 128, 1570: 129, 1571: 130, 1572: 131, 1573: 132, 1574: 133, 1575: 134, 1576: 135, 1577: 136, 1578: 137, 65535: 255, 1579: 139, 1580: 140, 1581: 142, 1582: 143, 1583: 144, + 1584: 145, 1585: 146, 1586: 147, 1587: 148, 1588: 149, 1589: 150, 1590: 151, 1591: 152, 1592: 153, 1593: 154, 1594: 155, 1601: 156, 1602: 157, 1603: 158, 1604: 159, 1605: 160, + 1606: 161, 1607: 162, 1608: 163, 1609: 164, 1610: 165, 1600: 166, 1548: 167, 1563: 168, 1567: 169, 171: 174, 187: 175, 160: 249, 8718: 254, + }, + } + case 0x22d: // 557 + return &StringConverter{ + LangID: 557, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1611, 1612, 233, 226, 1613, 224, 1614, 231, 234, 235, 232, 239, 238, 1615, 1616, 1617, + 1618, 65535, 65535, 244, 65535, 65535, 251, 249, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1600, 65535, 65535, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1611: 128, 1612: 129, 233: 130, 226: 131, 1613: 132, 224: 133, 1614: 134, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 1615: 141, 1616: 142, 1617: 143, + 1618: 144, 65535: 255, 244: 147, 251: 150, 249: 151, 1569: 165, 1570: 166, 1571: 167, 1572: 168, 1573: 169, 1574: 170, 1575: 171, 1576: 172, 1577: 173, 171: 174, 187: 175, + 1578: 224, 1579: 225, 1580: 226, 1581: 227, 1582: 228, 1583: 229, 1584: 230, 1585: 231, 1586: 232, 1587: 233, 1588: 234, 1589: 235, 1590: 236, 1591: 237, 1592: 238, 1593: 239, + 1594: 240, 1601: 241, 1602: 242, 1603: 243, 1604: 244, 1605: 245, 1606: 246, 1607: 247, 1608: 248, 1609: 249, 1610: 250, 1600: 251, 8718: 254, + }, + } + case 0x22e: // 558 + return &StringConverter{ + LangID: 558, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 233, 226, 65535, 224, 65535, 231, 234, 235, 232, 239, 238, 65535, 65535, 65535, + 65535, 1617, 1618, 244, 164, 1600, 251, 249, 1569, 1570, 1571, 1572, 163, 1573, 1574, 1575, + 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 171, 187, + 9617, 9618, 9619, 9474, 9508, 9569, 9570, 9558, 9557, 9571, 9553, 9559, 9565, 9564, 9563, 9488, + 9492, 9524, 9516, 9500, 9472, 9532, 9566, 9567, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9575, + 9576, 9572, 9573, 9561, 9560, 9554, 9555, 9579, 9578, 9496, 9484, 9608, 9604, 9612, 9616, 9600, + 1590, 1591, 1592, 1593, 1594, 1601, 181, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, + 8801, 1611, 1612, 1613, 1614, 1615, 1616, 8776, 176, 8729, 183, 8730, 8319, 178, 9632, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 144, 233: 130, 226: 131, 224: 133, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 1617: 145, 1618: 146, 244: 147, 164: 148, 1600: 149, 251: 150, + 249: 151, 1569: 152, 1570: 153, 1571: 154, 1572: 155, 163: 156, 1573: 157, 1574: 158, 1575: 159, 1576: 160, 1577: 161, 1578: 162, 1579: 163, 1580: 164, 1581: 165, 1582: 166, + 1583: 167, 1584: 168, 1585: 169, 1586: 170, 1587: 171, 1588: 172, 1589: 173, 171: 174, 187: 175, 9617: 176, 9618: 177, 9619: 178, 9474: 179, 9508: 180, 9569: 181, 9570: 182, + 9558: 183, 9557: 184, 9571: 185, 9553: 186, 9559: 187, 9565: 188, 9564: 189, 9563: 190, 9488: 191, 9492: 192, 9524: 193, 9516: 194, 9500: 195, 9472: 196, 9532: 197, 9566: 198, + 9567: 199, 9562: 200, 9556: 201, 9577: 202, 9574: 203, 9568: 204, 9552: 205, 9580: 206, 9575: 207, 9576: 208, 9572: 209, 9573: 210, 9561: 211, 9560: 212, 9554: 213, 9555: 214, + 9579: 215, 9578: 216, 9496: 217, 9484: 218, 9608: 219, 9604: 220, 9612: 221, 9616: 222, 9600: 223, 1590: 224, 1591: 225, 1592: 226, 1593: 227, 1594: 228, 1601: 229, 181: 230, + 1602: 231, 1603: 232, 1604: 233, 1605: 234, 1606: 235, 1607: 236, 1608: 237, 1609: 238, 1610: 239, 8801: 240, 1611: 241, 1612: 242, 1613: 243, 1614: 244, 1615: 245, 1616: 246, + 8776: 247, 176: 248, 8729: 249, 183: 250, 8730: 251, 8319: 252, 178: 253, 9632: 254, 160: 255, + }, + } + case 0x22f: // 559 + return &StringConverter{ + LangID: 559, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 1600, 1617, 1618, 1614, 65535, 1611, 65535, 1615, 65535, 1612, 65535, 1616, 65535, 1613, 65535, + 65535, 1569, 1570, 1571, 1572, 1573, 1574, 65535, 1575, 1576, 65535, 1577, 1578, 65535, 1579, 1580, + 65535, 1581, 1582, 65535, 1583, 65535, 1584, 1585, 65535, 1586, 65535, 1587, 1588, 1589, 1590, 1591, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1592, 1593, 1594, 65535, 1601, 65535, 1602, 1603, 65535, 65535, 1604, 65535, 65535, 65535, 65535, 1605, + 1606, 65535, 65535, 1607, 1608, 65535, 1609, 65535, 1610, 247, 215, 65535, 171, 187, 65535, 160, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 254, 1600: 129, 1617: 130, 1618: 131, 1614: 132, 1611: 134, 1615: 136, 1612: 138, 1616: 140, 1613: 142, 1569: 145, 1570: 146, 1571: 147, 1572: 148, 1573: 149, 1574: 150, + 1575: 152, 1576: 153, 1577: 155, 1578: 156, 1579: 158, 1580: 159, 1581: 161, 1582: 162, 1583: 164, 1584: 166, 1585: 167, 1586: 169, 1587: 171, 1588: 172, 1589: 173, 1590: 174, + 1591: 175, 1592: 224, 1593: 225, 1594: 226, 1601: 228, 1602: 230, 1603: 231, 1604: 234, 1605: 239, 1606: 240, 1607: 243, 1608: 244, 1609: 246, 1610: 248, 247: 249, 215: 250, + 171: 252, 187: 253, 160: 255, + }, + } + case 0x230: // 560 + return &StringConverter{ + LangID: 560, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 8364, 1662, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 1657, 8249, 338, 1670, 1688, 1672, + 1711, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 1705, 8482, 1681, 8250, 339, 8204, 8205, 1722, + 160, 1548, 162, 163, 164, 165, 166, 167, 168, 169, 1726, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1563, 187, 188, 189, 190, 1567, + 1729, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 215, 1591, 1592, 1593, 1594, 1600, 1601, 1602, 1603, + 224, 1604, 226, 1605, 1606, 1607, 1608, 231, 232, 233, 234, 235, 1609, 1610, 238, 239, + 1611, 1612, 1613, 1614, 244, 1615, 1616, 247, 1617, 249, 1618, 251, 252, 8206, 8207, 1746, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 8364: 128, 1662: 129, 8218: 130, 402: 131, 8222: 132, 8230: 133, 8224: 134, 8225: 135, 710: 136, 8240: 137, 1657: 138, 8249: 139, 338: 140, 1670: 141, 1688: 142, 1672: 143, + 1711: 144, 8216: 145, 8217: 146, 8220: 147, 8221: 148, 8226: 149, 8211: 150, 8212: 151, 1705: 152, 8482: 153, 1681: 154, 8250: 155, 339: 156, 8204: 157, 8205: 158, 1722: 159, + 160: 160, 1548: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 1726: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 1563: 186, 187: 187, 188: 188, 189: 189, 190: 190, 1567: 191, + 1729: 192, 1569: 193, 1570: 194, 1571: 195, 1572: 196, 1573: 197, 1574: 198, 1575: 199, 1576: 200, 1577: 201, 1578: 202, 1579: 203, 1580: 204, 1581: 205, 1582: 206, 1583: 207, + 1584: 208, 1585: 209, 1586: 210, 1587: 211, 1588: 212, 1589: 213, 1590: 214, 215: 215, 1591: 216, 1592: 217, 1593: 218, 1594: 219, 1600: 220, 1601: 221, 1602: 222, 1603: 223, + 224: 224, 1604: 225, 226: 226, 1605: 227, 1606: 228, 1607: 229, 1608: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 1609: 236, 1610: 237, 238: 238, 239: 239, + 1611: 240, 1612: 241, 1613: 242, 1614: 243, 244: 244, 1615: 245, 1616: 246, 247: 247, 1617: 248, 249: 249, 1618: 250, 251: 251, 252: 252, 8206: 253, 8207: 254, 1746: 255, + 192: 65, 194: 65, 199: 67, 200: 69, 201: 69, 202: 69, 203: 69, 206: 73, 207: 73, 212: 79, 217: 85, 219: 85, 220: 85, 401: 70, 1740: 237, 64342: 129, + 64343: 129, 64344: 129, 64345: 129, 64358: 138, 64359: 138, 64360: 138, 64361: 138, 64378: 141, 64379: 141, 64380: 141, 64381: 141, 64392: 143, 64393: 143, 64394: 142, 64395: 142, 64396: 154, + 64397: 154, 64398: 152, 64399: 152, 64400: 152, 64401: 152, 64402: 144, 64403: 144, 64404: 144, 64405: 144, 64414: 159, 64415: 159, 64422: 192, 64423: 192, 64424: 192, 64425: 192, 64426: 170, + 64427: 170, 64428: 170, 64429: 170, 64430: 255, 64431: 255, 65136: 240, 65137: 240, 65138: 241, 65140: 242, 65142: 243, 65143: 243, 65144: 245, 65145: 245, 65146: 246, 65147: 246, 65148: 248, + 65149: 248, 65150: 250, 65151: 250, 65152: 193, 65153: 194, 65154: 194, 65155: 195, 65156: 195, 65157: 196, 65158: 196, 65159: 197, 65160: 197, 65161: 198, 65162: 198, 65163: 198, 65164: 198, + 65165: 199, 65166: 199, 65167: 200, 65168: 200, 65169: 200, 65170: 200, 65171: 201, 65172: 201, 65173: 202, 65174: 202, 65175: 202, 65176: 202, 65177: 203, 65178: 203, 65179: 203, 65180: 203, + 65181: 204, 65182: 204, 65183: 204, 65184: 204, 65185: 205, 65186: 205, 65187: 205, 65188: 205, 65189: 206, 65190: 206, 65191: 206, 65192: 206, 65193: 207, 65194: 207, 65195: 208, 65196: 208, + 65197: 209, 65198: 209, 65199: 210, 65200: 210, 65201: 211, 65202: 211, 65203: 211, 65204: 211, 65205: 212, 65206: 212, 65207: 212, 65208: 212, 65209: 213, 65210: 213, 65211: 213, 65212: 213, + 65213: 214, 65214: 214, 65215: 214, 65216: 214, 65217: 216, 65218: 216, 65219: 216, 65220: 216, 65221: 217, 65222: 217, 65223: 217, 65224: 217, 65225: 218, 65226: 218, 65227: 218, 65228: 218, + 65229: 219, 65230: 219, 65231: 219, 65232: 219, 65233: 221, 65234: 221, 65235: 221, 65236: 221, 65237: 222, 65238: 222, 65239: 222, 65240: 222, 65241: 223, 65242: 223, 65243: 223, 65244: 223, + 65245: 225, 65246: 225, 65247: 225, 65248: 225, 65249: 227, 65250: 227, 65251: 227, 65252: 227, 65253: 228, 65254: 228, 65255: 228, 65256: 228, 65257: 229, 65258: 229, 65259: 229, 65260: 229, + 65261: 230, 65262: 230, 65263: 236, 65264: 236, 65265: 237, 65266: 237, 65267: 237, 65268: 237, 65281: 33, 65282: 34, 65283: 35, 65284: 36, 65285: 37, 65286: 38, 65287: 39, 65288: 40, + 65289: 41, 65290: 42, 65291: 43, 65292: 44, 65293: 45, 65294: 46, 65295: 47, 65296: 48, 65297: 49, 65298: 50, 65299: 51, 65300: 52, 65301: 53, 65302: 54, 65303: 55, 65304: 56, + 65305: 57, 65306: 58, 65307: 59, 65308: 60, 65309: 61, 65310: 62, 65312: 64, 65313: 65, 65314: 66, 65315: 67, 65316: 68, 65317: 69, 65318: 70, 65319: 71, 65320: 72, 65321: 73, + 65322: 74, 65323: 75, 65324: 76, 65325: 77, 65326: 78, 65327: 79, 65328: 80, 65329: 81, 65330: 82, 65331: 83, 65332: 84, 65333: 85, 65334: 86, 65335: 87, 65336: 88, 65337: 89, + 65338: 90, 65339: 91, 65340: 92, 65341: 93, 65342: 94, 65343: 95, 65344: 96, 65345: 97, 65346: 98, 65347: 99, 65348: 100, 65349: 101, 65350: 102, 65351: 103, 65352: 104, 65353: 105, + 65354: 106, 65355: 107, 65356: 108, 65357: 109, 65358: 110, 65359: 111, 65360: 112, 65361: 113, 65362: 114, 65363: 115, 65364: 116, 65365: 117, 65366: 118, 65367: 119, 65368: 120, 65369: 121, + 65370: 122, 65371: 123, 65372: 124, 65373: 125, 65374: 126, + }, + } + case 0x231: // 561 + return &StringConverter{ + LangID: 561, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 233, 226, 65535, 224, 65535, 231, 234, 235, 232, 239, 238, 65535, 65535, 160, + 65535, 65535, 65535, 244, 164, 1618, 251, 249, 1617, 1614, 65535, 1611, 65535, 1615, 65535, 1612, + 65535, 1616, 65535, 1613, 65535, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 171, 187, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1600, 1601, 1602, 1603, 1604, 1605, 65535, 1606, 1607, 65535, 1608, 1609, 1610, 8718, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, 233: 130, 226: 131, 224: 133, 231: 135, 234: 136, 235: 137, 232: 138, 239: 139, 238: 140, 160: 143, 244: 147, 164: 148, 1618: 149, 251: 150, 249: 151, + 1617: 152, 1614: 153, 1611: 155, 1615: 157, 1612: 159, 1616: 161, 1613: 163, 1569: 165, 1570: 166, 1571: 167, 1572: 168, 1573: 169, 1574: 170, 1575: 171, 1576: 172, 1577: 173, + 171: 174, 187: 175, 1578: 224, 1579: 225, 1580: 226, 1581: 227, 1582: 228, 1583: 229, 1584: 230, 1585: 231, 1586: 232, 1587: 233, 1588: 234, 1589: 235, 1590: 236, 1591: 237, + 1592: 238, 1593: 239, 1594: 240, 1600: 241, 1601: 242, 1602: 243, 1603: 244, 1604: 245, 1605: 246, 1606: 248, 1607: 249, 1608: 251, 1609: 252, 1610: 253, 8718: 254, + }, + } + case 0x233: // 563 + return &StringConverter{ + LangID: 563, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, + 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 65535, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 956, 182, 8718, 184, 185, 65535, 187, 65535, 65535, 65535, 191, + 1593, 1594, 1601, 1602, 1603, 197, 198, 199, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1600, + 272, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 946, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 273, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 1611: 128, 1612: 129, 1613: 130, 1614: 131, 1615: 132, 1616: 133, 1617: 134, 1618: 135, 1569: 136, 1570: 137, 1571: 138, 1572: 139, 1573: 140, 1574: 141, 1575: 142, 1576: 143, + 1577: 144, 1578: 145, 1579: 146, 1580: 147, 1581: 148, 1582: 149, 1583: 150, 1584: 151, 1585: 152, 1586: 153, 1587: 154, 1588: 155, 1589: 156, 1590: 157, 1591: 158, 1592: 159, + 160: 160, 161: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 65535: 190, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 956: 181, 182: 182, 8718: 183, 184: 184, 185: 185, 187: 187, 191: 191, 1593: 192, 1594: 193, 1601: 194, 1602: 195, + 1603: 196, 197: 197, 198: 198, 199: 199, 1604: 200, 1605: 201, 1606: 202, 1607: 203, 1608: 204, 1609: 205, 1610: 206, 1600: 207, 272: 208, 209: 209, 210: 210, 211: 211, + 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 221: 221, 222: 222, 946: 223, 224: 224, 225: 225, 226: 226, 227: 227, + 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, 273: 240, 241: 241, 242: 242, 243: 243, + 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 253: 253, 254: 254, 255: 255, + }, + } + case 0x235: // 565 + return &StringConverter{ + LangID: 565, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 160, 199, 201, 209, 214, 220, 225, 224, 226, 228, 1722, 171, 231, 233, 232, + 234, 235, 8230, 236, 238, 239, 241, 243, 187, 244, 246, 247, 250, 249, 251, 252, + 63713, 63712, 63711, 63710, 63709, 1642, 63675, 63707, 63705, 63706, 215, 63703, 1548, 63701, 63700, 63699, + 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 63688, 1563, 63686, 63685, 63684, 1567, + 1645, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 63683, 63682, 63681, 63680, 63679, + 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 1662, 1657, 1670, 1749, 1700, 1711, 1672, 1681, 63678, 63677, 63676, 1688, 1746, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 160: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 1722: 139, 171: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 8230: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 187: 152, 244: 153, 246: 154, 247: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 63713: 160, 63712: 161, 63711: 162, 63710: 163, 63709: 164, 1642: 165, 63675: 166, 63707: 167, 63705: 168, 63706: 169, 215: 170, 63703: 171, 1548: 172, 63701: 173, 63700: 174, 63699: 175, + 1632: 176, 1633: 177, 1634: 178, 1635: 179, 1636: 180, 1637: 181, 1638: 182, 1639: 183, 1640: 184, 1641: 185, 63688: 186, 1563: 187, 63686: 188, 63685: 189, 63684: 190, 1567: 191, + 1645: 192, 1569: 193, 1570: 194, 1571: 195, 1572: 196, 1573: 197, 1574: 198, 1575: 199, 1576: 200, 1577: 201, 1578: 202, 1579: 203, 1580: 204, 1581: 205, 1582: 206, 1583: 207, + 1584: 208, 1585: 209, 1586: 210, 1587: 211, 1588: 212, 1589: 213, 1590: 214, 1591: 215, 1592: 216, 1593: 217, 1594: 218, 63683: 219, 63682: 220, 63681: 221, 63680: 222, 63679: 223, + 1600: 224, 1601: 225, 1602: 226, 1603: 227, 1604: 228, 1605: 229, 1606: 230, 1607: 231, 1608: 232, 1609: 233, 1610: 234, 1611: 235, 1612: 236, 1613: 237, 1614: 238, 1615: 239, + 1616: 240, 1617: 241, 1618: 242, 1662: 243, 1657: 244, 1670: 245, 1749: 246, 1700: 247, 1711: 248, 1672: 249, 1681: 250, 63678: 251, 63677: 252, 63676: 253, 1688: 254, 1746: 255, + }, + } + case 0x236: // 566 + return &StringConverter{ + LangID: 566, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 160, 199, 201, 209, 214, 220, 225, 224, 226, 228, 1722, 171, 231, 233, 232, + 234, 235, 8230, 236, 238, 239, 241, 243, 187, 244, 246, 247, 250, 249, 251, 252, + 63713, 63712, 63711, 63710, 63709, 1642, 63675, 63707, 63705, 63706, 215, 63703, 1548, 63701, 63700, 63699, + 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 63688, 1563, 63686, 63685, 63684, 1567, + 1645, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 63683, 63682, 63681, 63680, 63679, + 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 1662, 1657, 1670, 1749, 1700, 1711, 1672, 1681, 63678, 63677, 63676, 1688, 1746, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 160: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 1722: 139, 171: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 8230: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 187: 152, 244: 153, 246: 154, 247: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 63713: 160, 63712: 161, 63711: 162, 63710: 163, 63709: 164, 1642: 165, 63675: 166, 63707: 167, 63705: 168, 63706: 169, 215: 170, 63703: 171, 1548: 172, 63701: 173, 63700: 174, 63699: 175, + 1632: 176, 1633: 177, 1634: 178, 1635: 179, 1636: 180, 1637: 181, 1638: 182, 1639: 183, 1640: 184, 1641: 185, 63688: 186, 1563: 187, 63686: 188, 63685: 189, 63684: 190, 1567: 191, + 1645: 192, 1569: 193, 1570: 194, 1571: 195, 1572: 196, 1573: 197, 1574: 198, 1575: 199, 1576: 200, 1577: 201, 1578: 202, 1579: 203, 1580: 204, 1581: 205, 1582: 206, 1583: 207, + 1584: 208, 1585: 209, 1586: 210, 1587: 211, 1588: 212, 1589: 213, 1590: 214, 1591: 215, 1592: 216, 1593: 217, 1594: 218, 63683: 219, 63682: 220, 63681: 221, 63680: 222, 63679: 223, + 1600: 224, 1601: 225, 1602: 226, 1603: 227, 1604: 228, 1605: 229, 1606: 230, 1607: 231, 1608: 232, 1609: 233, 1610: 234, 1611: 235, 1612: 236, 1613: 237, 1614: 238, 1615: 239, + 1616: 240, 1617: 241, 1618: 242, 1662: 243, 1657: 244, 1670: 245, 1749: 246, 1700: 247, 1711: 248, 1672: 249, 1681: 250, 63678: 251, 63677: 252, 63676: 253, 1688: 254, 1746: 255, + }, + } + case 0x237: // 567 + return &StringConverter{ + LangID: 567, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 11, 12, 10, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 196, 160, 199, 201, 209, 214, 220, 225, 224, 226, 228, 1722, 171, 231, 233, 232, + 234, 235, 8230, 236, 238, 239, 241, 243, 187, 244, 246, 247, 250, 249, 251, 252, + 63713, 63712, 63711, 63710, 63709, 1642, 63675, 63707, 63705, 63706, 215, 63703, 1548, 63701, 63700, 63699, + 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 63688, 1563, 63686, 63685, 63684, 1567, + 1645, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 63683, 63682, 63681, 63680, 63679, + 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 1662, 1657, 1670, 1749, 1700, 1711, 1672, 1681, 63678, 63677, 63676, 1688, 1746, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 13: 10, 11: 11, 12: 12, 10: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 196: 128, 160: 129, 199: 130, 201: 131, 209: 132, 214: 133, 220: 134, 225: 135, 224: 136, 226: 137, 228: 138, 1722: 139, 171: 140, 231: 141, 233: 142, 232: 143, + 234: 144, 235: 145, 8230: 146, 236: 147, 238: 148, 239: 149, 241: 150, 243: 151, 187: 152, 244: 153, 246: 154, 247: 155, 250: 156, 249: 157, 251: 158, 252: 159, + 63713: 160, 63712: 161, 63711: 162, 63710: 163, 63709: 164, 1642: 165, 63675: 166, 63707: 167, 63705: 168, 63706: 169, 215: 170, 63703: 171, 1548: 172, 63701: 173, 63700: 174, 63699: 175, + 1632: 176, 1633: 177, 1634: 178, 1635: 179, 1636: 180, 1637: 181, 1638: 182, 1639: 183, 1640: 184, 1641: 185, 63688: 186, 1563: 187, 63686: 188, 63685: 189, 63684: 190, 1567: 191, + 1645: 192, 1569: 193, 1570: 194, 1571: 195, 1572: 196, 1573: 197, 1574: 198, 1575: 199, 1576: 200, 1577: 201, 1578: 202, 1579: 203, 1580: 204, 1581: 205, 1582: 206, 1583: 207, + 1584: 208, 1585: 209, 1586: 210, 1587: 211, 1588: 212, 1589: 213, 1590: 214, 1591: 215, 1592: 216, 1593: 217, 1594: 218, 63683: 219, 63682: 220, 63681: 221, 63680: 222, 63679: 223, + 1600: 224, 1601: 225, 1602: 226, 1603: 227, 1604: 228, 1605: 229, 1606: 230, 1607: 231, 1608: 232, 1609: 233, 1610: 234, 1611: 235, 1612: 236, 1613: 237, 1614: 238, 1615: 239, + 1616: 240, 1617: 241, 1618: 242, 1662: 243, 1657: 244, 1670: 245, 1749: 246, 1700: 247, 1711: 248, 1672: 249, 1681: 250, 63678: 251, 63677: 252, 63676: 253, 1688: 254, 1746: 255, + }, + } + case 0x24e: // 590 + return &StringConverter{ + LangID: 590, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 160, 161, 162, 163, 65535, 165, 65535, 167, 164, 8216, 8220, 171, 8592, 8593, 8594, 8595, + 176, 177, 178, 179, 215, 181, 182, 183, 247, 8217, 8221, 187, 188, 189, 190, 191, + 65535, 768, 180, 710, 126, 713, 728, 729, 168, 65535, 730, 184, 65535, 733, 731, 711, + 8213, 185, 174, 169, 8482, 9834, 166, 65535, 65535, 65535, 65535, 65535, 8539, 8540, 8541, 8542, + 8486, 198, 272, 170, 294, 65535, 306, 319, 321, 216, 338, 186, 222, 358, 330, 329, + 312, 230, 273, 240, 295, 305, 307, 320, 322, 248, 339, 223, 254, 359, 331, 173, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 196, 127: 127, + 65535: 229, 160: 160, 161: 161, 162: 162, 163: 163, 165: 165, 167: 167, 164: 168, 8216: 169, 8220: 170, 171: 171, 8592: 172, 8593: 173, 8594: 174, 8595: 175, 176: 176, + 177: 177, 178: 178, 179: 179, 215: 180, 181: 181, 182: 182, 183: 183, 247: 184, 8217: 185, 8221: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, 768: 193, + 180: 194, 710: 195, 713: 197, 728: 198, 729: 199, 168: 200, 730: 202, 184: 203, 733: 205, 731: 206, 711: 207, 8213: 208, 185: 209, 174: 210, 169: 211, 8482: 212, + 9834: 213, 166: 214, 8539: 220, 8540: 221, 8541: 222, 8542: 223, 8486: 224, 198: 225, 272: 226, 170: 227, 294: 228, 306: 230, 319: 231, 321: 232, 216: 233, 338: 234, + 186: 235, 222: 236, 358: 237, 330: 238, 329: 239, 312: 240, 230: 241, 273: 242, 240: 243, 295: 244, 305: 245, 307: 246, 320: 247, 322: 248, 248: 249, 339: 250, + 223: 251, 254: 252, 359: 253, 331: 254, 173: 255, + }, + } + case 0x35e: // 862 + return &StringConverter{ + LangID: 862, + CharWidth: 1, + eReplace: 65533, + dReplace: 63, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 65535: 255, + }, + } + case 0x3ea: // 1002 + return &StringConverter{ + LangID: 1002, + CharWidth: 1, + eReplace: 65533, + dReplace: 191, + dBuffer: []int{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + }, + eBuffer: map[int]int{ + 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, + 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, + 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, + 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, + 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, + 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, + 96: 96, 97: 97, 98: 98, 99: 99, 100: 100, 101: 101, 102: 102, 103: 103, 104: 104, 105: 105, 106: 106, 107: 107, 108: 108, 109: 109, 110: 110, 111: 111, + 112: 112, 113: 113, 114: 114, 115: 115, 116: 116, 117: 117, 118: 118, 119: 119, 120: 120, 121: 121, 122: 122, 123: 123, 124: 124, 125: 125, 126: 126, 127: 127, + 128: 128, 129: 129, 130: 130, 131: 131, 132: 132, 133: 133, 134: 134, 135: 135, 136: 136, 137: 137, 138: 138, 139: 139, 140: 140, 141: 141, 142: 142, 143: 143, + 144: 144, 145: 145, 146: 146, 147: 147, 148: 148, 149: 149, 150: 150, 151: 151, 152: 152, 153: 153, 154: 154, 155: 155, 156: 156, 157: 157, 158: 158, 159: 159, + 160: 160, 161: 161, 162: 162, 163: 163, 164: 164, 165: 165, 166: 166, 167: 167, 168: 168, 169: 169, 170: 170, 171: 171, 172: 172, 173: 173, 174: 174, 175: 175, + 176: 176, 177: 177, 178: 178, 179: 179, 180: 180, 181: 181, 182: 182, 183: 183, 184: 184, 185: 185, 186: 186, 187: 187, 188: 188, 189: 189, 190: 190, 191: 191, + 192: 192, 193: 193, 194: 194, 195: 195, 196: 196, 197: 197, 198: 198, 199: 199, 200: 200, 201: 201, 202: 202, 203: 203, 204: 204, 205: 205, 206: 206, 207: 207, + 208: 208, 209: 209, 210: 210, 211: 211, 212: 212, 213: 213, 214: 214, 215: 215, 216: 216, 217: 217, 218: 218, 219: 219, 220: 220, 221: 221, 222: 222, 223: 223, + 224: 224, 225: 225, 226: 226, 227: 227, 228: 228, 229: 229, 230: 230, 231: 231, 232: 232, 233: 233, 234: 234, 235: 235, 236: 236, 237: 237, 238: 238, 239: 239, + 240: 240, 241: 241, 242: 242, 243: 243, 244: 244, 245: 245, 246: 246, 247: 247, 248: 248, 249: 249, 250: 250, 251: 251, 252: 252, 253: 253, 254: 254, 255: 255, + 8216: 96, 8213: 45, 63742: 183, 8248: 94, 8764: 126, 63741: 102, 8356: 76, 376: 89, 946: 223, + }, + } + default: + return &StringConverter{ + LangID: langID, + CharWidth: 2, + eReplace: 65533, + dReplace: 63, + } + } + //fileName := fmt.Sprintf("glb/lx20%x.json", LangID) + //jsonFile, err := os.Open(fileName) + //if err != nil { + // fmt.Println(err) + // return nil + //} + //content, _ := ioutil.ReadAll(jsonFile) + //var conv StringConverter + //err = json.Unmarshal(content, &conv) + //if err != nil { + // return nil + //} + //return &conv +} diff --git a/converters/type_conversion.go b/converters/type_conversion.go new file mode 100644 index 00000000..62056687 --- /dev/null +++ b/converters/type_conversion.go @@ -0,0 +1,276 @@ +package converters + +import ( + "bytes" + "encoding/binary" + "errors" + "math" + "time" +) + +var powerTable = [][]float64{ + {128.0, 1e+256, 1e-256}, + {64.0, 1e+128, 1e-128}, + {32.0, 1e+64, 1e-64}, + {16.0, 1e+32, 1e-32}, + {8.0, 1e+16, 1e-16}, + {4.0, 100000000.0, 1e-08}, + {2.0, 10000.0, 0.0001}, + {1.0, 100.0, 0.01}, +} + +// note that int64 is different in size > 22 byte size and when make clear type you will path 1 instead of 0 +//case OraType.ORA_NUMBER: +//case OraType.ORA_VARNUM: +//if (numArray.Length >= 22) +//{ +//mEngine.MarshalCLR(numArray, 1, (int) numArray[0]); +//break; +//} +//mEngine.MarshalCLR(numArray, 0, numArray.Length); +func encodeSign(input []byte, neg bool) []byte { + if !neg { + input[0] = uint8(int(input[0]) + 0x80 + 0x40 + 1) + for x := 1; x < len(input); x++ { + input[x] = input[x] + 1 + } + } else { + input[0] = 0xFF - uint8(int(input[0])+0x80+0x40+1) + for x := 1; x < len(input); x++ { + input[x] = uint8(101 - input[x]) + } + if len(input) <= 20 { + input = append(input, 102) + } + } + return input +} +func decodeSign(input []byte) (length int, neg bool) { + if input[0] > 0x80 { + length = int(input[0]) - 0x80 - 0x40 + for x := 1; x < len(input); x++ { + input[x] = input[x] - 1 + } + neg = false + } else { + length = 0xFF - int(input[0]) - 0x80 - 0x40 + if len(input) <= 20 && input[len(input)-1] == 102 { + input = input[:len(input)-1] + } + for x := 1; x < len(input); x++ { + input[x] = uint8(101 - input[x]) + } + neg = true + } + return +} +func DecodeInt(inputData []byte) int { + // take a copy of input + input := make([]byte, len(inputData)) + copy(input, inputData) + if input[0] == 0x80 { + return 0 + } + length, neg := decodeSign(input) + if length > len(input[1:]) { + input = append(input, make([]byte, length-len(input[1:]))...) + } + data := input[1 : 1+length] + ret := 0 + for x := 0; x < len(data); x++ { + ret = (ret * 100) + int(data[x]) + } + if neg { + return ret * -1 + } else { + return ret + } +} + +func EncodeInt64(val int64) []byte { + if val == 0 { + return []byte{0x80} + } + output := make([]byte, 0, 20) + neg := val < 0 + for val != 0 { + output = append(output, uint8(math.Abs(float64(val%100)))) + val = val / 100 + } + for i, j := 0, len(output)-1; i < j; i, j = i+1, j-1 { + output[i], output[j] = output[j], output[i] + } + byteLen := uint8(len(output)) + output = bytes.TrimRight(output, "\x00") + + output = append([]byte{byteLen}, output...) + return encodeSign(output, neg) +} +func EncodeInt(val int) []byte { + if val == 0 { + return []byte{0x80} + } + output := make([]byte, 0, 20) + neg := val < 0 + for val != 0 { + output = append(output, uint8(math.Abs(float64(val%100)))) + val = val / 100 + } + for i, j := 0, len(output)-1; i < j; i, j = i+1, j-1 { + output[i], output[j] = output[j], output[i] + } + byteLen := uint8(len(output)) + output = bytes.TrimRight(output, "\x00") + + output = append([]byte{byteLen}, output...) + return encodeSign(output, neg) + //if !neg { + // output[0] = output[0] + 0x80 + 0x40 + // for x := 1; x < len(output); x++ { + // output[x] = output[x] + 1 + // } + //} else { + // output[0] = 0xFF - (output[0] + 0x80 + 0x40) + // for x := 1; x < len(output); x++ { + // output[x] = uint8(101 - output[x]) + // } + // if len(output) <= 20 { + // output = append(output, 102) + // } + //} + //return output +} + +func EncodeDate(ti time.Time) []byte { + ret := make([]byte, 7) + ret[0] = uint8(ti.Year()/100 + 100) + ret[1] = uint8(ti.Year()%100 + 100) + ret[2] = uint8(ti.Month()) + ret[3] = uint8(ti.Day()) + ret[4] = uint8(ti.Hour() + 1) + ret[5] = uint8(ti.Minute() + 1) + ret[6] = uint8(ti.Second() + 1) + return ret +} + +func DecodeDate(data []byte) (time.Time, error) { + if len(data) < 7 { + return time.Now(), errors.New("abnormal data representation for date") + } + year := (int(data[0]) - 100) * 100 + year += int(data[1]) - 100 + nanoSec := 0 + if len(data) > 7 { + nanoSec = int(binary.BigEndian.Uint32(data[7:10])) + } + tzHour := 0 + tzMin := 0 + if len(data) > 11 { + tzHour = int(data[11]) - 20 + tzMin = int(data[12]) - 60 + } + + return time.Date(year, time.Month(data[2]), int(data[3]), + int(data[4]-1)+tzHour, int(data[5]-1)+tzMin, int(data[6]-1), nanoSec, time.UTC), nil +} + +func DecodeDouble(inputData []byte) float64 { + input := make([]byte, len(inputData)) + copy(input, inputData) + if input[0] == 0x80 { + return 0 + } + length, neg := decodeSign(input) + length -= 1 + data := input[1:] + var ret float64 + ret = float64(data[0]) + for x := 1; x < len(data); x++ { + ret = ret + (float64(data[x]) / math.Pow(100.0, float64(x))) + } + if length < 0 { + for x := 0; x < 8; x++ { + if length&int(powerTable[x][0]) == 0 { + ret = ret / powerTable[x][1] + length += int(powerTable[x][0]) + } + } + if length < 0 { + ret = ret / 100.0 + length += 1 + } + } else if length > 0 { + for x := 0; x < 8; x++ { + if length&int(powerTable[x][0]) > 0 { + ret = ret / powerTable[x][2] + } + } + } + if neg { + ret = ret * -1 + } + return ret + +} + +func EncodeDouble(num float64) ([]byte, error) { + //byte[] numArray = new byte[20]; + num1 := 0 + neg := num < 0.0 + num = math.Abs(num) + if num < 1.0 { + for x := 0; x < 8; x++ { + if powerTable[x][2] >= num { + num1 -= int(powerTable[x][0]) + num *= powerTable[x][1] + } + } + if num < 1.0 { + num1-- + num *= 100.0 + } + } else { + for x := 0; x < 8; x++ { + if powerTable[x][1] <= num { + num1 += int(powerTable[x][0]) + num *= powerTable[x][2] + } + } + } + if num1 > 62 || num1 < -65 { + return nil, errors.New("overflow occur") + } + flag := num < 10.0 + ret := make([]byte, 20) + num3 := uint8(num) + for x := 0; x < 8; x++ { + ret[x] = num3 + num = (num - float64(num3)) * 100.0 + num3 = uint8(num) + } + if flag { + if int(num3) >= 50 { + ret[7]++ + } + } else { + ret[7] = uint8(((int(ret[7]) + 5) / 10) * 10) + if num1 == 62 && ((int(ret[7])+5)/10)*10 == 100 { + ret[7] = uint8(((int(ret[7]) - 5) / 10) * 10) + } + } + x := 7 + for ret[x] == 100 { + if x == 0 { + num1++ + ret[x] = 1 + break + } + ret[x] = 0 + x-- + ret[x]++ + } + ret = bytes.TrimRight(ret, "\x00") + ret = append([]byte{uint8(num1)}, ret...) + return encodeSign(ret, neg), nil + // 192, 2, 79 +} diff --git a/data_set.go b/data_set.go new file mode 100644 index 00000000..fa7d5601 --- /dev/null +++ b/data_set.go @@ -0,0 +1,105 @@ +package go_ora + +import ( + "database/sql/driver" + "go-ora/network" + "io" +) + +type Row []driver.Value + +type DataSet struct { + ColumnCount int + RowCount int + UACBufferLength int + MaxRowSize int + Cols []ParameterInfo + Rows []Row + index int + parent *Stmt +} + +func (dataSet *DataSet) read(session *network.Session) error { + _, err := session.GetByte() + if err != nil { + return err + } + dataSet.ColumnCount, err = session.GetInt(2, true, true) + if err != nil { + return err + } + num, err := session.GetInt(4, true, true) + if err != nil { + return err + } + dataSet.ColumnCount += num * 0x100 + dataSet.RowCount, err = session.GetInt(4, true, true) + if err != nil { + return err + } + dataSet.UACBufferLength, err = session.GetInt(2, true, true) + if err != nil { + return err + } + bitVector, err := session.GetDlc() + if err != nil { + return err + } + dataSet.setBitVector(bitVector) + _, err = session.GetDlc() + return nil +} + +func (dataSet *DataSet) setBitVector(bitVector []byte) { + index := dataSet.ColumnCount / 8 + if dataSet.ColumnCount%8 > 0 { + index++ + } + if len(bitVector) > 0 { + for x := 0; x < index; x++ { + for i := 0; i < 8; i++ { + if x*8+i < dataSet.ColumnCount { + dataSet.Cols[(x*8)+i].getDataFromServer = bitVector[x]>>i&1 > 0 + } + } + } + } else { + for x := 0; x < len(dataSet.Cols); x++ { + dataSet.Cols[x].getDataFromServer = true + } + } + +} + +func (dataSet *DataSet) Close() error { + return nil +} + +func (dataSet *DataSet) Next(dest []driver.Value) error { + if dataSet.parent.hasMoreRows && dataSet.index > 0 && dataSet.index%dataSet.parent.noOfRowsToFetch == 0 { + dataSet.Rows = make([]Row, 0, dataSet.parent.noOfRowsToFetch) + err := dataSet.parent.fetch(dataSet) + if err != nil { + return err + } + } + if dataSet.index%dataSet.parent.noOfRowsToFetch < len(dataSet.Rows) { + for x := 0; x < len(dataSet.Rows[dataSet.index%dataSet.parent.noOfRowsToFetch]); x++ { + dest[x] = driver.Value(dataSet.Rows[dataSet.index%dataSet.parent.noOfRowsToFetch][x]) + } + dataSet.index++ + return nil + } + return io.EOF +} + +func (dataSet *DataSet) Columns() []string { + if len(dataSet.Cols) == 0 { + return nil + } + ret := make([]string, len(dataSet.Cols)) + for x := 0; x < len(dataSet.Cols); x++ { + ret[x] = dataSet.Cols[x].Name + } + return ret +} diff --git a/data_type_nego.go b/data_type_nego.go new file mode 100644 index 00000000..5d1e462e --- /dev/null +++ b/data_type_nego.go @@ -0,0 +1,485 @@ +package go_ora + +import ( + "encoding/binary" + "errors" + "fmt" + "go-ora/network" + "time" +) + +type DataTypeNego struct { + MessageCode uint8 + Server *TCPNego + TypeAndRep []int16 + RuntimeTypeAndRep []int16 + DataTypeRepFor1100 int16 + CompileTimeCaps []byte + RuntimeCap []byte + DBTimeZone []byte +} + +const bufferGrow int = 2369 + +//internal TTCDataTypeNegotiation(MarshallingEngine marshallingEngine, +// byte[] serverCompileTimeCap, byte[] serverRunTimeCap, +// short networkCharSetId, +// short networkNCharSetId, +// byte networkFlags) +//: base(marshallingEngine, (byte) 2) +//{ +//this.m_clientRemoteIn = networkCharSetId; +//this.m_clientRemoteOut = networkCharSetId; +//this.m_ncharSetId = networkNCharSetId; +//this.m_clientFlags = networkFlags; +// +// +// +// +//internal override void ReInit(MarshallingEngine marshallingEngine) +//{ +//base.ReInit(marshallingEngine); +//this.m_dbTimeZoneBytes = (byte[]) null; +//} +func (n *DataTypeNego) addTypeRep(dty int16, ndty int16, rep int16) { + if n.TypeAndRep == nil { + n.TypeAndRep = make([]int16, bufferGrow) + } + if len(n.TypeAndRep) < int(n.TypeAndRep[0]+4) { + n.TypeAndRep = append(n.TypeAndRep, make([]int16, bufferGrow)...) + } + index := n.TypeAndRep[0] + n.TypeAndRep[index] = dty + n.TypeAndRep[index+1] = ndty + if ndty == 0 { + n.TypeAndRep[0] = index + 2 + } else { + n.TypeAndRep[index+2] = rep + n.TypeAndRep[index+3] = 0 + n.TypeAndRep[0] = index + 4 + } +} + +func buildTypeNego(nego *TCPNego, session *network.Session) (*DataTypeNego, error) { + result := DataTypeNego{ + MessageCode: 2, + Server: nego, + TypeAndRep: make([]int16, bufferGrow), + CompileTimeCaps: []byte{ + 6, 1, 0, 0, 10, 1, 1, 6, + 1, 1, 1, 1, 1, 1, 0, 0x29, + 0x90, 3, 7, 3, 0, 1, 0, 0x6B, + 1, 0, 5, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 2}, + RuntimeCap: []byte{2, 1, 0, 0, 0, 0, 0}, + } + if result.Server.ServerCompileTimeCaps == nil || + len(result.Server.ServerCompileTimeCaps) <= 37 || + result.Server.ServerCompileTimeCaps[37]&2 != 2 { + result.CompileTimeCaps[37] = 0 + result.CompileTimeCaps[1] = 0 + } + + result.TypeAndRep[0] = 1 + result.addTypeRep(1, 1, 1) + result.addTypeRep(2, 2, 10) + result.addTypeRep(8, 8, 1) + result.addTypeRep(12, 12, 10) + result.addTypeRep(23, 23, 1) + result.addTypeRep(24, 24, 1) + result.addTypeRep(25, 25, 1) + result.addTypeRep(26, 26, 1) + result.addTypeRep(27, 27, 1) + result.addTypeRep(28, 28, 1) + result.addTypeRep(29, 29, 1) + result.addTypeRep(30, 30, 1) + result.addTypeRep(31, 31, 1) + result.addTypeRep(32, 32, 1) + result.addTypeRep(33, 33, 1) + result.addTypeRep(10, 10, 1) + result.addTypeRep(11, 11, 1) + result.addTypeRep(40, 40, 1) + result.addTypeRep(41, 41, 1) + result.addTypeRep(117, 117, 1) + result.addTypeRep(120, 120, 1) + result.addTypeRep(290, 290, 1) + result.addTypeRep(291, 291, 1) + result.addTypeRep(292, 292, 1) + result.addTypeRep(293, 293, 1) + result.addTypeRep(294, 294, 1) + result.addTypeRep(298, 298, 1) + result.addTypeRep(299, 299, 1) + result.addTypeRep(300, 300, 1) + result.addTypeRep(301, 301, 1) + result.addTypeRep(302, 302, 1) + result.addTypeRep(303, 303, 1) + result.addTypeRep(304, 304, 1) + result.addTypeRep(305, 305, 1) + result.addTypeRep(306, 306, 1) + result.addTypeRep(307, 307, 1) + result.addTypeRep(308, 308, 1) + result.addTypeRep(309, 309, 1) + result.addTypeRep(310, 310, 1) + result.addTypeRep(311, 311, 1) + result.addTypeRep(312, 312, 1) + result.addTypeRep(313, 313, 1) + result.addTypeRep(315, 315, 1) + result.addTypeRep(316, 316, 1) + result.addTypeRep(317, 317, 1) + result.addTypeRep(318, 318, 1) + result.addTypeRep(319, 319, 1) + result.addTypeRep(320, 320, 1) + result.addTypeRep(321, 321, 1) + result.addTypeRep(322, 322, 1) + result.addTypeRep(323, 323, 1) + result.addTypeRep(327, 327, 1) + result.addTypeRep(328, 328, 1) + result.addTypeRep(329, 329, 1) + result.addTypeRep(331, 331, 1) + result.addTypeRep(333, 333, 1) + result.addTypeRep(334, 334, 1) + result.addTypeRep(335, 335, 1) + result.addTypeRep(336, 336, 1) + result.addTypeRep(337, 337, 1) + result.addTypeRep(338, 338, 1) + result.addTypeRep(339, 339, 1) + result.addTypeRep(340, 340, 1) + result.addTypeRep(341, 341, 1) + result.addTypeRep(342, 342, 1) + result.addTypeRep(343, 343, 1) + result.addTypeRep(344, 344, 1) + result.addTypeRep(345, 345, 1) + result.addTypeRep(346, 346, 1) + result.addTypeRep(348, 348, 1) + result.addTypeRep(349, 349, 1) + result.addTypeRep(354, 354, 1) + result.addTypeRep(355, 355, 1) + result.addTypeRep(359, 359, 1) + result.addTypeRep(363, 363, 1) + result.addTypeRep(380, 380, 1) + result.addTypeRep(381, 381, 1) + result.addTypeRep(382, 382, 1) + result.addTypeRep(383, 383, 1) + result.addTypeRep(384, 384, 1) + result.addTypeRep(385, 385, 1) + result.addTypeRep(386, 386, 1) + result.addTypeRep(387, 387, 1) + result.addTypeRep(388, 388, 1) + result.addTypeRep(389, 389, 1) + result.addTypeRep(390, 390, 1) + result.addTypeRep(391, 391, 1) + result.addTypeRep(393, 393, 1) + result.addTypeRep(394, 394, 1) + result.addTypeRep(395, 395, 1) + result.addTypeRep(396, 396, 1) + result.addTypeRep(397, 397, 1) + result.addTypeRep(398, 398, 1) + result.addTypeRep(399, 399, 1) + result.addTypeRep(400, 400, 1) + result.addTypeRep(401, 401, 1) + result.addTypeRep(404, 404, 1) + result.addTypeRep(405, 405, 1) + result.addTypeRep(406, 406, 1) + result.addTypeRep(407, 407, 1) + result.addTypeRep(413, 413, 1) + result.addTypeRep(414, 414, 1) + result.addTypeRep(415, 415, 1) + result.addTypeRep(416, 416, 1) + result.addTypeRep(417, 417, 1) + result.addTypeRep(418, 418, 1) + result.addTypeRep(419, 419, 1) + result.addTypeRep(420, 420, 1) + result.addTypeRep(421, 421, 1) + result.addTypeRep(422, 422, 1) + result.addTypeRep(423, 423, 1) + result.addTypeRep(424, 424, 1) + result.addTypeRep(425, 425, 1) + result.addTypeRep(426, 426, 1) + result.addTypeRep(427, 427, 1) + result.addTypeRep(429, 429, 1) + result.addTypeRep(430, 430, 1) + result.addTypeRep(431, 431, 1) + result.addTypeRep(432, 432, 1) + result.addTypeRep(433, 433, 1) + result.addTypeRep(449, 449, 1) + result.addTypeRep(450, 450, 1) + result.addTypeRep(454, 454, 1) + result.addTypeRep(455, 455, 1) + result.addTypeRep(456, 456, 1) + result.addTypeRep(457, 457, 1) + result.addTypeRep(458, 458, 1) + result.addTypeRep(459, 459, 1) + result.addTypeRep(460, 460, 1) + result.addTypeRep(461, 461, 1) + result.addTypeRep(462, 462, 1) + result.addTypeRep(463, 463, 1) + result.addTypeRep(466, 466, 1) + result.addTypeRep(467, 467, 1) + result.addTypeRep(468, 468, 1) + result.addTypeRep(469, 469, 1) + result.addTypeRep(470, 470, 1) + result.addTypeRep(471, 471, 1) + result.addTypeRep(472, 472, 1) + result.addTypeRep(473, 473, 1) + result.addTypeRep(474, 474, 1) + result.addTypeRep(475, 475, 1) + result.addTypeRep(476, 476, 1) + result.addTypeRep(477, 477, 1) + result.addTypeRep(478, 478, 1) + result.addTypeRep(479, 479, 1) + result.addTypeRep(480, 480, 1) + result.addTypeRep(481, 481, 1) + result.addTypeRep(482, 482, 1) + result.addTypeRep(483, 483, 1) + result.addTypeRep(484, 484, 1) + result.addTypeRep(485, 485, 1) + result.addTypeRep(486, 486, 1) + result.addTypeRep(490, 490, 1) + result.addTypeRep(491, 491, 1) + result.addTypeRep(492, 492, 1) + result.addTypeRep(493, 493, 1) + result.addTypeRep(494, 494, 1) + result.addTypeRep(495, 495, 1) + result.addTypeRep(496, 496, 1) + result.addTypeRep(498, 498, 1) + result.addTypeRep(499, 499, 1) + result.addTypeRep(500, 500, 1) + result.addTypeRep(501, 501, 1) + result.addTypeRep(502, 502, 1) + result.addTypeRep(509, 509, 1) + result.addTypeRep(510, 510, 1) + result.addTypeRep(513, 513, 1) + result.addTypeRep(514, 514, 1) + result.addTypeRep(516, 516, 1) + result.addTypeRep(517, 517, 1) + result.addTypeRep(518, 518, 1) + result.addTypeRep(519, 519, 1) + result.addTypeRep(520, 520, 1) + result.addTypeRep(521, 521, 1) + result.addTypeRep(522, 522, 1) + result.addTypeRep(523, 523, 1) + result.addTypeRep(524, 524, 1) + result.addTypeRep(525, 525, 1) + result.addTypeRep(526, 526, 1) + result.addTypeRep(527, 527, 1) + result.addTypeRep(528, 528, 1) + result.addTypeRep(529, 529, 1) + result.addTypeRep(530, 530, 1) + result.addTypeRep(531, 531, 1) + result.addTypeRep(532, 532, 1) + result.addTypeRep(533, 533, 1) + result.addTypeRep(534, 534, 1) + result.addTypeRep(535, 535, 1) + result.addTypeRep(536, 536, 1) + result.addTypeRep(537, 537, 1) + result.addTypeRep(538, 538, 1) + result.addTypeRep(539, 539, 1) + result.addTypeRep(540, 540, 1) + result.addTypeRep(541, 541, 1) + result.addTypeRep(542, 542, 1) + result.addTypeRep(543, 543, 1) + result.addTypeRep(560, 560, 1) + result.addTypeRep(565, 565, 1) + result.addTypeRep(572, 572, 1) + result.addTypeRep(573, 573, 1) + result.addTypeRep(574, 574, 1) + result.addTypeRep(575, 575, 1) + result.addTypeRep(576, 576, 1) + result.addTypeRep(578, 578, 1) + result.addTypeRep(580, 580, 1) + result.addTypeRep(581, 581, 1) + result.addTypeRep(582, 582, 1) + result.addTypeRep(583, 583, 1) + result.addTypeRep(584, 584, 1) + result.addTypeRep(585, 585, 1) + result.addTypeRep(3, 2, 10) + result.addTypeRep(4, 2, 10) + result.addTypeRep(5, 1, 1) + result.addTypeRep(6, 2, 10) + result.addTypeRep(7, 2, 10) + result.addTypeRep(9, 1, 1) + result.addTypeRep(13, 0, 0) + result.addTypeRep(14, 0, 0) + result.addTypeRep(15, 23, 1) + result.addTypeRep(16, 0, 0) + result.addTypeRep(17, 0, 0) + result.addTypeRep(18, 0, 0) + result.addTypeRep(19, 0, 0) + result.addTypeRep(20, 0, 0) + result.addTypeRep(21, 0, 0) + result.addTypeRep(22, 0, 0) + result.addTypeRep(39, 120, 1) + result.addTypeRep(58, 0, 0) + result.addTypeRep(68, 2, 10) + result.addTypeRep(69, 0, 0) + result.addTypeRep(70, 0, 0) + result.addTypeRep(74, 0, 0) + result.addTypeRep(76, 0, 0) + result.addTypeRep(91, 2, 10) + result.addTypeRep(94, 1, 1) + result.addTypeRep(95, 23, 1) + result.addTypeRep(96, 96, 1) + result.addTypeRep(97, 96, 1) + result.addTypeRep(100, 100, 1) + result.addTypeRep(101, 101, 1) + result.addTypeRep(102, 102, 1) + result.addTypeRep(104, 11, 1) + result.addTypeRep(105, 0, 0) + result.addTypeRep(106, 106, 1) + result.addTypeRep(108, 109, 1) + result.addTypeRep(109, 109, 1) + result.addTypeRep(110, 111, 1) + result.addTypeRep(111, 111, 1) + result.addTypeRep(112, 112, 1) + result.addTypeRep(113, 113, 1) + result.addTypeRep(114, 114, 1) + result.addTypeRep(115, 115, 1) + result.addTypeRep(116, 102, 1) + result.addTypeRep(118, 0, 0) + result.addTypeRep(119, 0, 0) + result.addTypeRep(121, 0, 0) + result.addTypeRep(122, 0, 0) + result.addTypeRep(123, 0, 0) + result.addTypeRep(136, 0, 0) + result.addTypeRep(146, 146, 1) + result.addTypeRep(147, 0, 0) + result.addTypeRep(152, 2, 10) + result.addTypeRep(153, 2, 10) + result.addTypeRep(154, 2, 10) + result.addTypeRep(155, 1, 1) + result.addTypeRep(156, 12, 10) + result.addTypeRep(172, 2, 10) + result.addTypeRep(178, 178, 1) + result.addTypeRep(179, 179, 1) + result.addTypeRep(180, 180, 1) + result.addTypeRep(181, 181, 1) + result.addTypeRep(182, 182, 1) + result.addTypeRep(183, 183, 1) + result.addTypeRep(184, 12, 10) + result.addTypeRep(185, 185, 1) + result.addTypeRep(186, 186, 1) + result.addTypeRep(187, 187, 1) + result.addTypeRep(188, 188, 1) + result.addTypeRep(189, 189, 1) + result.addTypeRep(190, 190, 1) + result.addTypeRep(191, 0, 0) + result.addTypeRep(192, 0, 0) + result.addTypeRep(195, 112, 1) + result.addTypeRep(196, 113, 1) + result.addTypeRep(197, 114, 1) + result.addTypeRep(208, 208, 1) + result.addTypeRep(209, 0, 0) + result.addTypeRep(231, 231, 1) + result.addTypeRep(232, 231, 1) + result.addTypeRep(233, 233, 1) + result.addTypeRep(241, 109, 1) + result.addTypeRep(515, 0, 0) + result.DataTypeRepFor1100 = result.TypeAndRep[0] + result.addTypeRep(590, 590, 1) + result.addTypeRep(591, 591, 1) + result.addTypeRep(592, 592, 1) + if result.Server.ServerCompileTimeCaps != nil && len(result.Server.ServerCompileTimeCaps) > 7 && result.Server.ServerCompileTimeCaps[7] == 5 { + result.RuntimeTypeAndRep = result.TypeAndRep[:result.DataTypeRepFor1100] + } else { + result.RuntimeTypeAndRep = result.TypeAndRep + } + session.ResetBuffer() + session.PutBytes(result.bytes()) + err := session.Write() + if err != nil { + return nil, err + } + msg, err := session.GetByte() + if err != nil { + return nil, err + } + if msg != 2 { + return nil, errors.New(fmt.Sprintf("message code error: received code %d and expected code is 2", msg)) + } + + if result.RuntimeCap[1] == 1 { + result.DBTimeZone, err = session.GetBytes(11) + if err != nil { + return nil, err + } + if result.CompileTimeCaps[37]&2 == 2 { + _, _ = session.GetInt(4, false, false) + } + } + //getNum := func(session *network.Session, flag uint8) (int, error) { + // if flag == 0 { + // return session.GetInt(1, false, false) + // } else { + // return session.GetInt(2, false, true) + // } + //} + level := 0 + for { + var num int + if result.CompileTimeCaps[27] == 0 { + num, err = session.GetInt(1, false, false) + } else { + num, err = session.GetInt(2, false, true) + } + if num == 0 && level == 0 { + break + } + if num == 0 && level == 1 { + level = 0 + continue + } + if level == 3 { + level = 0 + continue + } + level++ + } + return &result, nil +} + +func (nego *DataTypeNego) bytes() []byte { + var result = make([]byte, 7, 1000) + if nego.Server.ServerCompileTimeCaps == nil || len(nego.Server.ServerCompileTimeCaps) <= 27 || nego.Server.ServerCompileTimeCaps[27] == 0 { + nego.CompileTimeCaps[27] = 0 + } + result[0] = nego.MessageCode + //binary.BigEndian.PutUint16(result[2:], 0) + //binary.BigEndian.PutUint16(result[4:], 0) + result[5] = nego.Server.ServerFlags + result[6] = uint8(len(nego.CompileTimeCaps)) + result = append(result, nego.CompileTimeCaps...) + result = append(result, uint8(len(nego.RuntimeCap))) + result = append(result, nego.RuntimeCap...) + if nego.RuntimeCap[1]&1 == 1 { + result = append(result, TZBytes()...) + if nego.CompileTimeCaps[37]&2 == 2 { + result = append(result, []byte{0, 0, 0, 0}...) + } + } + temp := []byte{0, 0} + binary.LittleEndian.PutUint16(temp, uint16(nego.Server.ServernCharset)) + result = append(result, temp...) + // marshal type reps + size := nego.RuntimeTypeAndRep[0] + if nego.CompileTimeCaps[27] == 0 { + for _, x := range nego.RuntimeTypeAndRep[1:size] { + result = append(result, uint8(x)) + } + result = append(result, 0) + } else { + for _, x := range nego.RuntimeTypeAndRep[1:size] { + binary.BigEndian.PutUint16(temp, uint16(x)) + result = append(result, temp...) + } + result = append(result, []byte{0, 0}...) + } + return result +} + +func TZBytes() []byte { + _, offset := time.Now().Zone() + hours := int8(offset / 3600) + minutes := int8((offset / 60) % 60) + seconds := int8(offset % 60) + return []byte{128, 0, 0, 0, uint8(hours + 60), uint8(minutes + 60), uint8(seconds + 60), 128, 0, 0, 0} +} diff --git a/db_version.go b/db_version.go new file mode 100644 index 00000000..e8cbbb88 --- /dev/null +++ b/db_version.go @@ -0,0 +1,66 @@ +package go_ora + +import ( + "errors" + "fmt" + "go-ora/network" +) + +type DBVersion struct { + Info string + Text string + Number uint16 + MajorVersion int + MinorVersion int + PatchsetVersion int + isDb10gR20OrHigher bool + isDb11gR10OrHigher bool +} + +func GetDBVersion(session *network.Session) (*DBVersion, error){ + session.ResetBuffer() + session.PutBytes([]byte{3, 0x3B, 0}) + session.PutUint(1, 1, false, false) + session.PutUint(0x100, 2, true, true) + session.PutUint(1, 1, false, false) + session.PutUint(1, 1, false, false) + err := session.Write() + if err != nil { + return nil, err + } + msg, err := session.GetInt(1, false, false) + if msg != 8 { + return nil, errors.New(fmt.Sprintf("message code error: received code %d and expected code is 8", msg)) + } + length, err := session.GetInt(2, true, true) + if err != nil { + return nil, err + } + info, err := session.GetBytes(int(length)) + if err != nil { + return nil, err + } + number, err := session.GetInt(4, true, true) + if err != nil { + return nil, err + } + version := (number >> 24 & 0xFF) * 1000 + (number >> 20 & 0xF) * 100 + (number >> 12 & 0xF) * 10 + (number >> 8 & 0xF) + text := fmt.Sprintf("%d.%d.%d.%d.%d", number >> 24 & 0xFF, number >> 20 & 0xF, + number >> 12 & 0xF, number >> 8 & 0xF, number & 0xFF) + + ret := &DBVersion{ + Info: string(info), + Text: text, + Number: uint16(version), + MajorVersion: int(number >> 24 & 0xFF), + MinorVersion: int(number >> 20 & 0xF), + PatchsetVersion: int(number >> 8 & 0xF), + } + if ret.MajorVersion > 10 || (ret.MajorVersion == 10 && ret.MinorVersion >= 2) { + ret.isDb10gR20OrHigher = true + } + if ret.MajorVersion > 11 || (ret.MajorVersion == 11 && ret.MinorVersion >= 1) { + ret.isDb11gR10OrHigher = true + } + return ret, nil +} \ No newline at end of file diff --git a/network/accept_packet.go b/network/accept_packet.go new file mode 100644 index 00000000..a9b015d8 --- /dev/null +++ b/network/accept_packet.go @@ -0,0 +1,109 @@ +package network + +import "encoding/binary" + +//type AcceptPacket Packet +type AcceptPacket struct { + packet Packet + sessionCtx SessionContext + buffer []byte +} + +func (pck *AcceptPacket) bytes() []byte { + output := pck.packet.bytes() + //output := make([]byte, pck.dataOffset) + //binary.BigEndian.PutUint16(output[0:], pck.packet.length) + //output[4] = uint8(pck.packet.packetType) + //output[5] = pck.packet.flag + binary.BigEndian.PutUint16(output[8:], pck.sessionCtx.Version) + binary.BigEndian.PutUint16(output[10:], pck.sessionCtx.Options) + binary.BigEndian.PutUint16(output[12:], pck.sessionCtx.SessionDataUnit) + binary.BigEndian.PutUint16(output[14:], pck.sessionCtx.TransportDataUnit) + binary.BigEndian.PutUint16(output[16:], pck.sessionCtx.Histone) + binary.BigEndian.PutUint16(output[18:], uint16(len(pck.buffer))) + binary.BigEndian.PutUint16(output[20:], pck.packet.dataOffset) + output[22] = pck.sessionCtx.ACFL0 + output[23] = pck.sessionCtx.ACFL1 + output = append(output, pck.buffer...) + return output +} +func (pck *AcceptPacket) getPacketType() PacketType { + return pck.packet.packetType +} + +//func NewAcceptPacket(sessionCtx SessionContext, acceptData []byte) *AcceptPacket { +// sessionCtx.Histone = 1 +// sessionCtx.ACFL0 = 4 +// sessionCtx.ACFL1 = 4 +// pck := AcceptPacket{ +// sessionCtx: sessionCtx, +// dataOffset: 32, +// length: 0, +// packetType: 2, +// flag: 0, +// NSPFSID: 0, +// buffer: acceptData, +// SID: nil, +// } +// if len(acceptData) > 230 { +// pck.length = uint16(len(acceptData)) + pck.dataOffset +// } +// return &pck +//} + +func newAcceptPacketFromData(packetData []byte) *AcceptPacket { + if len(packetData) < 32 { + return nil + } + reconAddStart := binary.BigEndian.Uint16(packetData[28:]) + reconAddLen := binary.BigEndian.Uint16(packetData[30:]) + reconAdd := "" + if reconAddStart != 0 && reconAddLen != 0 && uint16(len(packetData)) > (reconAddStart+reconAddLen) { + reconAdd = string(packetData[reconAddStart:(reconAddStart + reconAddLen)]) + } + pck := AcceptPacket{ + packet: Packet{ + dataOffset: binary.BigEndian.Uint16(packetData[20:]), + length: binary.BigEndian.Uint16(packetData), + packetType: PacketType(packetData[4]), + flag: packetData[5], + }, + sessionCtx: SessionContext{ + connOption: ConnectionOption{}, + SID: nil, + Version: binary.BigEndian.Uint16(packetData[8:]), + LoVersion: 0, + Options: 0, + NegotiatedOptions: binary.BigEndian.Uint16(packetData[10:]), + OurOne: 0, + Histone: binary.BigEndian.Uint16(packetData[16:]), + ReconAddr: reconAdd, + ACFL0: packetData[22], + ACFL1: packetData[23], + SessionDataUnit: binary.BigEndian.Uint16(packetData[12:]), + TransportDataUnit: binary.BigEndian.Uint16(packetData[14:]), + UsingAsyncReceivers: false, + IsNTConnected: false, + OnBreakReset: false, + GotReset: false, + }, + buffer: packetData[32:], + } + //if pck.length != uint16(len(packetData)) { + // return nil + //} + //if pck.packetType != ACCEPT { + // return nil + //} + if pck.packet.dataOffset != 32 { + return nil + } + if binary.BigEndian.Uint16(packetData[18:]) != uint16(len(pck.buffer)) { + return nil + } + return &pck +} + +//func (pck *AcceptPacket) SessionCTX() SessionContext { +// return pck.sessionCtx +//} diff --git a/network/address_resolution.go b/network/address_resolution.go new file mode 100644 index 00000000..620c1b0c --- /dev/null +++ b/network/address_resolution.go @@ -0,0 +1,57 @@ +package network + +const ( + DefaultAddress string = "(Description=(Address=(Protocol=tcp)(IP=loopback)(port=1521))(CONNECT_DATA=(SID=" +) +type AddressResolution struct { + InstanceName string + TNSAddress string + +} + +//func ResolveEZConnect(tnsAlias string, instanceName string) (*ConnectionOption, error) { +// op := ConnectionOption{ +// Protocol: "tcp", +// SessionDataUnitSize: 0xFFFF, +// TransportDataUnitSize: 0xFFFF, +// } +// startIndex := 0 +// endIndex := 0 +// if strings.HasPrefix(tnsAlias, "//") { +// startIndex = 2 +// } +// if tnsAlias[startIndex] == '[' { +// endIndex = strings.Index(tnsAlias[startIndex:], "]") +// if endIndex == -1 { +// return nil, errors.New("outData source contain [ without closing ]") +// } +// startIndex ++ +// if endIndex <= startIndex { +// return nil, errors.New("outData source contain [ without closing ]") +// } +// op.Host = tnsAlias[startIndex: endIndex] +// startIndex = endIndex + 1 +// } else { +// endIndex = strings.IndexAny(tnsAlias[startIndex:], ":/") +// if endIndex == -1 { +// endIndex = len(tnsAlias) +// } +// op.Host = tnsAlias[startIndex: endIndex] +// startIndex = endIndex +// } +// if endIndex < len(tnsAlias) { +// if tnsAlias[endIndex] == ':' { +// startIndex ++ +// endIndex = strings.IndexAny(tnsAlias[startIndex:], ":/") +// if endIndex == -1 { +// endIndex = len(tnsAlias) +// } +// var err error +// op.Port, err = strconv.Atoi(tnsAlias[startIndex: endIndex]) +// if err != nil { +// return nil, errors.New("port must be a number") +// } +// startIndex = endIndex +// } +// } +//} \ No newline at end of file diff --git a/network/connect_option.go b/network/connect_option.go new file mode 100644 index 00000000..3a3df267 --- /dev/null +++ b/network/connect_option.go @@ -0,0 +1,67 @@ +package network + +import ( + "strconv" +) + +type ClientData struct { + ProgramPath string + ProgramName string + UserName string + HostName string + DriverName string + PID int +} +type ConnectionOption struct { + Port int + TransportConnectTo int + SSLVersion string + WalletDict string + TransportDataUnitSize uint16 + SessionDataUnitSize uint16 + Protocol string + Host string + UserID string + //IP string + SID string + //Addr string + //Server string + ServiceName string + InstanceName string + DomainName string + DBName string + ClientData ClientData + //InAddrAny bool + +} + +func (op *ConnectionOption) ConnectionData() string { + FulCid := "(CID=(PROGRAM=" + op.ClientData.ProgramPath + ")(HOST=" + op.ClientData.HostName + ")(USER=" + op.ClientData.UserName + "))" + address := "(ADDRESS=(PROTOCOL=" + op.Protocol + ")(HOST=" + op.Host + ")(PORT=" + strconv.Itoa(op.Port) + "))" + result := "(CONNECT_DATA=" + if op.ServiceName != "" { + result += "(SERVICE_NAME=" + op.ServiceName + ")" + } else { + if op.SID != "" { + result += "(SERVICE_NAME=" + op.SID + ")" + } + } + if op.InstanceName != "" { + result += "(INSTANCE_NAME=" + op.InstanceName + ")" + } + result += FulCid + return "(DESCRIPTION=" + address + result + "))" +} + +//func NewConnectionOption(conStr *go_ora.ConnectionString) *ConnectionOption { +// +//} +//func NewConnectionOption() *ConnectionOption { +// return &ConnectionOption{ +// Port: 0xFFFF, +// TransportConnectTo: 0xFFFF, +// TransportDataUnitSize: 0xFFFF, +// SessionDataUnitSize: 0xFFFF, +// } +//} + diff --git a/network/connect_packet.go b/network/connect_packet.go new file mode 100644 index 00000000..6138aab4 --- /dev/null +++ b/network/connect_packet.go @@ -0,0 +1,64 @@ +package network + +import "encoding/binary" + +//type ConnectPacket Packet +type ConnectPacket struct { + packet Packet + sessionCtx SessionContext + buffer []byte +} + +func (pck *ConnectPacket) bytes() []byte { + output := pck.packet.bytes() + //binary.BigEndian.PutUint16(output, pck.length) + //output[4] = uint8(pck.packetType) + //output[5] = pck.flag + binary.BigEndian.PutUint16(output[8:], pck.sessionCtx.Version) + binary.BigEndian.PutUint16(output[10:], pck.sessionCtx.LoVersion) + binary.BigEndian.PutUint16(output[12:], pck.sessionCtx.Options) + binary.BigEndian.PutUint16(output[14:], pck.sessionCtx.SessionDataUnit) + binary.BigEndian.PutUint16(output[16:], pck.sessionCtx.TransportDataUnit) + output[18] = 79 + output[19] = 152 + binary.BigEndian.PutUint16(output[22:], pck.sessionCtx.Histone) + binary.BigEndian.PutUint16(output[24:], uint16(len(pck.buffer))) + binary.BigEndian.PutUint16(output[26:], pck.packet.dataOffset) + output[32] = pck.sessionCtx.ACFL0 + output[33] = pck.sessionCtx.ACFL1 + if len(pck.buffer) <= 230 { + output = append(output, pck.buffer...) + } + return output + +} +func (pck *ConnectPacket) getPacketType() PacketType { + return pck.packet.packetType +} +func newConnectPacket(sessionCtx SessionContext) *ConnectPacket { + connectData := sessionCtx.connOption.ConnectionData() + length := uint16(len(connectData)) + if length > 230 { + length = 0 + } + length += 58 + + sessionCtx.Histone = 1 + sessionCtx.ACFL0 = 4 + sessionCtx.ACFL1 = 4 + + return &ConnectPacket{ + sessionCtx: sessionCtx, + packet: Packet{ + dataOffset: 58, + length: length, + packetType: CONNECT, + flag: 0, + }, + buffer: []byte(connectData), + } +} + +//DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=al-maaly)(PORT=1521))(CONNECT_DATA=( +// SERVICE_NAME=newhospital)(CID=(PROGRAM=D:\projects\DotPeekExtractedProjects\TestClient\bin\Debug\TestClient.exe) +// (HOST=LABMANAGER)(USER=lab)))) diff --git a/network/data_packet.go b/network/data_packet.go new file mode 100644 index 00000000..a7591990 --- /dev/null +++ b/network/data_packet.go @@ -0,0 +1,63 @@ +package network + +import ( + "encoding/binary" +) + +type DataPacket struct { + packet Packet + //dataOffset uint16 + //length uint16 + //packetType PacketType + //Flag uint8 + dataFlag uint16 + buffer []byte +} + +func (pck *DataPacket) bytes() []byte { + output := pck.packet.bytes() + //binary.BigEndian.PutUint16(output, pck.length) + //output[4] = uint8(pck.packetType) + //output[5] = pck.Flag + binary.BigEndian.PutUint16(output[8:], pck.dataFlag) + if len(pck.buffer) > 0 { + output = append(output, pck.buffer...) + } + return output +} + +func (pck *DataPacket) getPacketType() PacketType { + return pck.packet.packetType +} +func newDataPacket(initialData []byte) *DataPacket { + return &DataPacket{ + packet: Packet{ + dataOffset: 0xA, + length: uint16(len(initialData) + 0xA), + packetType: DATA, + flag: 0, + }, + dataFlag: 0, + buffer: initialData, + } +} + +func newDataPacketFromData(packetData []byte) *DataPacket { + if len(packetData) <= 0xA || PacketType(packetData[4]) != DATA { + return nil + } + return &DataPacket{ + packet: Packet{ + dataOffset: 0xA, + length: binary.BigEndian.Uint16(packetData), + packetType: PacketType(packetData[4]), + flag: packetData[5], + }, + dataFlag: binary.BigEndian.Uint16(packetData[8:]), + buffer: packetData[10:], + } +} + +//func (pck *DataPacket) Data() []byte { +// return pck.buffer +//} diff --git a/network/marker_packet.go b/network/marker_packet.go new file mode 100644 index 00000000..bbacae06 --- /dev/null +++ b/network/marker_packet.go @@ -0,0 +1,52 @@ +package network + +import "encoding/binary" + +type MarkerPacket struct { + packet Packet + //length uint16 + //packetType PacketType + //flag uint8 + markerData uint8 + markerType uint8 +} + +func (pck *MarkerPacket) bytes() []byte { + return []byte{0, 0xB, 0, 0, 0xC, 0, 0, 0, pck.markerType, 0, pck.markerData} +} + +func (pck *MarkerPacket) getPacketType() PacketType { + return pck.packet.packetType +} + +func newMarkerPacket(markerData uint8) *MarkerPacket { + return &MarkerPacket{ + packet: Packet{ + dataOffset: 0, + length: 0xB, + packetType: MARKER, + flag: 0, + }, + markerType: 1, + markerData: markerData, + } +} +func newMarkerPacketFromData(packetData []byte) *MarkerPacket { + if len(packetData) != 0xB { + return nil + } + pck := MarkerPacket{ + packet: Packet{ + dataOffset: 0, + length: binary.BigEndian.Uint16(packetData), + packetType: PacketType(packetData[4]), + flag: packetData[5], + }, + markerType: packetData[8], + markerData: packetData[10], + } + if pck.packet.packetType != MARKER { + return nil + } + return &pck +} diff --git a/network/packets.go b/network/packets.go new file mode 100644 index 00000000..c437912e --- /dev/null +++ b/network/packets.go @@ -0,0 +1,68 @@ +package network + +import "encoding/binary" + +type PacketType uint8 + +type PacketInterface interface { + bytes() []byte + getPacketType() PacketType +} + +const ( + CONNECT PacketType = 1 + ACCEPT PacketType = 2 + ACK PacketType = 3 + REFUSE PacketType = 4 + REDIRECT PacketType = 5 + DATA PacketType = 6 + NULL PacketType = 7 + ABORT PacketType = 9 + RESEND PacketType = 11 + MARKER PacketType = 12 + ATTN PacketType = 13 + CTRL PacketType = 14 + HIGHEST PacketType = 19 +) + +type Packet struct { + //sessionCtx SessionContext + dataOffset uint16 + length uint16 + packetType PacketType + flag uint8 + //NSPFSID int + //buffer []byte + //SID []byte +} + +//const ( +// NSPFSID = 1 +// NSPFRDS = 2 +// NSPFRDR = 4 +// NSPFSRN = 8 +// NSPFPRB = 0x10 +// NSPSID_SZ = 0x10 +//) + +func newPacket(packetData []byte) *Packet { + return &Packet{ + length: binary.BigEndian.Uint16(packetData), + packetType: PacketType(packetData[4]), + flag: packetData[5], + } +} + +func (pck *Packet) bytes() []byte { + output := make([]byte, 8) + if pck.dataOffset > 8 { + output = append(output, make([]byte, pck.dataOffset-8)...) + } + binary.BigEndian.PutUint16(output, pck.length) + output[4] = uint8(pck.packetType) + output[5] = pck.flag + return output +} +func (pck *Packet) getPacketType() PacketType { + return pck.packetType +} diff --git a/network/redirect_packet.go b/network/redirect_packet.go new file mode 100644 index 00000000..622ff334 --- /dev/null +++ b/network/redirect_packet.go @@ -0,0 +1,49 @@ +package network + +import ( + "encoding/binary" + "strings" +) + +type RedirectPacket struct { + packet Packet + redirectAddr string + reconnectData string +} + +func (pck *RedirectPacket) bytes() []byte { + output := pck.packet.bytes() + data := append([]byte(pck.redirectAddr), 0) + data = append(data, []byte(pck.reconnectData)...) + binary.BigEndian.PutUint16(output[8:], uint16(len(data))) + output = append(output, data...) + return output +} + +func (pck *RedirectPacket) getPacketType() PacketType { + return pck.packet.packetType +} + +func newRedirectPacketFromData(packetData []byte) *RedirectPacket { + if len(packetData) < 10 { + return nil + } + dataLen := binary.BigEndian.Uint16(packetData[8:]) + + pck := RedirectPacket{ + packet: Packet{ + dataOffset: 10, + length: binary.BigEndian.Uint16(packetData), + packetType: PacketType(packetData[4]), + flag: packetData[5], + }, + } + data := string(packetData[10 : 10+dataLen]) + if pck.packet.flag&0x2 == 0 { + return nil + } + length := strings.Index(data, "\x00") + pck.redirectAddr = data[:length] + pck.reconnectData = data[length:] + return &pck +} diff --git a/network/refuse_packet.go b/network/refuse_packet.go new file mode 100644 index 00000000..67e57904 --- /dev/null +++ b/network/refuse_packet.go @@ -0,0 +1,45 @@ +package network + +import "encoding/binary" + +type RefusePacket struct { + packet Packet + //dataOffset uint16 + //Len uint16 + //packetType PacketType + //Flag uint8 + SystemReason uint8 + UserReason uint8 + message string +} + +func (pck *RefusePacket) bytes() []byte { + output := pck.packet.bytes() + output[8] = pck.SystemReason + output[9] = pck.UserReason + data := []byte(pck.message) + binary.BigEndian.PutUint16(output[10:], uint16(len(data))) + output = append(output, data...) + return output +} + +func (pck *RefusePacket) getPacketType() PacketType { + return pck.packet.packetType +} +func newRefusePacketFromData(packetData []byte) *RefusePacket { + if len(packetData) < 12 { + return nil + } + dataLen := binary.BigEndian.Uint16(packetData[10:]) + return &RefusePacket{ + packet: Packet{ + dataOffset: 12, + length: binary.BigEndian.Uint16(packetData), + packetType: PacketType(packetData[4]), + flag: 0, + }, + SystemReason: packetData[9], + UserReason: packetData[8], + message: string(packetData[12 : 12+dataLen]), + } +} diff --git a/network/session.go b/network/session.go new file mode 100644 index 00000000..ec01fcdb --- /dev/null +++ b/network/session.go @@ -0,0 +1,742 @@ +package network + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "go-ora/converters" + "log" + "net" + "strings" +) + +type Data interface { + Write(session *Session) error + Read(session *Session) error +} + +type Session struct { + conn net.Conn + connOption ConnectionOption + Context *SessionContext + sendPcks []PacketInterface + inBuffer []byte + outBuffer []byte + index int + key []byte + salt []byte + verifierType int + TimeZone []byte + TTCVersion uint8 + HasEOSCapability bool + HasFSAPCapability bool + Summary *SummaryObject + StrConv *converters.StringConverter +} + +func NewSession(connOption ConnectionOption) *Session { + return &Session{ + conn: nil, + inBuffer: nil, + outBuffer: nil, + index: 0, + connOption: connOption, + Context: NewSessionContext(connOption), + Summary: nil, + } +} + +func (session *Session) Connect() error { + session.Disconnect() + var err error + var host string + if !strings.Contains(session.connOption.Host, ":") { + host = fmt.Sprintf("%s:%d", session.connOption.Host, session.connOption.Port) + } else { + host = session.connOption.Host + } + + session.conn, err = net.Dial(session.connOption.Protocol, host) + if err != nil { + return err + } + connectPacket := newConnectPacket(*session.Context) + err = session.writePacket(connectPacket) + if err != nil { + return err + } + if connectPacket.packet.length == 58 { + session.PutBytes(connectPacket.buffer) + err = session.Write() + if err != nil { + return err + } + } + pck, err := session.readPacket() + if err != nil { + return err + } + + acceptPacket, ok := pck.(*AcceptPacket) + if !ok { + return errors.New("connection refused by the server") + } + *session.Context = acceptPacket.sessionCtx + + //for { + // err = session.writePacket(newConnectPacket(*session.Context)) + // + // rPck, err := session.readPacket() + // if err != nil { + // return err + // } + // if rPck == nil { + // return errors.New("packet is null due to unknown packet type") + // } + // + // tmpPck, ok := rPck.(*Packet) + // if ok && tmpPck.packetType == RESEND { + // continue + // } + //} + return nil +} + +func (session *Session) Disconnect() { + session.ResetBuffer() + if session.conn != nil { + _ = session.conn.Close() + session.conn = nil + } +} + +func (session *Session) ResetBuffer() { + session.Summary = nil + session.sendPcks = nil + session.inBuffer = nil + session.outBuffer = nil + session.index = 0 +} + +func (session *Session) Debug() { + //if session.index > 350 && session.index < 370 { + fmt.Println("index: ", session.index) + fmt.Printf("data buffer: %#v\n", session.inBuffer[session.index:session.index+30]) + oldIndex := session.index + fmt.Println(session.GetClr()) + session.index = oldIndex + //} +} +func (session *Session) DumpIn() { + log.Printf("%#v\n", session.inBuffer) +} + +func (session *Session) DumpOut() { + log.Printf("%#v\n", session.outBuffer) +} + +func (session *Session) Write() error { + size := uint(len(session.outBuffer)) + if size == 0 { + // send empty data packet + return session.writePacket(newDataPacket(nil)) + //return errors.New("the output buffer is empty") + } + segment := uint(session.Context.SessionDataUnit - 20) + offset := uint(0) + for size > segment { + err := session.writePacket(newDataPacket(session.outBuffer[offset : offset+segment])) + if err != nil { + session.outBuffer = nil + return err + } + size -= segment + offset += segment + } + if size != 0 { + err := session.writePacket(newDataPacket(session.outBuffer[offset:])) + if err != nil { + session.outBuffer = nil + return err + } + } + return nil +} + +func (session *Session) read(numBytes int) ([]byte, error) { + if session.index+numBytes > len(session.inBuffer) { + pck, err := session.readPacket() + if err != nil { + return nil, err + } + if dataPck, ok := pck.(*DataPacket); ok { + session.inBuffer = append(session.inBuffer, dataPck.buffer...) + } else { + return nil, errors.New("the packet received is not data packet") + } + } + ret := session.inBuffer[session.index : session.index+numBytes] + session.index += numBytes + return ret, nil +} + +//func (session *Session) writePackets() error { +// +// return nil +//} +func (session *Session) writePacket(pck PacketInterface) error { + session.sendPcks = append(session.sendPcks, pck) + tmp := pck.bytes() + //log.Printf("Request: %#v\n\n", tmp) + _, err := session.conn.Write(tmp) + if err != nil { + return err + } + return nil +} + +func (session *Session) HasError() bool { + return session.Summary != nil && session.Summary.RetCode != 0 +} + +func (session *Session) GetError() string { + if session.Summary != nil && session.Summary.RetCode != 0 { + if session.StrConv != nil { + return session.StrConv.Decode(session.Summary.ErrorMessage) + } else { + return string(session.Summary.ErrorMessage) + } + } + return "" +} + +func (session *Session) readPacket() (PacketInterface, error) { + + readPacketData := func(conn net.Conn) ([]byte, error) { + trials := 0 + for { + if trials > 3 { + return nil, errors.New("abnormal response") + } + trials++ + head := make([]byte, 8) + _, err := conn.Read(head) + if err != nil { + return nil, err + } + length := binary.BigEndian.Uint16(head) + length -= 8 + body := make([]byte, length) + index := uint16(0) + for index < length { + temp, err := conn.Read(body[index:]) + if err != nil { + if e, ok := err.(net.Error); ok && e.Timeout() && temp != 0 { + index += uint16(temp) + continue + } + return nil, err + } + index += uint16(temp) + } + pckType := PacketType(head[4]) + if pckType == RESEND { + for _, pck := range session.sendPcks { + //log.Printf("Request: %#v\n\n", pck.bytes()) + _, err := session.conn.Write(pck.bytes()) + if err != nil { + return nil, err + } + } + continue + } + + return append(head, body...), nil + } + + } + + packetData, err := readPacketData(session.conn) + if err != nil { + return nil, err + } + pckType := PacketType(packetData[4]) + //log.Printf("Response: %#v\n\n", packetData) + switch pckType { + case ACCEPT: + return newAcceptPacketFromData(packetData), nil + case REFUSE: + return newRefusePacketFromData(packetData), nil + case REDIRECT: + return newRedirectPacketFromData(packetData), nil + case DATA: + return newDataPacketFromData(packetData), nil + case MARKER: + pck := newMarkerPacketFromData(packetData) + breakConnection := false + resetConnection := false + switch pck.markerType { + case 0: + breakConnection = true + case 1: + if pck.markerData == 2 { + resetConnection = true + } else { + breakConnection = true + } + default: + return nil, errors.New("unknown marker type") + } + trials := 1 + for breakConnection && !resetConnection { + if trials > 3 { + return nil, errors.New("connection break") + } + packetData, err = readPacketData(session.conn) + if err != nil { + return nil, err + } + pck = newMarkerPacketFromData(packetData) + if pck == nil { + return nil, errors.New("connection break") + } + switch pck.markerType { + case 0: + breakConnection = true + case 1: + if pck.markerData == 2 { + resetConnection = true + } else { + breakConnection = true + } + default: + return nil, errors.New("unknown marker type") + } + trials++ + } + session.ResetBuffer() + err = session.writePacket(newMarkerPacket(2)) + if err != nil { + return nil, err + } + packetData, err = readPacketData(session.conn) + if err != nil { + return nil, err + } + dataPck := newDataPacketFromData(packetData) + if dataPck == nil { + return nil, errors.New("connection break") + } + session.inBuffer = dataPck.buffer + session.index = 0 + msg, err := session.GetByte() + if err != nil { + return nil, err + } + if msg == 4 { + session.Summary, err = NewSummary(session) + if err != nil { + return nil, err + } + if session.HasError() { + return nil, errors.New(session.GetError()) + } + } + fallthrough + default: + return nil, nil + } +} + +func (session *Session) PutBytes(data []byte) { + session.outBuffer = append(session.outBuffer, data...) +} + +func (session *Session) PutUint(number interface{}, size uint8, bigEndian bool, compress bool) { + var num uint64 + switch number := number.(type) { + case int64: + num = uint64(number) + case int32: + num = uint64(number) + case int16: + num = uint64(number) + case int8: + num = uint64(number) + case uint64: + num = number + case uint32: + num = uint64(number) + case uint16: + num = uint64(number) + case uint8: + num = uint64(number) + case uint: + num = uint64(number) + case int: + num = uint64(number) + default: + panic("you need to pass an integer to this function") + } + if size == 1 { + session.outBuffer = append(session.outBuffer, uint8(num)) + return + } + if compress { + // if the size is one byte no compression occur only one byte written + temp := make([]byte, 8) + binary.BigEndian.PutUint64(temp, num) + temp = bytes.TrimLeft(temp, "\x00") + if size > uint8(len(temp)) { + size = uint8(len(temp)) + } + if size == 0 { + session.outBuffer = append(session.outBuffer, 0) + } else { + session.outBuffer = append(session.outBuffer, size) + session.outBuffer = append(session.outBuffer, temp...) + } + } else { + temp := make([]byte, size) + if bigEndian { + switch size { + case 2: + binary.BigEndian.PutUint16(temp, uint16(num)) + case 4: + binary.BigEndian.PutUint32(temp, uint32(num)) + case 8: + binary.BigEndian.PutUint64(temp, num) + } + } else { + switch size { + case 2: + binary.LittleEndian.PutUint16(temp, uint16(num)) + case 4: + binary.LittleEndian.PutUint32(temp, uint32(num)) + case 8: + binary.LittleEndian.PutUint64(temp, num) + } + } + session.outBuffer = append(session.outBuffer, temp...) + } +} + +func (session *Session) PutInt(number interface{}, size uint8, bigEndian bool, compress bool) { + var num int64 + switch number := number.(type) { + case int64: + num = number + case int32: + num = int64(number) + case int16: + num = int64(number) + case int8: + num = int64(number) + case uint64: + num = int64(number) + case uint32: + num = int64(number) + case uint16: + num = int64(number) + case uint8: + num = int64(number) + case uint: + num = int64(number) + case int: + num = int64(number) + default: + panic("you need to pass an integer to this function") + } + + if compress { + temp := make([]byte, 8) + binary.BigEndian.PutUint64(temp, uint64(num)) + temp = bytes.TrimLeft(temp, "\x00") + if size > uint8(len(temp)) { + size = uint8(len(temp)) + } + if size == 0 { + session.outBuffer = append(session.outBuffer, 0) + } else { + if num < 0 { + num = num * -1 + size = size & 0x80 + } + session.outBuffer = append(session.outBuffer, size) + session.outBuffer = append(session.outBuffer, temp...) + } + } else { + if size == 1 { + session.outBuffer = append(session.outBuffer, uint8(num)) + } else { + temp := make([]byte, size) + if bigEndian { + switch size { + case 2: + binary.BigEndian.PutUint16(temp, uint16(num)) + case 4: + binary.BigEndian.PutUint32(temp, uint32(num)) + case 8: + binary.BigEndian.PutUint64(temp, uint64(num)) + } + } else { + switch size { + case 2: + binary.LittleEndian.PutUint16(temp, uint16(num)) + case 4: + binary.LittleEndian.PutUint32(temp, uint32(num)) + case 8: + binary.LittleEndian.PutUint64(temp, uint64(num)) + } + } + session.outBuffer = append(session.outBuffer, temp...) + } + } +} + +func (session *Session) PutClr(data []byte) { + dataLen := len(data) + if dataLen == 0 { + session.outBuffer = append(session.outBuffer, 0) + return + } + if dataLen > 0x40 { + session.outBuffer = append(session.outBuffer, 0xFE) + } + start := 0 + for start < dataLen { + end := start + 0x40 + if end > dataLen { + end = dataLen + } + temp := data[start:end] + session.outBuffer = append(session.outBuffer, uint8(len(temp))) + session.outBuffer = append(session.outBuffer, temp...) + start += 64 + } + if dataLen > 0x40 { + session.outBuffer = append(session.outBuffer, 0) + } +} + +func (session *Session) PutKeyValString(key string, val string, num uint8) { + session.PutKeyVal([]byte(key), []byte(val), num) +} + +func (session *Session) PutKeyVal(key []byte, val []byte, num uint8) { + if len(key) == 0 { + session.outBuffer = append(session.outBuffer, 0) + } else { + session.PutUint(len(key), 4, true, true) + session.PutClr(key) + } + if len(val) == 0 { + session.outBuffer = append(session.outBuffer, 0) + } else { + session.PutUint(len(val), 4, true, true) + session.PutClr(val) + } + session.PutInt(num, 4, true, true) +} + +func (session *Session) PutData(data Data) error { + return data.Write(session) +} +func (session *Session) GetData(data Data) error { + return data.Read(session) +} +func (session *Session) GetByte() (uint8, error) { + rb, err := session.read(1) + if err != nil { + return 0, err + } + return rb[0], nil +} + +func (session *Session) GetInt64(size int, compress bool, bigEndian bool) (int64, error) { + var ret int64 + negFlag := false + if compress { + rb, err := session.read(1) + if err != nil { + return 0, err + } + size = int(rb[0]) + if size&0x80 > 0 { + negFlag = true + size = size & 0x7F + } + bigEndian = true + } + if size == 0 { + return 0, nil + } + rb, err := session.read(size) + if err != nil { + return 0, err + } + temp := make([]byte, 8) + if bigEndian { + copy(temp[8-size:], rb) + ret = int64(binary.BigEndian.Uint64(temp)) + } else { + copy(temp[:size], rb) + //temp = append(pck.buffer[pck.index: pck.index + size], temp...) + ret = int64(binary.LittleEndian.Uint64(temp)) + } + if negFlag { + ret = ret * -1 + } + return ret, nil +} +func (session *Session) GetInt(size int, compress bool, bigEndian bool) (int, error) { + temp, err := session.GetInt64(size, compress, bigEndian) + if err != nil { + return 0, err + } + return int(temp), nil +} +func (session *Session) GetNullTermString(maxSize int) (result string, err error) { + oldIndex := session.index + temp, err := session.read(maxSize) + if err != nil { + return + } + find := bytes.Index(temp, []byte{0}) + if find > 0 { + result = string(temp[:find]) + session.index = oldIndex + find + 1 + } else { + result = string(temp) + } + return +} + +func (session *Session) GetClr() (output []byte, err error) { + var size uint8 + var rb []byte + size, err = session.GetByte() + if err != nil { + return + } + if size == 253 { + err = errors.New("TTC error") + return + } + if size == 0 || size == 0xFF { + output = nil + err = nil + return + } + if size != 0xFE { + output, err = session.read(int(size)) + return + } + output = make([]byte, 0, 1000) + for { + var size1 uint8 + size1, err = session.GetByte() + if err != nil || size1 == 0 { + break + } + rb, err = session.read(int(size1)) + if err != nil { + return + } + output = append(output, rb...) + } + return +} + +func (session *Session) GetDlc() (output []byte, err error) { + var length int + length, err = session.GetInt(4, true, true) + if err != nil { + return + } + if length > 0 { + output, err = session.GetClr() + if len(output) > length { + output = output[:length] + } + } + return +} + +func (session *Session) GetBytes(length int) ([]byte, error) { + return session.read(length) +} + +// return key, val, int and error +func (session *Session) GetKeyVal() (key []byte, val []byte, num int, err error) { + key, err = session.GetDlc() + if err != nil { + return + } + val, err = session.GetDlc() + if err != nil { + return + } + num, err = session.GetInt(4, true, true) + return +} + +//func (session *Session) DoAuth(logonMode int) error{ +// index := strings.LastIndex(session.connOption.ClientData.ProgramName, "/") +// if index < 0 { +// index = 0 +// } else { +// index += 1 +// } +// ikeys := []string{"AUTH_TERMINAL", "AUTH_PROGRAM_NM", "AUTH_MACHINE", "AUTH_PID", "AUTH_SID"} +// ivals := []string{ +// session.connOption.ClientData.HostName, +// session.connOption.ClientData.ProgramName[index:], +// session.connOption.ClientData.HostName, +// fmt.Sprintf("%d", session.connOption.ClientData.PID), +// session.connOption.ClientData.UserName, +// } +// inums := []int{0, 0, 0, 0, 0} +// +// var pck = newDataPacket([]byte {3, 118, 0, 1}) // message_code, function_code, sequence_number, 1 +// pck.AppendInt(len(session.connOption.UserID), 4, false, true) +// pck.AppendInt(logonMode | 1, 4, false, true) +// pck.AppendBytes([]byte{1, 1, 5, 1, 1}, false) +// pck.AppendBytes([]byte(session.connOption.UserID), false) +// pck.AppendKeyVal(ikeys, ivals, inums) +// authData, err := session.SendData(pck.Data()) +// if err != nil { +// return err +// } +// rPck := newDataPacket(authData) +// messageCode, err := rPck.ReadInt(1, false, false) +// if err != nil { +// return err +// } +// if messageCode != 8 { +// return errors.New(fmt.Sprintf("message code error: received code %d and expected code is 8", messageCode)) +// } +// dictLen, err := rPck.ReadInt(4, true, true) +// if err != nil { +// return err +// } +// keys, vals, nums, err := rPck.ReadKeyVal(int(dictLen)) +// if err != nil { +// fmt.Println(err) +// return err +// } +// for x:=0; x < len(keys); x++ { +// if bytes.Compare(keys[x], []byte("AUTH_SESSKEY")) == 0 { +// session.key = vals[x] +// } else if bytes.Compare(keys[x], []byte("AUTH_VFR_DATA")) == 0 { +// session.salt = vals[x] +// session.verifierType = nums[x] +// } +// } +// if len(session.key) != 64 && len(session.key) != 96 { +// return errors.New("TCC Error: SessionKey should be either 64 or 96 bytes long.") +// } +// // load the error object +// return nil +//} diff --git a/network/session_ctx.go b/network/session_ctx.go new file mode 100644 index 00000000..12d1a959 --- /dev/null +++ b/network/session_ctx.go @@ -0,0 +1,58 @@ +package network + +//internal static readonly int NSVSNDHS = 311; +//internal static readonly int NSVSNRDS = 312; +//internal static readonly int NSVSNRDR = 312; +//internal static readonly int NSVSNDHO = 312; +//internal static readonly int NSVSNDHE = 314; +//internal static readonly int NSVSNIP6 = 314; +//internal static readonly int NSVSNSRN = 313; +//internal static readonly int NSVSNPPP = 313; + +type SessionContext struct { + //conn net.Conn + connOption ConnectionOption + //PortNo int + //InstanceName string + //HostName string + //IPAddress string + //Protocol string + //ServiceName string + SID []byte + //internal Stream m_socketStream; + //internal Socket m_socket; + //internal ReaderStream m_readerStream; + //internal WriterStream m_writerStream; + //internal ITransportAdapter m_transportAdapter; + //ConnectData string + Version uint16 + LoVersion uint16 + Options uint16 + NegotiatedOptions uint16 + OurOne uint16 + Histone uint16 + ReconAddr string + //internal Ano m_ano; + //internal bool m_bAnoEnabled; + ACFL0 uint8 + ACFL1 uint8 + SessionDataUnit uint16 + TransportDataUnit uint16 + UsingAsyncReceivers bool + IsNTConnected bool + OnBreakReset bool + GotReset bool +} + +func NewSessionContext(connOption ConnectionOption) *SessionContext { + return &SessionContext{ + SessionDataUnit: connOption.SessionDataUnitSize, + TransportDataUnit: connOption.TransportDataUnitSize, + Version: 312, + LoVersion: 300, + Options: 1 | 1024 | 2048, + OurOne: 1, + connOption: connOption, + } +} + diff --git a/network/summary_object.go b/network/summary_object.go new file mode 100644 index 00000000..3c536699 --- /dev/null +++ b/network/summary_object.go @@ -0,0 +1,254 @@ +package network + +type BindError struct { + errorCode int + rowOffset int + errorMsg []byte +} +type SummaryObject struct { + EndOfCallStatus int // uint32 + EndToEndECIDSequence int // uint16 + CurRowNumber int // uint32 + RetCode int // uint16 + arrayElmWError int // uint16 + arrayElmErrno int //uint16 + CursorID int // uint16 + errorPos int // uint16 + sqlType uint8 + oerFatal uint8 + flags int // uint16 + userCursorOPT int // uint16 + upiParam uint8 + warningFlag uint8 + rba int // uint32 + partitionID int // uint16 + tableID uint8 + blockNumber int // uint32 + slotNumber int // uint16 + osError int // uint32 + stmtNumber uint8 + callNumber uint8 + pad1 int // uint16 + successIter int // uint16 + ErrorMessage []byte + bindErrors []BindError +} + +func NewSummary(session *Session) (*SummaryObject, error) { + result := new(SummaryObject) + var err error + if session.HasEOSCapability { + result.EndOfCallStatus, err = session.GetInt(4, true, true) + if err != nil { + return nil, err + } + } + if session.HasFSAPCapability { + result.EndToEndECIDSequence, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + } + result.CurRowNumber, err = session.GetInt(4, true, true) + if err != nil { + return nil, err + } + result.RetCode, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.arrayElmWError, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.arrayElmErrno, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.CursorID, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.errorPos, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.sqlType, err = session.GetByte() + if err != nil { + return nil, err + } + result.oerFatal, err = session.GetByte() + if err != nil { + return nil, err + } + result.flags, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.userCursorOPT, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.upiParam, err = session.GetByte() + if err != nil { + return nil, err + } + result.warningFlag, err = session.GetByte() + if err != nil { + return nil, err + } + result.rba, err = session.GetInt(4, true, true) + if err != nil { + return nil, err + } + result.partitionID, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.tableID, err = session.GetByte() + if err != nil { + return nil, err + } + result.blockNumber, err = session.GetInt(4, true, true) + if err != nil { + return nil, err + } + result.slotNumber, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.osError, err = session.GetInt(4, true, true) + if err != nil { + return nil, err + } + result.stmtNumber, err = session.GetByte() + if err != nil { + return nil, err + } + result.callNumber, err = session.GetByte() + if err != nil { + return nil, err + } + result.pad1, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.successIter, err = session.GetInt(4, true, true) + if err != nil { + return nil, err + } + _, _ = session.GetDlc() + length, err := session.GetInt(2, true, true) + if err != nil { + return nil, err + } + if length > 0 { + result.bindErrors = make([]BindError, length) + num, err := session.GetByte() + if err != nil { + return nil, err + } + flag := num == 0xFE + for x := 0; x < length; x++ { + if flag { + _, _ = session.GetByte() + } + result.bindErrors[x].errorCode, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + } + if flag { + _, _ = session.GetByte() + } + } + length, err = session.GetInt(4, true, true) + if err != nil { + return nil, err + } + if length > 0 { + num, err := session.GetByte() + if err != nil { + return nil, err + } + flag := num == 0xFE + for x := 0; x < length; x++ { + if flag { + _, _ = session.GetByte() + } + result.bindErrors[x].rowOffset, err = session.GetInt(4, true, true) + if err != nil { + return nil, err + } + } + if flag { + _, _ = session.GetByte() + } + } + length, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + if length > 0 { + _, _ = session.GetByte() + for x := 0; x < length; x++ { + _, err := session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.bindErrors[x].errorMsg, err = session.GetClr() + if err != nil { + return nil, err + } + _, _ = session.GetByte() + _, _ = session.GetByte() + } + } + if result.RetCode != 0 { + result.ErrorMessage, err = session.GetClr() + if err != nil { + return nil, err + } + } + + //if result.sqlType == 3 && result.RetCode == 1403 { + // _, _ = session.GetClr() + //} else if result.RetCode != 0 { + // + //} + //fmt.Println(result) + return result, nil +} + +type WarningObject struct { + retCode int + flag int + errorMessage string +} + +func NewWarningObject(session *Session) (*WarningObject, error) { + result := new(WarningObject) + var err error + result.retCode, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + length, err := session.GetInt(2, true, true) + if err != nil { + return nil, err + } + result.flag, err = session.GetInt(2, true, true) + if err != nil { + return nil, err + } + if result.retCode == 0 || length == 0 { + return nil, nil + } else { + msg, err := session.GetClr() + if err != nil { + return nil, err + } + result.errorMessage = string(msg) + } + return result, nil +} diff --git a/parameter.go b/parameter.go new file mode 100644 index 00000000..d4845ebe --- /dev/null +++ b/parameter.go @@ -0,0 +1,335 @@ +package go_ora + +import ( + "go-ora/network" + "math" + "strings" +) + +type OracleType int +type ParameterDirection int + +const ( + Input ParameterDirection = 1 + Output ParameterDirection = 2 + InOut ParameterDirection = 3 + RetVal ParameterDirection = 9 +) + +//internal enum BindDirection +//{ +//Output = 16, +//Input = 32, +//InputOutput = 48, +//} +const ( + NCHAR OracleType = 1 + NUMBER OracleType = 2 + SB1 OracleType = 3 + SB2 OracleType = 3 + SB4 OracleType = 3 + FLOAT OracleType = 4 + NullStr OracleType = 5 + VarNum OracleType = 6 + LONG OracleType = 8 + VARCHAR OracleType = 9 + ROWID OracleType = 11 + DATE OracleType = 12 + VarRaw OracleType = 15 + BFloat OracleType = 21 + BDouble OracleType = 22 + RAW OracleType = 23 + LongRaw OracleType = 24 + UINT OracleType = 68 + LongVarChar OracleType = 94 + LongVarRaw OracleType = 95 + CHAR OracleType = 96 + CHARZ OracleType = 97 + IBFloat OracleType = 100 + IBDouble OracleType = 101 + RefCursor OracleType = 102 + NOT OracleType = 108 + XMLType OracleType = 108 + OCIRef OracleType = 110 + OCIClobLocator OracleType = 112 + OCIBlobLocator OracleType = 113 + OCIFileLocator OracleType = 114 + ResultSet OracleType = 116 + OCIString OracleType = 155 + OCIDate OracleType = 156 + TimeStampDTY OracleType = 180 + TimeStampTZ_DTY OracleType = 181 + IntervalYM_DTY OracleType = 182 + IntervalDS_DTY OracleType = 183 + TimeTZ OracleType = 186 + TimeStamp OracleType = 187 + TimeStampTZ OracleType = 188 + IntervalYM OracleType = 189 + IntervalDS OracleType = 190 + UROWID OracleType = 208 + TimeStampLTZ_DTY OracleType = 231 + TimeStampeLTZ OracleType = 232 +) + +type ParameterType int + +const ( + Number ParameterType = 1 + String ParameterType = 2 +) + +type ParameterInfo struct { + Name string + Direction ParameterDirection + IsNull bool + AllowNull bool + ColAlias string + DataType OracleType + IsXmlType bool + Flag uint8 + Precision uint16 + Scale uint16 + MaxLen int + MaxCharLen int + MaxNoOfArrayElements int + ContFlag int + ToID []byte + Version int + CharsetID int + CharsetForm int + Value []byte + getDataFromServer bool +} + +//func (par *ParameterInfo) Read(session *network.Session) error { +// return nil +//} + +func (par *ParameterInfo) read(session *network.Session) error { + par.getDataFromServer = true + dataType, err := session.GetByte() + if err != nil { + return err + } + par.DataType = OracleType(dataType) + par.Flag, err = session.GetByte() + if err != nil { + return err + } + precision, err := session.GetInt(1, false, false) + var scale int + switch par.DataType { + case NUMBER: + fallthrough + case TimeStampDTY: + fallthrough + case TimeStampTZ_DTY: + fallthrough + case IntervalDS_DTY: + fallthrough + case TimeStamp: + fallthrough + case TimeStampTZ: + fallthrough + case IntervalDS: + fallthrough + case TimeStampLTZ_DTY: + fallthrough + case TimeStampeLTZ: + scale, err = session.GetInt(2, true, true) + default: + scale, err = session.GetInt(1, false, false) + } + if scale == -127 { + precision = int(math.Ceil(float64(precision) * 0.30103)) + scale = 0xFF + } + if par.DataType == NUMBER && precision == 0 && (scale == 0 || scale == 0xFF) { + precision = 38 + scale = 0xFF + } + par.Scale = uint16(scale) + par.Precision = uint16(precision) + par.MaxLen, err = session.GetInt(4, true, true) + if err != nil { + return err + } + switch par.DataType { + case ROWID: + par.MaxLen = 128 + case DATE: + par.MaxLen = 7 + case IBFloat: + par.MaxLen = 4 + case IBDouble: + par.MaxLen = 8 + case TimeStampTZ_DTY: + par.MaxLen = 13 + case IntervalYM_DTY: + fallthrough + case IntervalDS_DTY: + fallthrough + case IntervalYM: + fallthrough + case IntervalDS: + par.MaxLen = 11 + } + par.MaxNoOfArrayElements, err = session.GetInt(4, true, true) + if err != nil { + return err + } + par.ContFlag, err = session.GetInt(4, true, true) + if err != nil { + return err + } + par.ToID, err = session.GetDlc() + par.Version, err = session.GetInt(2, true, true) + if err != nil { + return err + } + par.CharsetID, err = session.GetInt(2, true, true) + if err != nil { + return err + } + par.CharsetForm, err = session.GetInt(1, false, false) + if err != nil { + return err + } + par.MaxCharLen, err = session.GetInt(4, true, true) + if err != nil { + return err + } + num1, err := session.GetInt(1, false, false) + if err != nil { + return err + } + par.AllowNull = num1 > 0 + _, err = session.GetInt(1, false, false) + if err != nil { + return err + } + bName, err := session.GetDlc() + if err != nil { + return err + } + par.Name = string(bName) + _, err = session.GetDlc() + bName, err = session.GetDlc() + if err != nil { + return err + } + if strings.ToUpper(string(bName)) == "XMLTYPE" { + par.DataType = XMLType + par.IsXmlType = true + } + if session.TTCVersion < 3 { + return nil + } + _, err = session.GetInt(2, true, true) + if session.TTCVersion < 6 { + return nil + } + _, err = session.GetInt(4, true, true) + return nil +} +func (par *ParameterInfo) write(session *network.Session) error { + session.PutUint(int(par.DataType), 1, false, false) + session.PutUint(par.Flag, 1, false, false) + session.PutUint(par.Precision, 1, false, false) + session.PutUint(par.Scale, 1, false, false) + session.PutUint(par.MaxLen, 4, true, true) + session.PutInt(par.MaxNoOfArrayElements, 4, true, true) + session.PutInt(par.ContFlag, 4, true, true) + if par.ToID == nil { + session.PutInt(0, 1, false, false) + } else { + session.PutInt(len(par.ToID), 4, true, true) + session.PutClr(par.ToID) + } + session.PutUint(par.Version, 2, true, true) + session.PutUint(par.CharsetID, 2, true, true) + session.PutUint(par.CharsetForm, 1, false, false) + session.PutUint(par.MaxCharLen, 4, true, true) + return nil +} + +//func NewIntegerParameter(name string, val int, direction ParameterDirection) *ParameterInfo { +// ret := ParameterInfo{ +// Name: name, +// Direction: direction, +// flag: 3, +// ContFlag: 0, +// DataType: NUMBER, +// MaxCharLen: 22, +// MaxLen: 22, +// CharsetID: 871, +// CharsetForm: 1, +// Value: converters.EncodeInt(val), +// } +// return &ret +//} +//func NewStringParameter(name string, val string, size int, direction ParameterDirection) *ParameterInfo { +// ret := ParameterInfo{ +// Name: name, +// Direction: direction, +// flag: 3, +// ContFlag: 16, +// DataType: NCHAR, +// MaxCharLen: size, +// MaxLen: size, +// CharsetID: 871, +// CharsetForm: 1, +// Value: []byte(val), +// } +// return &ret +//} + +//func NewParamInfo(name string, parType ParameterType, size int, direction ParameterDirection) *ParameterInfo { +// ret := new(ParameterInfo) +// ret.Name = name +// ret.Direction = direction +// ret.flag = 3 +// //ret.DataType = dataType +// switch parType { +// case String: +// ret.ContFlag = 16 +// default: +// ret.ContFlag = 0 +// } +// switch parType { +// case Number: +// ret.DataType = NUMBER +// ret.MaxLen = 22 +// case String: +// ret.CharsetForm = 1 +// ret.DataType = NCHAR +// ret.MaxCharLen = size +// ret.MaxLen = size +// } +// //ret.MaxCharLen = 0 // number of character to write +// //ret.MaxLen = ret.MaxCharLen * 1 // number of character * byte per character +// ret.CharsetID = 871 +// return ret +// // if duplicateBind ret.flag = 128 else ret.flag = 3 +// // if collection type is assocative array ret.Flat |= 64 +// +// //num3 := 0 +// //switch dataType { +// //case LONG: +// // fallthrough +// //case LongRaw: +// // fallthrough +// //case CHAR: +// // fallthrough +// //case RAW: +// // fallthrough +// //case NCHAR: +// // num3 = 1 +// //default: +// // num3 = 0 +// //} +// //if num3 != 0 { +// // +// //} +// //return ret +//} diff --git a/simple_object.go b/simple_object.go new file mode 100644 index 00000000..6370dff6 --- /dev/null +++ b/simple_object.go @@ -0,0 +1,71 @@ +package go_ora + +import ( + "errors" + "fmt" + "go-ora/network" +) + +type simpleObject struct { + session *network.Session + operationID uint8 + data []byte + err error +} + +func (obj *simpleObject) write() *simpleObject{ + //obj.session.ResetBuffer() + obj.session.PutBytes([]byte {3, obj.operationID, 0}) + if obj.data != nil { + obj.session.PutBytes(obj.data) + } + obj.err = obj.session.Write() + return obj +} + +func (obj *simpleObject) read() error { + if obj.err != nil { + return obj.err + } + loop := true + for loop { + msg, err := obj.session.GetByte() + if err != nil { + return err + } + switch msg { + case 4: + obj.session.Summary, err = network.NewSummary(obj.session) + if err != nil { + return err + } + loop = false + case 9: + if obj.session.HasEOSCapability { + if obj.session.Summary == nil { + obj.session.Summary = new(network.SummaryObject) + } + obj.session.Summary.EndOfCallStatus, err = obj.session.GetInt(4, true, true) + if err != nil { + return err + } + } + if obj.session.HasFSAPCapability { + if obj.session.Summary == nil { + obj.session.Summary = new(network.SummaryObject) + } + obj.session.Summary.EndToEndECIDSequence, err = obj.session.GetInt(2, true, true) + if err != nil { + return err + } + } + loop = false + default: + return errors.New(fmt.Sprintf("message code error: received code %d and expected code is 4, 9", msg)) + } + } + if obj.session.HasError() { + return errors.New(obj.session.GetError()) + } + return nil +} \ No newline at end of file diff --git a/tcp_protocol_nego.go b/tcp_protocol_nego.go new file mode 100644 index 00000000..20f00061 --- /dev/null +++ b/tcp_protocol_nego.go @@ -0,0 +1,108 @@ +package go_ora + +import ( + "encoding/binary" + "errors" + "fmt" + "go-ora/network" +) + +type TCPNego struct { + MessageCode uint8 + ProtocolServerVersion uint8 + ProtocolServerString string + OracleVersion int + ServerCharset int + ServerFlags uint8 + CharsetElem int + ServernCharset int + ServerCompileTimeCaps []byte + ServerRuntimeCaps []byte +} + +func NewTCPNego(session *network.Session) (*TCPNego, error) { + session.ResetBuffer() + session.PutBytes([]byte{1, 6, 0}) + session.PutBytes([]byte("OracleClientGo\x00")) + err := session.Write() + if err != nil { + return nil, err + } + result := TCPNego{} + result.MessageCode, err = session.GetByte() + if err != nil { + return nil, err + } + if result.MessageCode != 1 { + return nil, errors.New(fmt.Sprintf("message code error: received code %d and expected code is 1", result.MessageCode)) + } + result.ProtocolServerVersion, err = session.GetByte() + if err != nil { + return nil, err + } + switch result.ProtocolServerVersion { + case 4: + result.OracleVersion = 7230 + case 5: + result.OracleVersion = 8030 + case 6: + result.OracleVersion = 8100 + default: + return nil, errors.New("unsupported server version") + } + _, _ = session.GetByte() + result.ProtocolServerString, err = session.GetNullTermString(50) + if err != nil { + return nil, err + } + + result.ServerCharset, err = session.GetInt(2, false, false) + if err != nil { + return nil, err + } + result.ServerFlags, err = session.GetByte() + if err != nil { + return nil, err + } + result.CharsetElem, err = session.GetInt(2, false, false) + if err != nil { + return nil, err + } + if result.CharsetElem > 0 { + _, _ = session.GetBytes(result.CharsetElem * 5) + } + + len1, err := session.GetInt(2, false, true) + if err != nil { + return nil, err + } + numArray, err := session.GetBytes(len1) + if err != nil { + return nil, err + } + num3 := int(6 + (numArray[5]) + (numArray[6])) + result.ServernCharset = int(binary.BigEndian.Uint16(numArray[(num3 + 3):(num3 + 5)])) + len2, err := session.GetByte() + if err != nil { + return nil, err + } + result.ServerCompileTimeCaps, err = session.GetBytes(int(len2)) + if err != nil { + return nil, err + } + len3, err := session.GetByte() + if err != nil { + return nil, err + } + result.ServerRuntimeCaps, err = session.GetBytes(int(len3)) + if err != nil { + return nil, err + } + if result.ServerCompileTimeCaps[15]&1 != 0 { + session.HasEOSCapability = true + } + if result.ServerCompileTimeCaps[16]&1 != 0 { + session.HasFSAPCapability = true + } + return &result, nil +} diff --git a/transaction.go b/transaction.go new file mode 100644 index 00000000..b2ece040 --- /dev/null +++ b/transaction.go @@ -0,0 +1,17 @@ +package go_ora + +type Transaction struct { + conn *Connection +} + +func (tx *Transaction) Commit() error { + tx.conn.autoCommit = true + tx.conn.session.ResetBuffer() + return (&simpleObject{session: tx.conn.session, operationID:0xE}).write().read() +} + +func (tx *Transaction) Rollback() error { + tx.conn.autoCommit = true + tx.conn.session.ResetBuffer() + return (&simpleObject{session: tx.conn.session, operationID:0xF}).write().read() +} \ No newline at end of file