//------------------------------------------------------------------------------
// Desc:	This file contains the Unicode conversion routines
//
// Tabs:	3
//
//		Copyright (c) 1999-2006 Novell, Inc. All Rights Reserved.
//
//		This program is free software; you can redistribute it and/or
//		modify it under the terms of version 2 of the GNU General Public
//		License as published by the Free Software Foundation.
//
//		This program is distributed in the hope that it will be useful,
//		but WITHOUT ANY WARRANTY; without even the implied warranty of
//		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//		GNU General Public License for more details.
//
//		You should have received a copy of the GNU General Public License
//		along with this program; if not, contact Novell, Inc.
//
//		To contact Novell about this file by physical or electronic mail,
//		you may find current contact information at www.novell.com
//
// $Id: funicode.cpp 3115 2006-01-19 13:24:39 -0700 (Thu, 19 Jan 2006) dsanders $
//------------------------------------------------------------------------------

#define DEF_FLM_UNI_GLOBALS
#include "flaimsys.h"

// Local constants

#define UTOWP60_ENTRIES			1502

// Mapping table

/****************************************************************************
Desc:		UNICODE to WP6 character mapping table
Notes:	This table is used to convert a subset of Unicode characters to
			their WordPerfect equivalents so that the WP collation routines
			can be used for indexing.  This contains characters that can be
			mapped 1:1 from Unicode->WP and from WP->Unicode.  There is
			no ambiguity and there are no character expansions or
			contractions.
****************************************************************************/
FLMUINT16 WP_UTOWP60[ UTOWP60_ENTRIES][2] =
{
	{ 0x00A1, 0x0407 },		//   7 ,  4
	{ 0x00A2, 0x0413 },		//  19 ,  4
	{ 0x00A3, 0x040b },		//  11 ,  4
	{ 0x00A4, 0x0418 },		//  24 ,  4
	{ 0x00A5, 0x040c },		//  12 ,  4
	{ 0x00A7, 0x0406 },		//   6 ,  4
	{ 0x00A9, 0x0417 },		//  23 ,  4
	{ 0x00AA, 0x040f },		//  15 ,  4
	{ 0x00AB, 0x0409 },		//   9 ,  4
	{ 0x00AC, 0x0614 },		//  20 ,  6
	{ 0x00AE, 0x0416 },		//  22 ,  4
	{ 0x00B0, 0x0624 },		//  36 ,  6
	{ 0x00B1, 0x0601 },		//   1 ,  6
	{ 0x00B2, 0x0414 },		//  20 ,  4
	{ 0x00B3, 0x041a },		//  26 ,  4
	{ 0x00B5, 0x0625 },		//  37 ,  6
	{ 0x00B6, 0x0405 },		//   5 ,  4
	{ 0x00B7, 0x0101 },		//  101,  1
	{ 0x00B9, 0x044e },		//  78 ,  4
	{ 0x00BA, 0x0410 },		//  16 ,  4
	{ 0x00BB, 0x040a },		//  10 ,  4
	{ 0x00BC, 0x0412 },		//  18 ,  4
	{ 0x00BD, 0x0411 },		//  17 ,  4
	{ 0x00BE, 0x0419 },		//  25 ,  4
	{ 0x00BF, 0x0408 },		//   8 ,  4
	{ 0x00C0, 0x0120 },		//  32 ,  1
	{ 0x00C1, 0x011a },		//  26 ,  1
	{ 0x00C2, 0x011c },		//  28 ,  1
	{ 0x00C3, 0x014c },		//  76 ,  1
	{ 0x00C4, 0x011e },		//  30 ,  1
	{ 0x00C5, 0x0122 },		//  34 ,  1
	{ 0x00C6, 0x0124 },		//  36 ,  1
	{ 0x00C7, 0x0126 },		//  38 ,  1
	{ 0x00C8, 0x012e },		//  46 ,  1
	{ 0x00C9, 0x0128 },		//  40 ,  1
	{ 0x00CA, 0x012a },		//  42 ,  1
	{ 0x00CB, 0x012c },		//  44 ,  1
	{ 0x00CC, 0x0136 },		//  54 ,  1
	{ 0x00CD, 0x0130 },		//  48 ,  1
	{ 0x00CE, 0x0132 },		//  50 ,  1
	{ 0x00CF, 0x0134 },		//  52 ,  1
	{ 0x00D0, 0x0156 },		//  86 ,  1
	{ 0x00D1, 0x0138 },		//  56 ,  1
	{ 0x00D2, 0x0140 },		//  64 ,  1
	{ 0x00D3, 0x013a },		//  58 ,  1
	{ 0x00D4, 0x013c },		//  60 ,  1
	{ 0x00D5, 0x0152 },		//  82 ,  1
	{ 0x00D6, 0x013e },		//  62 ,  1
	{ 0x00D7, 0x0627 },		//  39 ,  6
	{ 0x00D8, 0x0150 },		//  80 ,  1
	{ 0x00D9, 0x0148 },		//  72 ,  1
	{ 0x00DA, 0x0142 },		//  66 ,  1
	{ 0x00DB, 0x0144 },		//  68 ,  1
	{ 0x00DC, 0x0146 },		//  70 ,  1
	{ 0x00DD, 0x0154 },		//  84 ,  1
	{ 0x00DE, 0x0158 },		//  88 ,  1
	{ 0x00DF, 0x0117 },		//  23 ,  1
	{ 0x00E0, 0x0121 },		//  33 ,  1
	{ 0x00E1, 0x011b },		//  27 ,  1
	{ 0x00E2, 0x011d },		//  29 ,  1
	{ 0x00E3, 0x014d },		//  77 ,  1
	{ 0x00E4, 0x011f },		//  31 ,  1
	{ 0x00E5, 0x0123 },		//  35 ,  1
	{ 0x00E6, 0x0125 },		//  37 ,  1
	{ 0x00E7, 0x0127 },		//  39 ,  1
	{ 0x00E8, 0x012f },		//  47 ,  1
	{ 0x00E9, 0x0129 },		//  41 ,  1
	{ 0x00EA, 0x012b },		//  43 ,  1
	{ 0x00EB, 0x012d },		//  45 ,  1
	{ 0x00EC, 0x0137 },		//  55 ,  1
	{ 0x00ED, 0x0131 },		//  49 ,  1
	{ 0x00EE, 0x0133 },		//  51 ,  1
	{ 0x00EF, 0x0135 },		//  53 ,  1
	{ 0x00F0, 0x0157 },		//  87 ,  1
	{ 0x00F1, 0x0139 },		//  57 ,  1
	{ 0x00F2, 0x0141 },		//  65 ,  1
	{ 0x00F3, 0x013b },		//  59 ,  1
	{ 0x00F4, 0x013d },		//  61 ,  1
	{ 0x00F5, 0x0153 },		//  83 ,  1
	{ 0x00F6, 0x013f },		//  63 ,  1
	{ 0x00F7, 0x0608 },		//   8 ,  6
	{ 0x00F8, 0x0151 },		//  81 ,  1
	{ 0x00F9, 0x0149 },		//  73 ,  1
	{ 0x00FA, 0x0143 },		//  67 ,  1
	{ 0x00FB, 0x0145 },		//  69 ,  1
	{ 0x00FC, 0x0147 },		//  71 ,  1
	{ 0x00FD, 0x0155 },		//  85 ,  1
	{ 0x00FE, 0x0159 },		//  89 ,  1
	{ 0x00FF, 0x014b },		//  75 ,  1
	{ 0x0100, 0x015c },		//  92 ,  1
	{ 0x0101, 0x015d },		//  93 ,  1
	{ 0x0102, 0x015a },		//  90 ,  1
	{ 0x0103, 0x015b },		//  91 ,  1
	{ 0x0104, 0x015e },		//  94 ,  1
	{ 0x0105, 0x015f },		//  95 ,  1
	{ 0x0106, 0x0160 },		//  96 ,  1
	{ 0x0107, 0x0161 },		//  97 ,  1
	{ 0x0108, 0x0164 },		//  100,  1
	{ 0x0109, 0x0165 },		//  101,  1
	{ 0x010A, 0x0166 },		//  102,  1
	{ 0x010B, 0x0167 },		//  103,  1
	{ 0x010C, 0x0162 },		//  98 ,  1
	{ 0x010D, 0x0163 },		//  99 ,  1
	{ 0x010E, 0x0168 },		//  104,  1
	{ 0x010F, 0x0169 },		//  105,  1
	{ 0x0110, 0x014e },		//  78 ,  1
	{ 0x0111, 0x014f },		//  79 ,  1
	{ 0x0112, 0x016e },		//  110,  1
	{ 0x0113, 0x016f },		//  111,  1
	{ 0x0114, 0x01ea },		//  234,  1
	{ 0x0115, 0x01eb },		//  235,  1
	{ 0x0116, 0x016c },		//  108,  1
	{ 0x0117, 0x016d },		//  109,  1
	{ 0x0118, 0x0170 },		//  112,  1
	{ 0x0119, 0x0171 },		//  113,  1
	{ 0x011A, 0x016a },		//  106,  1
	{ 0x011B, 0x016b },		//  107,  1
	{ 0x011C, 0x017a },		//  122,  1
	{ 0x011D, 0x017b },		//  123,  1
	{ 0x011E, 0x0174 },		//  116,  1
	{ 0x011F, 0x0175 },		//  117,  1
	{ 0x0120, 0x017c },		//  124,  1
	{ 0x0121, 0x017d },		//  125,  1
	{ 0x0122, 0x0178 },		//  120,  1
	{ 0x0123, 0x0179 },		//  121,  1
	{ 0x0124, 0x017e },		//  126,  1
	{ 0x0125, 0x017f },		//  127,  1
	{ 0x0126, 0x0180 },		//  128,  1
	{ 0x0127, 0x0181 },		//  129,  1
	{ 0x0128, 0x0188 },		//  136,  1
	{ 0x0129, 0x0189 },		//  137,  1
	{ 0x012A, 0x0184 },		//  132,  1
	{ 0x012B, 0x0185 },		//  133,  1
	{ 0x012C, 0x01ec },		//  236,  1
	{ 0x012D, 0x01ed },		//  237,  1
	{ 0x012E, 0x0186 },		//  134,  1
	{ 0x012F, 0x0187 },		//  135,  1
	{ 0x0130, 0x0182 },		//  130,  1
	{ 0x0131, 0x01ef },		//  239,  1
	{ 0x0132, 0x018a },		//  138,  1
	{ 0x0133, 0x018b },		//  139,  1
	{ 0x0134, 0x018c },		//  140,  1
	{ 0x0135, 0x018d },		//  141,  1
	{ 0x0136, 0x018e },		//  142,  1
	{ 0x0137, 0x018f },		//  143,  1
	{ 0x0138, 0x0118 },		//  24 ,  1
	{ 0x0139, 0x0190 },		//  144,  1
	{ 0x013A, 0x0191 },		//  145,  1
	{ 0x013B, 0x0194 },		//  148,  1
	{ 0x013C, 0x0195 },		//  149,  1
	{ 0x013D, 0x0192 },		//  146,  1
	{ 0x013E, 0x0193 },		//  147,  1
	{ 0x013F, 0x0196 },		//  150,  1
	{ 0x0140, 0x0197 },		//  151,  1
	{ 0x0141, 0x0198 },		//  152,  1
	{ 0x0142, 0x0199 },		//  153,  1
	{ 0x0143, 0x019a },		//  154,  1
	{ 0x0144, 0x019b },		//  155,  1
	{ 0x0145, 0x01a0 },		//  160,  1
	{ 0x0146, 0x01a1 },		//  161,  1
	{ 0x0147, 0x019e },		//  158,  1
	{ 0x0148, 0x019f },		//  159,  1
	{ 0x0149, 0x019d },		//  157,  1
	{ 0x014A, 0x01d2 },		//  210,  1
	{ 0x014B, 0x01d3 },		//  211,  1
	{ 0x014C, 0x01a4 },		//  164,  1
	{ 0x014D, 0x01a5 },		//  165,  1
	{ 0x014E, 0x01f0 },		//  240,  1
	{ 0x014F, 0x01f1 },		//  241,  1
	{ 0x0150, 0x01a2 },		//  162,  1
	{ 0x0151, 0x01a3 },		//  163,  1
	{ 0x0152, 0x01a6 },		//  166,  1
	{ 0x0153, 0x01a7 },		//  167,  1
	{ 0x0154, 0x01a8 },		//  168,  1
	{ 0x0155, 0x01a9 },		//  169,  1
	{ 0x0156, 0x01ac },		//  172,  1
	{ 0x0157, 0x01ad },		//  173,  1
	{ 0x0158, 0x01aa },		//  170,  1
	{ 0x0159, 0x01ab },		//  171,  1
	{ 0x015A, 0x01ae },		//  174,  1
	{ 0x015B, 0x01af },		//  175,  1
	{ 0x015C, 0x01b4 },		//  180,  1
	{ 0x015D, 0x01b5 },		//  181,  1
	{ 0x015E, 0x01b2 },		//  178,  1
	{ 0x015F, 0x01b3 },		//  179,  1
	{ 0x0160, 0x01b0 },		//  176,  1
	{ 0x0161, 0x01b1 },		//  177,  1
	{ 0x0162, 0x01b8 },		//  184,  1
	{ 0x0163, 0x01b9 },		//  185,  1
	{ 0x0164, 0x01b6 },		//  182,  1
	{ 0x0165, 0x01b7 },		//  183,  1
	{ 0x0166, 0x01ba },		//  186,  1
	{ 0x0167, 0x01bb },		//  187,  1
	{ 0x0168, 0x01c6 },		//  198,  1
	{ 0x0169, 0x01c7 },		//  199,  1
	{ 0x016A, 0x01c0 },		//  192,  1
	{ 0x016B, 0x01c1 },		//  193,  1
	{ 0x016C, 0x01bc },		//  188,  1
	{ 0x016D, 0x01bd },		//  189,  1
	{ 0x016E, 0x01c4 },		//  196,  1
	{ 0x016F, 0x01c5 },		//  197,  1
	{ 0x0170, 0x01be },		//  190,  1
	{ 0x0171, 0x01bf },		//  191,  1
	{ 0x0172, 0x01c2 },		//  194,  1
	{ 0x0173, 0x01c3 },		//  195,  1
	{ 0x0174, 0x01c8 },		//  200,  1
	{ 0x0175, 0x01c9 },		//  201,  1
	{ 0x0176, 0x01ca },		//  202,  1
	{ 0x0177, 0x01cb },		//  203,  1
	{ 0x0178, 0x014a },		//  74 ,  1
	{ 0x0179, 0x01cc },		//  204,  1
	{ 0x017A, 0x01cd },		//  205,  1
	{ 0x017B, 0x01d0 },		//  208,  1
	{ 0x017C, 0x01d1 },		//  209,  1
	{ 0x017D, 0x01ce },		//  206,  1
	{ 0x017E, 0x01cf },		//  207,  1
	{ 0x0192, 0x040e },		//  14 ,  4
	{ 0x0194, 0x0a7c },		//  124, 10
	{ 0x01A0, 0x01e6 },		//  230,  1
	{ 0x01A1, 0x01e7 },		//  231,  1
	{ 0x01AF, 0x01e8 },		//  232,  1
	{ 0x01B0, 0x01e9 },		//  233,  1
	{ 0x01C0, 0x0605 },		//   5 ,  6
	{ 0x0250, 0x0237 },		//  55 ,  2
	{ 0x0251, 0x0238 },		//  56 ,  2
	{ 0x0252, 0x0239 },		//  57 ,  2
	{ 0x0253, 0x023a },		//  58 ,  2
	{ 0x0254, 0x023c },		//  60 ,  2
	{ 0x0255, 0x023d },		//  61 ,  2
	{ 0x0256, 0x023f },		//  63 ,  2
	{ 0x0257, 0x0240 },		//  64 ,  2
	{ 0x0258, 0x0241 },		//  65 ,  2
	{ 0x0259, 0x0242 },		//  66 ,  2
	{ 0x025A, 0x0243 },		//  67 ,  2
	{ 0x025B, 0x0244 },		//  68 ,  2
	{ 0x025C, 0x0245 },		//  69 ,  2
	{ 0x025D, 0x0246 },		//  70 ,  2
	{ 0x025E, 0x0248 },		//  72 ,  2
	{ 0x025F, 0x0249 },		//  73 ,  2
	{ 0x0260, 0x024c },		//  76 ,  2
	{ 0x0261, 0x024b },		//  75 ,  2
	{ 0x0262, 0x024d },		//  77 ,  2
	{ 0x0263, 0x024f },		//  79 ,  2
	{ 0x0264, 0x0250 },		//  80 ,  2
	{ 0x0265, 0x0251 },		//  81 ,  2
	{ 0x0266, 0x0252 },		//  82 ,  2
	{ 0x0267, 0x0253 },		//  83 ,  2
	{ 0x0268, 0x0255 },		//  85 ,  2
	{ 0x0269, 0x0257 },		//  87 ,  2
	{ 0x026A, 0x0256 },		//  86 ,  2
	{ 0x026B, 0x025a },		//  90 ,  2
	{ 0x026C, 0x025b },		//  91 ,  2
	{ 0x026D, 0x025c },		//  92 ,  2
	{ 0x026E, 0x025e },		//  94 ,  2
	{ 0x026F, 0x0260 },		//  96 ,  2
	{ 0x0270, 0x0261 },		//  97 ,  2
	{ 0x0271, 0x0262 },		//  98 ,  2
	{ 0x0272, 0x0263 },		//  99 ,  2
	{ 0x0273, 0x0264 },		//  100,  2
	{ 0x0274, 0x0265 },		//  101,  2
	{ 0x0275, 0x0279 },		//  121,  2
	{ 0x0276, 0x0266 },		//  102,  2
	{ 0x0277, 0x0267 },		//  103,  2
	{ 0x0278, 0x024a },		//  74 ,  2
	{ 0x0279, 0x0269 },		//  105,  2
	{ 0x027A, 0x026a },		//  106,  2
	{ 0x027B, 0x026b },		//  107,  2
	{ 0x027C, 0x026c },		//  108,  2
	{ 0x027D, 0x026d },		//  109,  2
	{ 0x027E, 0x026e },		//  110,  2
	{ 0x027F, 0x026f },		//  111,  2
	{ 0x0280, 0x0270 },		//  112,  2
	{ 0x0281, 0x0271 },		//  113,  2
	{ 0x0282, 0x0272 },		//  114,  2
	{ 0x0283, 0x0273 },		//  115,  2
	{ 0x0284, 0x0274 },		//  116,  2
	{ 0x0285, 0x0275 },		//  117,  2
	{ 0x0286, 0x0276 },		//  118,  2
	{ 0x0287, 0x0277 },		//  119,  2
	{ 0x0288, 0x0278 },		//  120,  2
	{ 0x0289, 0x027a },		//  122,  2
	{ 0x028A, 0x027b },		//  123,  2
	{ 0x028B, 0x027d },		//  125,  2
	{ 0x028C, 0x027c },		//  124,  2
	{ 0x028D, 0x027e },		//  126,  2
	{ 0x028E, 0x025f },		//  95 ,  2
	{ 0x028F, 0x0280 },		//  128,  2
	{ 0x0290, 0x0281 },		//  129,  2
	{ 0x0291, 0x0282 },		//  130,  2
	{ 0x0292, 0x0283 },		//  131,  2
	{ 0x0293, 0x0284 },		//  132,  2
	{ 0x0294, 0x0285 },		//  133,  2
	{ 0x0295, 0x0286 },		//  134,  2
	{ 0x0296, 0x0287 },		//  135,  2
	{ 0x0297, 0x023e },		//  62 ,  2
	{ 0x0298, 0x028a },		//  138,  2
	{ 0x0299, 0x023b },		//  59 ,  2
	{ 0x029A, 0x0247 },		//  71 ,  2
	{ 0x029B, 0x024e },		//  78 ,  2
	{ 0x029C, 0x0254 },		//  84 ,  2
	{ 0x029D, 0x0258 },		//  88 ,  2
	{ 0x029E, 0x0259 },		//  89 ,  2
	{ 0x029F, 0x025d },		//  93 ,  2
	{ 0x02A0, 0x0268 },		//  104,  2
	{ 0x02A1, 0x0288 },		//  136,  2
	{ 0x02A2, 0x0289 },		//  137,  2
	{ 0x02A3, 0x028b },		//  139,  2
	{ 0x02A4, 0x028c },		//  140,  2
	{ 0x02A5, 0x028d },		//  141,  2
	{ 0x02A6, 0x028e },		//  142,  2
	{ 0x02A7, 0x028f },		//  143,  2
	{ 0x02A8, 0x0290 },		//  144,  2
	{ 0x02B0, 0x0235 },		//  53 ,  2
	{ 0x02B6, 0x0236 },		//  54 ,  2
	{ 0x02B9, 0x0200 },		//   0 ,  2
	{ 0x02BA, 0x0201 },		//   1 ,  2
	{ 0x02BB, 0x0202 },		//   2 ,  2
	{ 0x02BC, 0x0205 },		//   5 ,  2
	{ 0x02BD, 0x0204 },		//   4 ,  2
	{ 0x02BE, 0x0207 },		//   7 ,  2
	{ 0x02BF, 0x0208 },		//   8 ,  2
	{ 0x02C6, 0x0217 },		//  23 ,  2
	{ 0x02C7, 0x0218 },		//  24 ,  2
	{ 0x02C8, 0x020f },		//  15 ,  2
	{ 0x02C9, 0x0211 },		//  17 ,  2
	{ 0x02CA, 0x0212 },		//  18 ,  2
	{ 0x02CB, 0x0213 },		//  19 ,  2
	{ 0x02CC, 0x0210 },		//  16 ,  2
	{ 0x02CD, 0x0214 },		//  20 ,  2
	{ 0x02CE, 0x0215 },		//  21 ,  2
	{ 0x02CF, 0x0216 },		//  22 ,  2
	{ 0x02D0, 0x020a },		//  10 ,  2
	{ 0x02D1, 0x020b },		//  11 ,  2
	{ 0x02D2, 0x022a },		//  42 ,  2
	{ 0x02D3, 0x022b },		//  43 ,  2
	{ 0x02DA, 0x021b },		//  27 ,  2
	{ 0x02DB, 0x0231 },		//  49 ,  2
	{ 0x02DC, 0x0219 },		//  25 ,  2
	{ 0x02DE, 0x0233 },		//  51 ,  2
	{ 0x0300, 0x0100 },		//   0 ,  1
	{ 0x0301, 0x0106 },		//   6 ,  1
	{ 0x0302, 0x0103 },		//   3 ,  1
	{ 0x0303, 0x0102 },		//   2 ,  1
	{ 0x0304, 0x0108 },		//   8 ,  1
	{ 0x0305, 0x0115 },		//  21 ,  1
	{ 0x0306, 0x0116 },		//  22 ,  1
	{ 0x0307, 0x010f },		//  15 ,  1
	{ 0x0308, 0x0107 },		//   7 ,  1
	{ 0x030A, 0x010e },		//  14 ,  1
	{ 0x030B, 0x0110 },		//  16 ,  1
	{ 0x030C, 0x0113 },		//  19 ,  1
	{ 0x0310, 0x0209 },		//   9 ,  2
	{ 0x0311, 0x0858 },		//  88 ,  8
	{ 0x0313, 0x0109 },		//   9 ,  1
	{ 0x0314, 0x085a },		//  90 ,  8
	{ 0x0315, 0x010a },		//  10 ,  1
	{ 0x031C, 0x0221 },		//  33 ,  2
	{ 0x031D, 0x0222 },		//  34 ,  2
	{ 0x031E, 0x0223 },		//  35 ,  2
	{ 0x031F, 0x0224 },		//  36 ,  2
	{ 0x0320, 0x0225 },		//  37 ,  2
	{ 0x0321, 0x0226 },		//  38 ,  2
	{ 0x0322, 0x0227 },		//  39 ,  2
	{ 0x0323, 0x021e },		//  30 ,  2
	{ 0x0324, 0x0220 },		//  32 ,  2
	{ 0x0325, 0x021a },		//  26 ,  2
	{ 0x0326, 0x010c },		//  12 ,  1
	{ 0x0327, 0x0111 },		//  17 ,  1
	{ 0x0328, 0x0112 },		//  18 ,  1
	{ 0x0329, 0x020e },		//  14 ,  2
	{ 0x032A, 0x0228 },		//  40 ,  2
	{ 0x032B, 0x0229 },		//  41 ,  2
	{ 0x032C, 0x021d },		//  29 ,  2
	{ 0x032D, 0x021c },		//  28 ,  2
	{ 0x032E, 0x020d },		//  13 ,  2
	{ 0x0335, 0x0104 },		//   4 ,  1
	{ 0x0337, 0x0114 },		//  20 ,  1
	{ 0x0338, 0x0105 },		//   5 ,  1
	{ 0x033E, 0x0230 },		//  48 ,  2
	{ 0x0345, 0x085b },		//  91 ,  8
	{ 0x0374, 0x0851 },		//  81 ,  8
	{ 0x0375, 0x0852 },		//  82 ,  8
	{ 0x0391, 0x0800 },		//   0 ,  8
	{ 0x0392, 0x0802 },		//   2 ,  8
	{ 0x0393, 0x0806 },		//   6 ,  8
	{ 0x0394, 0x0808 },		//   8 ,  8
	{ 0x0395, 0x080a },		//  10 ,  8
	{ 0x0396, 0x080c },		//  12 ,  8
	{ 0x0397, 0x080e },		//  14 ,  8
	{ 0x0398, 0x0810 },		//  16 ,  8
	{ 0x0399, 0x0812 },		//  18 ,  8
	{ 0x039A, 0x0814 },		//  20 ,  8
	{ 0x039B, 0x0816 },		//  22 ,  8
	{ 0x039C, 0x0818 },		//  24 ,  8
	{ 0x039D, 0x081a },		//  26 ,  8
	{ 0x039E, 0x081c },		//  28 ,  8
	{ 0x039F, 0x081e },		//  30 ,  8
	{ 0x03A0, 0x0820 },		//  32 ,  8
	{ 0x03A1, 0x0822 },		//  34 ,  8
	{ 0x03A3, 0x0824 },		//  36 ,  8
	{ 0x03A4, 0x0828 },		//  40 ,  8
	{ 0x03A5, 0x082a },		//  42 ,  8
	{ 0x03A6, 0x082c },		//  44 ,  8
	{ 0x03A7, 0x082e },		//  46 ,  8
	{ 0x03A8, 0x0830 },		//  48 ,  8
	{ 0x03A9, 0x0832 },		//  50 ,  8
	{ 0x03AA, 0x083c },		//  60 ,  8
	{ 0x03AB, 0x0842 },		//  66 ,  8
	{ 0x03AC, 0x0835 },		//  53 ,  8
	{ 0x03AD, 0x0837 },		//  55 ,  8
	{ 0x03AE, 0x0839 },		//  57 ,  8
	{ 0x03AF, 0x083b },		//  59 ,  8
	{ 0x03B1, 0x0801 },		//   1 ,  8
	{ 0x03B2, 0x0803 },		//   3 ,  8
	{ 0x03B3, 0x0807 },		//   7 ,  8
	{ 0x03B4, 0x0809 },		//   9 ,  8
	{ 0x03B5, 0x080b },		//  11 ,  8
	{ 0x03B6, 0x080d },		//  13 ,  8
	{ 0x03B7, 0x080f },		//  15 ,  8
	{ 0x03B8, 0x0811 },		//  17 ,  8
	{ 0x03B9, 0x0813 },		//  19 ,  8
	{ 0x03BA, 0x0815 },		//  21 ,  8
	{ 0x03BB, 0x0817 },		//  23 ,  8
	{ 0x03BC, 0x0819 },		//  25 ,  8
	{ 0x03BD, 0x081b },		//  27 ,  8
	{ 0x03BE, 0x081d },		//  29 ,  8
	{ 0x03BF, 0x081f },		//  31 ,  8
	{ 0x03C0, 0x0821 },		//  33 ,  8
	{ 0x03C1, 0x0823 },		//  35 ,  8
	{ 0x03C2, 0x0827 },		//  39 ,  8
	{ 0x03C3, 0x0825 },		//  37 ,  8
	{ 0x03C4, 0x0829 },		//  41 ,  8
	{ 0x03C5, 0x082b },		//  43 ,  8
	{ 0x03C6, 0x082d },		//  45 ,  8
	{ 0x03C7, 0x082f },		//  47 ,  8
	{ 0x03C8, 0x0831 },		//  49 ,  8
	{ 0x03C9, 0x0833 },		//  51 ,  8
	{ 0x03CA, 0x083d },		//  61 ,  8
	{ 0x03CB, 0x0843 },		//  67 ,  8
	{ 0x03CC, 0x083f },		//  63 ,  8
	{ 0x03CD, 0x0841 },		//  65 ,  8
	{ 0x03CE, 0x0845 },		//  69 ,  8
	{ 0x03D0, 0x0805 },		//   5 ,  8
	{ 0x03D1, 0x0847 },		//  71 ,  8
	{ 0x03D2, 0x084c },		//  76 ,  8
	{ 0x03D5, 0x084d },		//  77 ,  8
	{ 0x03D6, 0x0849 },		//  73 ,  8
	{ 0x03D7, 0x084f },		//  79 ,  8
	{ 0x03DA, 0x08d7 },		//  215,  8
	{ 0x03DB, 0x084B },		//  75 ,  8
	{ 0x03DC, 0x08d8 },		//  216,  8
	{ 0x03DE, 0x08d9 },		//  217,  8
	{ 0x03E0, 0x08da },		//  218,  8
	{ 0x03F0, 0x0848 },		//  72 ,  8
	{ 0x03F1, 0x084a },		//  74 ,  8
	{ 0x0401, 0x0a0c },		//  12 , 10
	{ 0x0402, 0x0a4a },		//  74 , 10
	{ 0x0403, 0x0a44 },		//  68 , 10
	{ 0x0404, 0x0a4e },		//  78 , 10
	{ 0x0405, 0x0a52 },		//  82 , 10
	{ 0x0406, 0x0a58 },		//  88 , 10
	{ 0x0407, 0x0a5a },		//  90 , 10
	{ 0x0408, 0x0a5e },		//  94 , 10
	{ 0x0409, 0x0a68 },		//  104, 10
	{ 0x040A, 0x0a6c },		//  108, 10
	{ 0x040B, 0x0a72 },		//  114, 10
	{ 0x040C, 0x0a60 },		//  96 , 10
	{ 0x040E, 0x0a74 },		//  116, 10
	{ 0x040F, 0x0a86 },		//  134, 10
	{ 0x0410, 0x0a00 },		//   0 , 10
	{ 0x0411, 0x0a02 },		//   2 , 10
	{ 0x0412, 0x0a04 },		//   4 , 10
	{ 0x0413, 0x0a06 },		//   6 , 10
	{ 0x0414, 0x0a08 },		//   8 , 10
	{ 0x0415, 0x0a0a },		//  10 , 10
	{ 0x0416, 0x0a0e },		//  14 , 10
	{ 0x0417, 0x0a10 },		//  16 , 10
	{ 0x0418, 0x0a12 },		//  18 , 10
	{ 0x0419, 0x0a14 },		//  20 , 10
	{ 0x041A, 0x0a16 },		//  22 , 10
	{ 0x041B, 0x0a18 },		//  24 , 10
	{ 0x041C, 0x0a1a },		//  26 , 10
	{ 0x041D, 0x0a1c },		//  28 , 10
	{ 0x041E, 0x0a1e },		//  30 , 10
	{ 0x041F, 0x0a20 },		//  32 , 10
	{ 0x0420, 0x0a22 },		//  34 , 10
	{ 0x0421, 0x0a24 },		//  36 , 10
	{ 0x0422, 0x0a26 },		//  38 , 10
	{ 0x0423, 0x0a28 },		//  40 , 10
	{ 0x0424, 0x0a2a },		//  42 , 10
	{ 0x0425, 0x0a2c },		//  44 , 10
	{ 0x0426, 0x0a2e },		//  46 , 10
	{ 0x0427, 0x0a30 },		//  48 , 10
	{ 0x0428, 0x0a32 },		//  50 , 10
	{ 0x0429, 0x0a34 },		//  52 , 10
	{ 0x042A, 0x0a36 },		//  54 , 10
	{ 0x042B, 0x0a38 },		//  56 , 10
	{ 0x042C, 0x0a3a },		//  58 , 10
	{ 0x042D, 0x0a3c },		//  60 , 10
	{ 0x042E, 0x0a3e },		//  62 , 10
	{ 0x042F, 0x0a40 },		//  64 , 10
	{ 0x0430, 0x0a01 },		//   1 , 10
	{ 0x0431, 0x0a03 },		//   3 , 10
	{ 0x0432, 0x0a05 },		//   5 , 10
	{ 0x0433, 0x0a07 },		//   7 , 10
	{ 0x0434, 0x0a09 },		//   9 , 10
	{ 0x0435, 0x0a0b },		//  11 , 10
	{ 0x0436, 0x0a0f },		//  15 , 10
	{ 0x0437, 0x0a11 },		//  17 , 10
	{ 0x0438, 0x0a13 },		//  19 , 10
	{ 0x0439, 0x0a15 },		//  21 , 10
	{ 0x043A, 0x0a17 },		//  23 , 10
	{ 0x043B, 0x0a19 },		//  25 , 10
	{ 0x043C, 0x0a1b },		//  27 , 10
	{ 0x043D, 0x0a1d },		//  29 , 10
	{ 0x043E, 0x0a1f },		//  31 , 10
	{ 0x043F, 0x0a21 },		//  33 , 10
	{ 0x0440, 0x0a23 },		//  35 , 10
	{ 0x0441, 0x0a25 },		//  37 , 10
	{ 0x0442, 0x0a27 },		//  39 , 10
	{ 0x0443, 0x0a29 },		//  41 , 10
	{ 0x0444, 0x0a2b },		//  43 , 10
	{ 0x0445, 0x0a2d },		//  45 , 10
	{ 0x0446, 0x0a2f },		//  47 , 10
	{ 0x0447, 0x0a31 },		//  49 , 10
	{ 0x0448, 0x0a33 },		//  51 , 10
	{ 0x0449, 0x0a35 },		//  53 , 10
	{ 0x044A, 0x0a37 },		//  55 , 10
	{ 0x044B, 0x0a39 },		//  57 , 10
	{ 0x044C, 0x0a3b },		//  59 , 10
	{ 0x044D, 0x0a3d },		//  61 , 10
	{ 0x044E, 0x0a3f },		//  63 , 10
	{ 0x044F, 0x0a41 },		//  65 , 10
	{ 0x0451, 0x0a0d },		//  13 , 10
	{ 0x0452, 0x0a4b },		//  75 , 10
	{ 0x0453, 0x0a45 },		//  69 , 10
	{ 0x0454, 0x0a4f },		//  79 , 10
	{ 0x0455, 0x0a53 },		//  83 , 10
	{ 0x0456, 0x0a59 },		//  89 , 10
	{ 0x0457, 0x0a5b },		//  91 , 10
	{ 0x0458, 0x0a5f },		//  95 , 10
	{ 0x0459, 0x0a69 },		//  105, 10
	{ 0x045A, 0x0a6d },		//  109, 10
	{ 0x045B, 0x0a73 },		//  115, 10
	{ 0x045C, 0x0a61 },		//  97 , 10
	{ 0x045E, 0x0a75 },		//  117, 10
	{ 0x045F, 0x0a87 },		//  135, 10
	{ 0x0460, 0x0a70 },		//  112, 10
	{ 0x0461, 0x0a71 },		//  113, 10
	{ 0x0462, 0x0a8e },		//  142, 10
	{ 0x0463, 0x0a8f },		//  143, 10
	{ 0x0466, 0x0a90 },		//  144, 10
	{ 0x0467, 0x0a91 },		//  145, 10
	{ 0x046A, 0x0a92 },		//  146, 10
	{ 0x046B, 0x0a93 },		//  147, 10
	{ 0x046E, 0x0a94 },		//  148, 10
	{ 0x046F, 0x0a95 },		//  149, 10
	{ 0x0470, 0x0a96 },		//  150, 10
	{ 0x0471, 0x0a97 },		//  151, 10
	{ 0x0472, 0x0a98 },		//  152, 10
	{ 0x0473, 0x0a99 },		//  153, 10
	{ 0x0474, 0x0a9a },		//  154, 10
	{ 0x0475, 0x0a9b },		//  155, 10
	{ 0x047A, 0x0a6e },		//  110, 10
	{ 0x047B, 0x0a6f },		//  111, 10
	{ 0x047E, 0x0a84 },		//  132, 10
	{ 0x047F, 0x0a85 },		//  133, 10
	{ 0x0490, 0x0a46 },		//  70 , 10
	{ 0x0491, 0x0a47 },		//  71 , 10
	{ 0x0492, 0x0a48 },		//  72 , 10
	{ 0x0493, 0x0a49 },		//  73 , 10
	{ 0x0496, 0x0a50 },		//  80 , 10
	{ 0x0497, 0x0a51 },		//  81 , 10
	{ 0x049A, 0x0a62 },		//  98 , 10
	{ 0x049B, 0x0a63 },		//  99 , 10
	{ 0x049C, 0x0a66 },		//  102, 10
	{ 0x049D, 0x0a67 },		//  103, 10
	{ 0x04A2, 0x0a6a },		//  106, 10
	{ 0x04A3, 0x0a6b },		//  107, 10
	{ 0x04AE, 0x0a78 },		//  120, 10
	{ 0x04AF, 0x0a79 },		//  121, 10
	{ 0x04B0, 0x0a7a },		//  122, 10
	{ 0x04B1, 0x0a7b },		//  123, 10
	{ 0x04B2, 0x0a7e },		//  126, 10
	{ 0x04B3, 0x0a7f },		//  127, 10
	{ 0x04B6, 0x0a88 },		//  136, 10
	{ 0x04B7, 0x0a89 },		//  137, 10
	{ 0x04B8, 0x0a8a },		//  138, 10
	{ 0x04B9, 0x0a8b },		//  139, 10
	{ 0x04BA, 0x0a82 },		//  130, 10
	{ 0x04BB, 0x0a83 },		//  131, 10
	{ 0x04D8, 0x0a42 },		//  66 , 10
	{ 0x04D9, 0x0a43 },		//  67 , 10
	{ 0x04EE, 0x0a76 },		//  118, 10
	{ 0x04EF, 0x0a77 },		//  119, 10
	{ 0x05B0, 0x0920 },		//  32 ,  9
	{ 0x05B1, 0x0921 },		//  33 ,  9
	{ 0x05B2, 0x0922 },		//  34 ,  9
	{ 0x05B3, 0x0923 },		//  35 ,  9
	{ 0x05B4, 0x0924 },		//  36 ,  9
	{ 0x05B5, 0x0925 },		//  37 ,  9
	{ 0x05B6, 0x0926 },		//  38 ,  9
	{ 0x05B7, 0x0927 },		//  39 ,  9
	{ 0x05B8, 0x0928 },		//  40 ,  9
	{ 0x05B9, 0x0929 },		//  41 ,  9
	{ 0x05BB, 0x092b },		//  43 ,  9
	{ 0x05BC, 0x092c },		//  44 ,  9
	{ 0x05BD, 0x092d },		//  45 ,  9
	{ 0x05BF, 0x092e },		//  46 ,  9
	{ 0x05C0, 0x091c },		//  28 ,  9
	{ 0x05C3, 0x091d },		//  29 ,  9
	{ 0x05D0, 0x0900 },		//   0 ,  9
	{ 0x05D1, 0x0901 },		//   1 ,  9
	{ 0x05D2, 0x0902 },		//   2 ,  9
	{ 0x05D3, 0x0903 },		//   3 ,  9
	{ 0x05D4, 0x0904 },		//   4 ,  9
	{ 0x05D5, 0x0905 },		//   5 ,  9
	{ 0x05D6, 0x0906 },		//   6 ,  9
	{ 0x05D7, 0x0907 },		//   7 ,  9
	{ 0x05D8, 0x0908 },		//   8 ,  9
	{ 0x05D9, 0x0909 },		//   9 ,  9
	{ 0x05DA, 0x090a },		//  10 ,  9
	{ 0x05DB, 0x090b },		//  11 ,  9
	{ 0x05DC, 0x090c },		//  12 ,  9
	{ 0x05DD, 0x090d },		//  13 ,  9
	{ 0x05DE, 0x090e },		//  14 ,  9
	{ 0x05DF, 0x090f },		//  15 ,  9
	{ 0x05E0, 0x0910 },		//  16 ,  9
	{ 0x05E1, 0x0911 },		//  17 ,  9
	{ 0x05E2, 0x0912 },		//  18 ,  9
	{ 0x05E3, 0x0913 },		//  19 ,  9
	{ 0x05E4, 0x0914 },		//  20 ,  9
	{ 0x05E5, 0x0915 },		//  21 ,  9
	{ 0x05E6, 0x0916 },		//  22 ,  9
	{ 0x05E7, 0x0917 },		//  23 ,  9
	{ 0x05E8, 0x0918 },		//  24 ,  9
	{ 0x05E9, 0x0919 },		//  25 ,  9
	{ 0x05EA, 0x091a },		//  26 ,  9
	{ 0x05F0, 0x0931 },		//  49 ,  9
	{ 0x05F1, 0x0932 },		//  50 ,  9
	{ 0x05F2, 0x0933 },		//  51 ,  9
	{ 0x05F3, 0x091e },		//  30 ,  9
	{ 0x05F4, 0x091f },		//  31 ,  9
	{ 0x060C, 0x0d26 },		//  38 , 13
	{ 0x061B, 0x0d27 },		//  39 , 13
	{ 0x061F, 0x0d28 },		//  40 , 13
	{ 0x0621, 0x0da4 },		//  164, 13
	{ 0x0622, 0x0db1 },		//  177, 13
	{ 0x0623, 0x0da5 },		//  165, 13
	{ 0x0624, 0x0da9 },		//  169, 13
	{ 0x0625, 0x0da7 },		//  167, 13
	{ 0x0626, 0x0dab },		//  171, 13
	{ 0x0627, 0x0d3a },		//  58 , 13
	{ 0x0628, 0x0d3c },		//  60 , 13
	{ 0x0629, 0x0d98 },		//  152, 13
	{ 0x062A, 0x0d40 },		//  64 , 13
	{ 0x062B, 0x0d44 },		//  68 , 13
	{ 0x062C, 0x0d48 },		//  72 , 13
	{ 0x062D, 0x0d4c },		//  76 , 13
	{ 0x062E, 0x0d50 },		//  80 , 13
	{ 0x062F, 0x0d54 },		//  84 , 13
	{ 0x0630, 0x0d56 },		//  86 , 13
	{ 0x0631, 0x0d58 },		//  88 , 13
	{ 0x0632, 0x0d5a },		//  90 , 13
	{ 0x0633, 0x0d5c },		//  92 , 13
	{ 0x0634, 0x0d60 },		//  96 , 13
	{ 0x0635, 0x0d64 },		//  100, 13
	{ 0x0636, 0x0d68 },		//  104, 13
	{ 0x0637, 0x0d6c },		//  108, 13
	{ 0x0638, 0x0d70 },		//  112, 13
	{ 0x0639, 0x0d74 },		//  116, 13
	{ 0x063A, 0x0d78 },		//  120, 13
	{ 0x0640, 0x0dc2 },		//  194, 13
	{ 0x0641, 0x0d7c },		//  124, 13
	{ 0x0642, 0x0d80 },		//  128, 13
	{ 0x0643, 0x0d84 },		//  132, 13
	{ 0x0644, 0x0d88 },		//  136, 13
	{ 0x0645, 0x0d8c },		//  140, 13
	{ 0x0646, 0x0d90 },		//  144, 13
	{ 0x0647, 0x0d94 },		//  148, 13
	{ 0x0648, 0x0d9a },		//  154, 13
	{ 0x0649, 0x0da0 },		//  160, 13
	{ 0x064A, 0x0d9c },		//  156, 13
	{ 0x064B, 0x0d10 },		//  16 , 13
	{ 0x064C, 0x0d11 },		//  17 , 13
	{ 0x064E, 0x0d0a },		//  10 , 13
	{ 0x064F, 0x0d0c },		//  12 , 13
	{ 0x0650, 0x0d0e },		//  14 , 13
	{ 0x0651, 0x0d16 },		//  22 , 13
	{ 0x0652, 0x0d14 },		//  20 , 13
	{ 0x0660, 0x0d38 },		//  56 , 13
	{ 0x0661, 0x0d2f },		//  47 , 13
	{ 0x0662, 0x0d30 },		//  48 , 13
	{ 0x0663, 0x0d31 },		//  49 , 13
	{ 0x0664, 0x0d32 },		//  50 , 13
	{ 0x0665, 0x0d33 },		//  51 , 13
	{ 0x0666, 0x0d34 },		//  52 , 13
	{ 0x0667, 0x0d35 },		//  53 , 13
	{ 0x0668, 0x0d36 },		//  54 , 13
	{ 0x0669, 0x0d37 },		//  55 , 13
	{ 0x066A, 0x0d2a },		//  42 , 13
	{ 0x0671, 0x0db3 },		//  179, 13
	{ 0x0674, 0x0d24 },		//  36 , 13
	{ 0x0679, 0x0e3c },		//  60 , 14
	{ 0x067A, 0x0e4c },		//  76 , 14
	{ 0x067B, 0x0e30 },		//  48 , 14
	{ 0x067C, 0x0e40 },		//  64 , 14
	{ 0x067D, 0x0e48 },		//  72 , 14
	{ 0x067E, 0x0e38 },		//  56 , 14
	{ 0x067F, 0x0e44 },		//  68 , 14
	{ 0x0680, 0x0e34 },		//  52 , 14
	{ 0x0681, 0x0e64 },		//  100, 14
	{ 0x0683, 0x0e54 },		//  84 , 14
	{ 0x0684, 0x0e50 },		//  80 , 14
	{ 0x0685, 0x0e60 },		//  96 , 14
	{ 0x0686, 0x0e58 },		//  88 , 14
	{ 0x0687, 0x0e5c },		//  92 , 14
	{ 0x0688, 0x0e68 },		//  104, 14
	{ 0x0689, 0x0e6a },		//  106, 14
	{ 0x068A, 0x0e70 },		//  112, 14
	{ 0x068C, 0x0e6c },		//  108, 14
	{ 0x068D, 0x0e72 },		//  114, 14
	{ 0x068E, 0x0e6e },		//  110, 14
	{ 0x0691, 0x0e76 },		//  118, 14
	{ 0x0692, 0x0e7C },		//  124, 14
	{ 0x0693, 0x0e74 },		//  116, 14
	{ 0x0695, 0x0e7a },		//  122, 14
	{ 0x0696, 0x0e80 },		//  128, 14
	{ 0x0698, 0x0e7e },		//  126, 14
	{ 0x0699, 0x0e78 },		//  120, 14
	{ 0x069A, 0x0e84 },		//  132, 14
	{ 0x06A0, 0x0e88 },		//  136, 14
	{ 0x06A4, 0x0e8c },		//  140, 14
	{ 0x06A6, 0x0e90 },		//  144, 14
	{ 0x06A9, 0x0e94 },		//  148, 14
	{ 0x06AA, 0x0e9c },		//  156, 14
	{ 0x06AB, 0x0ea8 },		//  168, 14
	{ 0x06AF, 0x0ea0 },		//  160, 14
	{ 0x06B1, 0x0eac },		//  172, 14
	{ 0x06B3, 0x0eb0 },		//  176, 14
	{ 0x06B5, 0x0eb4 },		//  180, 14
	{ 0x06BA, 0x0eba },		//  186, 14
	{ 0x06BB, 0x0ec2 },		//  194, 14
	{ 0x06BC, 0x0ebe },		//  190, 14
	{ 0x06C0, 0x0eda },		//  218, 14
	{ 0x06C6, 0x0ec6 },		//  198, 14
	{ 0x06CA, 0x0ec8 },		//  200, 14
	{ 0x06CE, 0x0ed0 },		//  208, 14
	{ 0x06D1, 0x0ed6 },		//  214, 14
	{ 0x06D2, 0x0ed4 },		//  212, 14
	{ 0x06D6, 0x0d25 },		//  37 , 13
	{ 0x06E4, 0x0d22 },		//  34 , 13
	{ 0x06F4, 0x0e29 },		//  41 , 14
	{ 0x06F5, 0x0e2b },		//  43 , 14
	{ 0x06F6, 0x0e2c },		//  44 , 14
	{ 0x06F7, 0x0e2e },		//  46 , 14
	{ 0x06F8, 0x0e2f },		//  47 , 14
	{ 0x10D0, 0x0ad2 },		//  210, 10
	{ 0x10D1, 0x0ad3 },		//  211, 10
	{ 0x10D2, 0x0ad4 },		//  212, 10
	{ 0x10D3, 0x0ad5 },		//  213, 10
	{ 0x10D4, 0x0ad6 },		//  214, 10
	{ 0x10D5, 0x0ad7 },		//  215, 10
	{ 0x10D6, 0x0ad8 },		//  216, 10
	{ 0x10D7, 0x0ada },		//  218, 10
	{ 0x10D8, 0x0adb },		//  219, 10
	{ 0x10D9, 0x0adc },		//  220, 10
	{ 0x10DA, 0x0add },		//  221, 10
	{ 0x10DB, 0x0ade },		//  222, 10
	{ 0x10DC, 0x0adf },		//  223, 10
	{ 0x10DD, 0x0ae1 },		//  225, 10
	{ 0x10DE, 0x0ae2 },		//  226, 10
	{ 0x10DF, 0x0ae3 },		//  227, 10
	{ 0x10E0, 0x0ae4 },		//  228, 10
	{ 0x10E1, 0x0ae5 },		//  229, 10
	{ 0x10E2, 0x0ae6 },		//  230, 10
	{ 0x10E3, 0x0ae7 },		//  231, 10
	{ 0x10E4, 0x0ae9 },		//  233, 10
	{ 0x10E5, 0x0aea },		//  234, 10
	{ 0x10E6, 0x0aeb },		//  235, 10
	{ 0x10E7, 0x0aec },		//  236, 10
	{ 0x10E8, 0x0aed },		//  237, 10
	{ 0x10E9, 0x0aee },		//  238, 10
	{ 0x10EA, 0x0aef },		//  239, 10
	{ 0x10EB, 0x0af0 },		//  240, 10
	{ 0x10EC, 0x0af1 },		//  241, 10
	{ 0x10ED, 0x0af2 },		//  242, 10
	{ 0x10EE, 0x0af3 },		//  243, 10
	{ 0x10EF, 0x0af5 },		//  245, 10
	{ 0x10F0, 0x0af6 },		//  246, 10
	{ 0x10F1, 0x0ad9 },		//  217, 10
	{ 0x10F2, 0x0ae0 },		//  224, 10
	{ 0x10F3, 0x0ae8 },		//  232, 10
	{ 0x10F4, 0x0af4 },		//  244, 10
	{ 0x10F5, 0x0af7 },		//  247, 10
	{ 0x10F6, 0x0af8 },		//  248, 10
	{ 0x1F00, 0x0873 },		//  115,  8
	{ 0x1F01, 0x087b },		//  123,  8
	{ 0x1F02, 0x0875 },		//  117,  8
	{ 0x1F03, 0x087d },		//  125,  8
	{ 0x1F04, 0x0874 },		//  116,  8
	{ 0x1F05, 0x087c },		//  124,  8
	{ 0x1F10, 0x0884 },		//  132,  8
	{ 0x1F11, 0x0887 },		//  135,  8
	{ 0x1F12, 0x0886 },		//  134,  8
	{ 0x1F13, 0x0889 },		//  137,  8
	{ 0x1F14, 0x0885 },		//  133,  8
	{ 0x1F15, 0x0888 },		//  136,  8
	{ 0x1F20, 0x0890 },		//  144,  8
	{ 0x1F21, 0x0898 },		//  152,  8
	{ 0x1F22, 0x0892 },		//  146,  8
	{ 0x1F23, 0x089a },		//  154,  8
	{ 0x1F24, 0x0891 },		//  145,  8
	{ 0x1F25, 0x0899 },		//  153,  8
	{ 0x1F30, 0x08a4 },		//  164,  8
	{ 0x1F31, 0x08a8 },		//  168,  8
	{ 0x1F32, 0x08a6 },		//  166,  8
	{ 0x1F33, 0x08aa },		//  170,  8
	{ 0x1F34, 0x08a5 },		//  165,  8
	{ 0x1F35, 0x08a9 },		//  169,  8
	{ 0x1F40, 0x08ad },		//  173,  8
	{ 0x1F41, 0x08b0 },		//  176,  8
	{ 0x1F42, 0x08af },		//  175,  8
	{ 0x1F43, 0x08b2 },		//  178,  8
	{ 0x1F44, 0x08ae },		//  174,  8
	{ 0x1F45, 0x08b1 },		//  177,  8
	{ 0x1F50, 0x08b9 },		//  185,  8
	{ 0x1F51, 0x08bd },		//  189,  8
	{ 0x1F52, 0x08bb },		//  187,  8
	{ 0x1F53, 0x08bf },		//  191,  8
	{ 0x1F54, 0x08ba },		//  186,  8
	{ 0x1F55, 0x08be },		//  190,  8
	{ 0x1F60, 0x08c7 },		//  199,  8
	{ 0x1F61, 0x08cf },		//  207,  8
	{ 0x1F62, 0x08c9 },		//  201,  8
	{ 0x1F63, 0x08d1 },		//  209,  8
	{ 0x1F64, 0x08c8 },		//  200,  8
	{ 0x1F65, 0x08d0 },		//  208,  8
	{ 0x1F70, 0x086d },		//  109,  8
	{ 0x1F72, 0x0883 },		//  131,  8
	{ 0x1F74, 0x088a },		//  138,  8
	{ 0x1F76, 0x08a0 },		//  160,  8
	{ 0x1F78, 0x08ac },		//  172,  8
	{ 0x1F7A, 0x08b5 },		//  181,  8
	{ 0x1F7C, 0x08c1 },		//  193,  8
	{ 0x1F80, 0x0877 },		//  119,  8
	{ 0x1F81, 0x087f },		//  127,  8
	{ 0x1F82, 0x0879 },		//  121,  8
	{ 0x1F83, 0x0881 },		//  129,  8
	{ 0x1F84, 0x0878 },		//  120,  8
	{ 0x1F85, 0x0880 },		//  128,  8
	{ 0x1F90, 0x0894 },		//  148,  8
	{ 0x1F91, 0x089c },		//  156,  8
	{ 0x1F92, 0x0896 },		//  150,  8
	{ 0x1F93, 0x089e },		//  158,  8
	{ 0x1F94, 0x0895 },		//  149,  8
	{ 0x1F95, 0x089d },		//  157,  8
	{ 0x1FA0, 0x08cb },		//  203,  8
	{ 0x1FA1, 0x08d3 },		//  211,  8
	{ 0x1FA2, 0x08cd },		//  205,  8
	{ 0x1FA3, 0x08d5 },		//  213,  8
	{ 0x1FA4, 0x08cc },		//  204,  8
	{ 0x1FA5, 0x08d4 },		//  212,  8
	{ 0x1FB2, 0x0871 },		//  113,  8
	{ 0x1FB3, 0x086f },		//  111,  8
	{ 0x1FB4, 0x0870 },		//  112,  8
	{ 0x1FC2, 0x088e },		//  142,  8
	{ 0x1FC3, 0x088c },		//  140,  8
	{ 0x1FC4, 0x088d },		//  141,  8
	{ 0x1FCD, 0x085e },		//  94 ,  8
	{ 0x1FCE, 0x085c },		//  92 ,  8
	{ 0x1FDD, 0x085f },		//  95 ,  8
	{ 0x1FDE, 0x085d },		//  93 ,  8
	{ 0x1FE4, 0x08B4 },		//  180,  8
	{ 0x1FE5, 0x08B3 },		//  179,  8
	{ 0x1FF2, 0x08c5 },		//  197,  8
	{ 0x1FF3, 0x08c3 },		//  195,  8
	{ 0x1FF4, 0x08c4 },		//  196,  8
	{ 0x2007, 0x0517 },		//  23 ,  5
	{ 0x2012, 0x0432 },		//  50 ,  4
	{ 0x2013, 0x0421 },		//  33 ,  4
	{ 0x2014, 0x0422 },		//  34 ,  4
	{ 0x2017, 0x022f },		//  47 ,  2
	{ 0x2018, 0x041d },		//  29 ,  4
	{ 0x2019, 0x041c },		//  28 ,  4
	{ 0x201A, 0x043e },		//  62 ,  4
	{ 0x201B, 0x041b },		//  27 ,  4
	{ 0x201C, 0x0420 },		//  32 ,  4
	{ 0x201D, 0x041f },		//  31 ,  4
	{ 0x201E, 0x043f },		//  63 ,  4
	{ 0x201F, 0x041e },		//  30 ,  4
	{ 0x2020, 0x0427 },		//  39 ,  4
	{ 0x2021, 0x0428 },		//  40 ,  4
	{ 0x2022, 0x0403 },		//   3 ,  4
	{ 0x2026, 0x0438 },		//  56 ,  4
	{ 0x2030, 0x044b },		//  75 ,  4
	{ 0x2033, 0x0580 },		//  128,  5
	{ 0x2034, 0x0671 },		//  113,  6
	{ 0x2036, 0x057f },		//  127,  5
	{ 0x2039, 0x0423 },		//  35 ,  4
	{ 0x203A, 0x0424 },		//  36 ,  4
	{ 0x203C, 0x050d },		//  13 ,  5
	{ 0x203E, 0x0626 },		//  38 ,  6
	{ 0x207F, 0x0415 },		//  21 ,  4
	{ 0x20A0, 0x043c },		//  60 ,  4
	{ 0x20A2, 0x043b },		//  59 ,  4
	{ 0x20A3, 0x043a },		//  58 ,  4
	{ 0x20A4, 0x043d },		//  61 ,  4
	{ 0x20A6, 0x0457 },		//  87 ,  4
	{ 0x20A7, 0x040d },		//  13 ,  4
	{ 0x20A8, 0x0458 },		//  88 ,  4
	{ 0x20A9, 0x0456 },		//  86 ,  4
	{ 0x20AA, 0x097A },		//  122,  9
	{ 0x20AC, 0x0466 },	   //  102,  4, Euro Sign - GW assigned x448 [4,72]
	{ 0x20DD, 0x066d },		//  109,  6
	{ 0x20E1, 0x06e1 },		//  225,  6
	{ 0x2102, 0x06d5 },		//  213,  6
	{ 0x2104, 0x0515 },		//  21 ,  5
	{ 0x2105, 0x0449 },		//  73 ,  4
	{ 0x2106, 0x044a },		//  74 ,  4
	{ 0x210C, 0x06e9 },		//  233,  6
	{ 0x210F, 0x0632 },		//  50 ,  6
	{ 0x2111, 0x0633 },		//  51 ,  6
	{ 0x2112, 0x0669 },		//  105,  6
	{ 0x2113, 0x0631 },		//  49 ,  6
	{ 0x2115, 0x06d7 },		//  215,  6
	{ 0x2116, 0x044c },		//  76 ,  4
	{ 0x2118, 0x0635 },		//  53 ,  6
	{ 0x211C, 0x0634 },		//  52 ,  6
	{ 0x211D, 0x06d8 },		//  216,  6
	{ 0x211E, 0x042b },		//  43 ,  4
	{ 0x2120, 0x042a },		//  42 ,  4
	{ 0x2122, 0x0429 },		//  41 ,  4
	{ 0x2127, 0x06a7 },		//  167,  6
	{ 0x2128, 0x066b },		//  107,  6
	{ 0x212B, 0x0623 },		//  35 ,  6
	{ 0x212D, 0x066a },		//  106,  6
	{ 0x212F, 0x0630 },		//  48 ,  6
	{ 0x2130, 0x06d3 },		//  211,  6
	{ 0x2131, 0x06d4 },		//  212,  6
	{ 0x2153, 0x0440 },		//  64 ,  4
	{ 0x2154, 0x0441 },		//  65 ,  4
	{ 0x215B, 0x0442 },		//  66 ,  4
	{ 0x215C, 0x0443 },		//  67 ,  4
	{ 0x215D, 0x0444 },		//  68 ,  4
	{ 0x215E, 0x0445 },		//  69 ,  4
	{ 0x2190, 0x0590 },		//  144,  5
	{ 0x2191, 0x0617 },		//  23 ,  6
	{ 0x2192, 0x05d5 },		//  213,  5
	{ 0x2193, 0x0618 },		//  24 ,  6
	{ 0x2194, 0x05d6 },		//  214,  5
	{ 0x2195, 0x05d7 },		//  215,  5
	{ 0x2196, 0x0640 },		//  64 ,  6
	{ 0x2197, 0x063e },		//  62 ,  6
	{ 0x2198, 0x063f },		//  63 ,  6
	{ 0x2199, 0x0641 },		//  65 ,  6
	{ 0x219D, 0x0690 },		//  144,  6
	{ 0x21A3, 0x0693 },		//  147,  6
	{ 0x21A8, 0x050f },		//  15 ,  5
	{ 0x21A9, 0x0691 },		//  145,  6
	{ 0x21AA, 0x0692 },		//  146,  6
	{ 0x21B5, 0x0514 },		//  20 ,  5
	{ 0x21BC, 0x0694 },		//  148,  6
	{ 0x21BD, 0x0695 },		//  149,  6
	{ 0x21BE, 0x069b },		//  155,  6
	{ 0x21BF, 0x069a },		//  154,  6
	{ 0x21C0, 0x0696 },		//  150,  6
	{ 0x21C1, 0x0697 },		//  151,  6
	{ 0x21C2, 0x069d },		//  157,  6
	{ 0x21C3, 0x069c },		//  156,  6
	{ 0x21C4, 0x0636 },		//  54 ,  6
	{ 0x21C6, 0x0637 },		//  55 ,  6
	{ 0x21C7, 0x069f },		//  159,  6
	{ 0x21C9, 0x069e },		//  158,  6
	{ 0x21CB, 0x0699 },		//  153,  6
	{ 0x21CC, 0x0698 },		//  152,  6
	{ 0x21D0, 0x0639 },		//  57 ,  6
	{ 0x21D1, 0x063a },		//  58 ,  6
	{ 0x21D2, 0x0638 },		//  56 ,  6
	{ 0x21D3, 0x063b },		//  59 ,  6
	{ 0x21D4, 0x063c },		//  60 ,  6
	{ 0x21D5, 0x063d },		//  61 ,  6
	{ 0x21E6, 0x0597 },		//  151,  5
	{ 0x21E8, 0x0596 },		//  150,  5
	{ 0x2200, 0x067a },		//  122,  6
	{ 0x2202, 0x062c },		//  44 ,  6
	{ 0x2203, 0x0679 },		//  121,  6
	{ 0x2204, 0x06d0 },		//  208,  6
	{ 0x2205, 0x0648 },		//  72 ,  6
	{ 0x2207, 0x062b },		//  43 ,  6
	{ 0x2208, 0x060f },		//  15 ,  6
	{ 0x2209, 0x06d1 },		//  209,  6
	{ 0x220B, 0x06db },		//  219,  6
	{ 0x220D, 0x0647 },		//  71 ,  6
	{ 0x220F, 0x0629 },		//  41 ,  6
	{ 0x2210, 0x0672 },		//  114,  6
	{ 0x2211, 0x0612 },		//  18 ,  6
	{ 0x2212, 0x0600 },		//   0 ,  6
	{ 0x2213, 0x062a },		//  42 ,  6
	{ 0x2214, 0x06ae },		//  174,  6
	{ 0x2215, 0x0606 },		//   6 ,  6
	{ 0x2216, 0x0607 },		//   7 ,  6
	{ 0x2218, 0x0621 },		//  33 ,  6
	{ 0x2219, 0x0622 },		//  34 ,  6
	{ 0x221A, 0x0704 },		//   4 ,  7
	{ 0x221D, 0x0604 },		//   4 ,  6
	{ 0x221E, 0x0613 },		//  19 ,  6
	{ 0x221F, 0x06da },		//  218,  6
	{ 0x2220, 0x064f },		//  79 ,  6
	{ 0x2221, 0x06a8 },		//  168,  6
	{ 0x2222, 0x06a9 },		//  169,  6
	{ 0x2223, 0x0609 },		//   9 ,  6
	{ 0x2224, 0x06ce },		//  206,  6
	{ 0x2225, 0x0611 },		//  17 ,  6
	{ 0x2226, 0x06cd },		//  205,  6
	{ 0x2227, 0x0655 },		//  85 ,  6
	{ 0x2228, 0x0656 },		//  86 ,  6
	{ 0x2229, 0x0610 },		//  16 ,  6
	{ 0x222A, 0x0642 },		//  66 ,  6
	{ 0x222B, 0x0628 },		//  40 ,  6
	{ 0x222E, 0x0668 },		//  104,  6
	{ 0x2234, 0x0666 },		//  102,  6
	{ 0x2235, 0x0665 },		//  101,  6
	{ 0x2237, 0x0667 },		//  103,  6
	{ 0x223C, 0x060c },		//  12 ,  6
	{ 0x2241, 0x06bd },		//  189,  6
	{ 0x2243, 0x0673 },		//  115,  6
	{ 0x2244, 0x06be },		//  190,  6
	{ 0x2245, 0x0674 },		//  116,  6
	{ 0x2247, 0x06bf },		//  191,  6
	{ 0x2248, 0x060d },		//  13 ,  6
	{ 0x2249, 0x06c0 },		//  192,  6
	{ 0x224D, 0x06b3 },		//  179,  6
	{ 0x224E, 0x06b2 },		//  178,  6
	{ 0x2250, 0x06af },		//  175,  6
	{ 0x2252, 0x06b0 },		//  176,  6
	{ 0x2253, 0x06b1 },		//  177,  6
	{ 0x225F, 0x06d9 },		//  217,  6
	{ 0x2260, 0x0663 },		//  99 ,  6
	{ 0x2261, 0x060e },		//  14 ,  6
	{ 0x2262, 0x0664 },		//  100,  6
	{ 0x2264, 0x0602 },		//   2 ,  6
	{ 0x2265, 0x0603 },		//   3 ,  6
	{ 0x226A, 0x064d },		//  77 ,  6
	{ 0x226B, 0x064e },		//  78 ,  6
	{ 0x226C, 0x06b6 },		//  182,  6
	{ 0x226D, 0x06cf },		//  207,  6
	{ 0x226E, 0x06b9 },		//  185,  6
	{ 0x226F, 0x06bb },		//  187,  6
	{ 0x2270, 0x06ba },		//  186,  6
	{ 0x2271, 0x06bc },		//  188,  6
	{ 0x2272, 0x06eb },		//  235,  6
	{ 0x2273, 0x06ec },		//  236,  6
	{ 0x227A, 0x0675 },		//  117,  6
	{ 0x227B, 0x0677 },		//  119,  6
	{ 0x227C, 0x0676 },		//  118,  6
	{ 0x227D, 0x0678 },		//  120,  6
	{ 0x2280, 0x06c1 },		//  193,  6
	{ 0x2281, 0x06c3 },		//  195,  6
	{ 0x2282, 0x0643 },		//  67 ,  6
	{ 0x2283, 0x0644 },		//  68 ,  6
	{ 0x2284, 0x06c5 },		//  197,  6
	{ 0x2285, 0x06c6 },		//  198,  6
	{ 0x2286, 0x0645 },		//  69 ,  6
	{ 0x2287, 0x0646 },		//  70 ,  6
	{ 0x2288, 0x06c7 },		//  199,  6
	{ 0x2289, 0x06c8 },		//  200,  6
	{ 0x228A, 0x067e },		//  126,  6
	{ 0x228B, 0x067f },		//  127,  6
	{ 0x228E, 0x067d },		//  125,  6
	{ 0x228F, 0x0682 },		//  130,  6
	{ 0x2290, 0x0685 },		//  133,  6
	{ 0x2291, 0x0683 },		//  131,  6
	{ 0x2292, 0x0686 },		//  134,  6
	{ 0x2293, 0x0680 },		//  128,  6
	{ 0x2294, 0x0681 },		//  129,  6
	{ 0x2295, 0x0651 },		//  81 ,  6
	{ 0x2296, 0x0652 },		//  82 ,  6
	{ 0x2297, 0x0650 },		//  80 ,  6
	{ 0x2299, 0x0654 },		//  84 ,  6
	{ 0x229A, 0x06a4 },		//  164,  6
	{ 0x229B, 0x06a5 },		//  165,  6
	{ 0x229D, 0x06a6 },		//  166,  6
	{ 0x22A2, 0x065b },		//  91 ,  6
	{ 0x22A3, 0x065c },		//  92 ,  6
	{ 0x22A4, 0x0658 },		//  88 ,  6
	{ 0x22A5, 0x0659 },		//  89 ,  6
	{ 0x22A8, 0x06b4 },		//  180,  6
	{ 0x22BB, 0x0657 },		//  87 ,  6
	{ 0x22C5, 0x061f },		//  31 ,  6
	{ 0x22C6, 0x0670 },		//  112,  6
	{ 0x22C8, 0x068c },		//  140,  6
	{ 0x22D0, 0x06a2 },		//  162,  6
	{ 0x22D1, 0x06a3 },		//  163,  6
	{ 0x22D2, 0x06a1 },		//  161,  6
	{ 0x22D3, 0x06a0 },		//  160,  6
	{ 0x22D8, 0x067b },		//  123,  6
	{ 0x22D9, 0x067c },		//  124,  6
	{ 0x22E0, 0x06c2 },		//  194,  6
	{ 0x22E1, 0x06c4 },		//  196,  6
	{ 0x22E2, 0x06cb },		//  203,  6
	{ 0x22E3, 0x06cc },		//  204,  6
	{ 0x22E4, 0x0684 },		//  132,  6
	{ 0x22E5, 0x0687 },		//  135,  6
	{ 0x22EE, 0x06de },		//  222,  6
	{ 0x22EF, 0x06dc },		//  220,  6
	{ 0x22F1, 0x06df },		//  223,  6
	{ 0x2302, 0x050c },		//  12 ,  5
	{ 0x2308, 0x0649 },		//  73 ,  6
	{ 0x2309, 0x064a },		//  74 ,  6
	{ 0x230A, 0x064b },		//  75 ,  6
	{ 0x230B, 0x064c },		//  76 ,  6
	{ 0x2310, 0x0510 },		//  16 ,  5
	{ 0x2312, 0x065a },		//  90 ,  6
	{ 0x2319, 0x0511 },		//  17 ,  5
	{ 0x231A, 0x051f },		//  31 ,  5
	{ 0x231B, 0x0520 },		//  32 ,  5
	{ 0x2320, 0x0700 },		//   0 ,  7
	{ 0x2321, 0x0701 },		//   1 ,  7
	{ 0x2322, 0x068e },		//  142,  6
	{ 0x2323, 0x068d },		//  141,  6
	{ 0x2329, 0x060a },		//  10 ,  6
	{ 0x232A, 0x060b },		//  11 ,  6
	{ 0x2409, 0x044f },		//  79 ,  4
	{ 0x240A, 0x0452 },		//  82 ,  4
	{ 0x240B, 0x0454 },		//  84 ,  4
	{ 0x240C, 0x0450 },		//  80 ,  4
	{ 0x240D, 0x0451 },		//  81 ,  4
	{ 0x2424, 0x0453 },		//  83 ,  4
	{ 0x24C2, 0x0446 },		//  70 ,  4
	{ 0x24C5, 0x0447 },		//  71 ,  4
	{ 0x24CA, 0x0448 },		//  72 ,  4,  - circled U
	{ 0x2500, 0x0308 },		//   8 ,  3
	{ 0x2502, 0x0309 },		//   9 ,  3
	{ 0x250C, 0x030a },		//  10 ,  3
	{ 0x2510, 0x030b },		//  11 ,  3
	{ 0x2514, 0x030d },		//  13 ,  3
	{ 0x2518, 0x030c },		//  12 ,  3
	{ 0x251C, 0x030e },		//  14 ,  3
	{ 0x251E, 0x033e },		//  62 ,  3
	{ 0x251F, 0x033c },		//  60 ,  3
	{ 0x2521, 0x033f },		//  63 ,  3
	{ 0x2522, 0x033d },		//  61 ,  3
	{ 0x2524, 0x0310 },		//  16 ,  3
	{ 0x2526, 0x0345 },		//  69 ,  3
	{ 0x2527, 0x0344 },		//  68 ,  3
	{ 0x2529, 0x0347 },		//  71 ,  3
	{ 0x252A, 0x0346 },		//  70 ,  3
	{ 0x252C, 0x030f },		//  15 ,  3
	{ 0x252D, 0x0342 },		//  66 ,  3
	{ 0x252E, 0x0340 },		//  64 ,  3
	{ 0x2531, 0x0343 },		//  67 ,  3
	{ 0x2532, 0x0341 },		//  65 ,  3
	{ 0x2534, 0x0311 },		//  17 ,  3
	{ 0x2535, 0x034a },		//  74 ,  3
	{ 0x2536, 0x0348 },		//  72 ,  3
	{ 0x2539, 0x034b },		//  75 ,  3
	{ 0x253A, 0x0349 },		//  73 ,  3
	{ 0x253C, 0x0312 },		//  18 ,  3
	{ 0x253D, 0x0352 },		//  82 ,  3
	{ 0x253E, 0x034e },		//  78 ,  3
	{ 0x2540, 0x034f },		//  79 ,  3
	{ 0x2541, 0x034c },		//  76 ,  3
	{ 0x2543, 0x0355 },		//  85 ,  3
	{ 0x2544, 0x0350 },		//  80 ,  3
	{ 0x2545, 0x0353 },		//  83 ,  3
	{ 0x2546, 0x034d },		//  77 ,  3
	{ 0x2547, 0x0357 },		//  87 ,  3
	{ 0x2548, 0x0354 },		//  84 ,  3
	{ 0x2549, 0x0356 },		//  86 ,  3
	{ 0x254A, 0x0351 },		//  81 ,  3
	{ 0x2550, 0x0313 },		//  19 ,  3
	{ 0x2551, 0x0314 },		//  20 ,  3
	{ 0x2552, 0x031e },		//  30 ,  3
	{ 0x2553, 0x0322 },		//  34 ,  3
	{ 0x2554, 0x0315 },		//  21 ,  3
	{ 0x2555, 0x031f },		//  31 ,  3
	{ 0x2556, 0x0323 },		//  35 ,  3
	{ 0x2557, 0x0316 },		//  22 ,  3
	{ 0x2558, 0x0321 },		//  33 ,  3
	{ 0x2559, 0x0325 },		//  37 ,  3
	{ 0x255A, 0x0318 },		//  24 ,  3
	{ 0x255B, 0x0320 },		//  32 ,  3
	{ 0x255C, 0x0324 },		//  36 ,  3
	{ 0x255D, 0x0317 },		//  23 ,  3
	{ 0x255E, 0x0326 },		//  38 ,  3
	{ 0x255F, 0x032a },		//  42 ,  3
	{ 0x2560, 0x0319 },		//  25 ,  3
	{ 0x2561, 0x0328 },		//  40 ,  3
	{ 0x2562, 0x032c },		//  44 ,  3
	{ 0x2563, 0x031b },		//  27 ,  3
	{ 0x2564, 0x032b },		//  43 ,  3
	{ 0x2565, 0x0327 },		//  39 ,  3
	{ 0x2566, 0x031a },		//  26 ,  3
	{ 0x2567, 0x032d },		//  45 ,  3
	{ 0x2568, 0x0329 },		//  41 ,  3
	{ 0x2569, 0x031c },		//  28 ,  3
	{ 0x256A, 0x032f },		//  47 ,  3
	{ 0x256B, 0x032e },		//  46 ,  3
	{ 0x256C, 0x031d },		//  29 ,  3
	{ 0x2574, 0x0330 },		//  48 ,  3
	{ 0x2575, 0x0331 },		//  49 ,  3
	{ 0x2576, 0x0332 },		//  50 ,  3
	{ 0x2577, 0x0333 },		//  51 ,  3
	{ 0x2578, 0x0334 },		//  52 ,  3
	{ 0x2579, 0x0335 },		//  53 ,  3
	{ 0x257A, 0x0336 },		//  54 ,  3
	{ 0x257B, 0x0337 },		//  55 ,  3
	{ 0x257C, 0x0338 },		//  56 ,  3
	{ 0x257D, 0x033a },		//  58 ,  3
	{ 0x257E, 0x0339 },		//  57 ,  3
	{ 0x257F, 0x033b },		//  59 ,  3
	{ 0x2580, 0x0305 },		//   5 ,  3
	{ 0x2584, 0x0307 },		//   7 ,  3
	{ 0x2588, 0x0303 },		//   3 ,  3
	{ 0x258C, 0x0304 },		//   4 ,  3
	{ 0x2590, 0x0306 },		//   6 ,  3
	{ 0x2591, 0x0300 },		//   0 ,  3
	{ 0x2592, 0x0301 },		//   1 ,  3
	{ 0x2593, 0x0302 },		//   2 ,  3
	{ 0x25A0, 0x0402 },		//   2 ,  4
	{ 0x25A1, 0x0426 },		//  38 ,  4
	{ 0x25AA, 0x042f },		//  47 ,  4
	{ 0x25AB, 0x0431 },		//  49 ,  4
	{ 0x25AC, 0x050b },		//  11 ,  5
	{ 0x25B2, 0x0573 },		//  115,  5
	{ 0x25B3, 0x0688 },		//  136,  6
	{ 0x25B4, 0x061d },		//  29 ,  6
	{ 0x25B5, 0x06ac },		//  172,  6
	{ 0x25B8, 0x061b },		//  27 ,  6
	{ 0x25B9, 0x068b },		//  139,  6
	{ 0x25BC, 0x0574 },		//  116,  5
	{ 0x25BD, 0x0689 },		//  137,  6
	{ 0x25BE, 0x061e },		//  30 ,  6
	{ 0x25BF, 0x06ad },		//  173,  6
	{ 0x25C2, 0x061c },		//  28 ,  6
	{ 0x25C3, 0x068a },		//  138,  6
	{ 0x25C6, 0x0575 },		//  117,  5
	{ 0x25C7, 0x066f },		//  111,  6
	{ 0x25CA, 0x065f },		//  95 ,  6
	{ 0x25CB, 0x0401 },		//   1 ,  4
	{ 0x25CF, 0x0400 },		//   0 ,  4
	{ 0x25D6, 0x059e },		//  158,  5
	{ 0x25D7, 0x0577 },		//  119,  5
	{ 0x25D8, 0x0512 },		//  18 ,  5
	{ 0x25D9, 0x0513 },		//  19 ,  5
	{ 0x25E6, 0x042d },		//  45 ,  4
	{ 0x2605, 0x0548 },		//  72,   5
	{ 0x260E, 0x051e },		//  30 ,  5
	{ 0x2610, 0x0518 },		//  24 ,  5
	{ 0x2612, 0x0519 },		//  25 ,  5
	{ 0x261B, 0x052a },		//  42 ,  5
	{ 0x261C, 0x0516 },		//  22 ,  5
	{ 0x261E, 0x052b },		//  43 ,  5
	{ 0x2639, 0x051a },		//  26 ,  5
	{ 0x263A, 0x0507 },		//   7 ,  5
	{ 0x263B, 0x0508 },		//   8 ,  5
	{ 0x263C, 0x0506 },		//   6 ,  5
	{ 0x2640, 0x0505 },		//   5 ,  5
	{ 0x2642, 0x0504 },		//   4 ,  5
	{ 0x2660, 0x05ab },		//  171,  5
	{ 0x2661, 0x0500 },		//   0 ,  5
	{ 0x2662, 0x0501 },		//   1 ,  5
	{ 0x2663, 0x05a8 },		//  168,  5
	{ 0x2664, 0x0503 },		//   3 ,  5
	{ 0x2665, 0x05aa },		//  170,  5
	{ 0x2666, 0x05a9 },		//  169,  5
	{ 0x2667, 0x0502 },		//   2 ,  5
	{ 0x266A, 0x0509 },		//   9 ,  5
	{ 0x266C, 0x050a },		//  10 ,  5
	{ 0x266D, 0x051c },		//  28 ,  5
	{ 0x266E, 0x051d },		//  29 ,  5
	{ 0x266F, 0x051b },		//  27 ,  5
	{ 0x2701, 0x0521 },		//  33 ,  5
	{ 0x2702, 0x0522 },		//  34 ,  5
	{ 0x2703, 0x0523 },		//  35 ,  5
	{ 0x2704, 0x0524 },		//  36 ,  5
	{ 0x2706, 0x0526 },		//  38 ,  5
	{ 0x2707, 0x0527 },		//  39 ,  5
	{ 0x2708, 0x0528 },		//  40 ,  5
	{ 0x2709, 0x0529 },		//  41 ,  5
	{ 0x270C, 0x052c },		//  44 ,  5
	{ 0x270D, 0x052d },		//  45 ,  5
	{ 0x270E, 0x052e },		//  46 ,  5
	{ 0x270F, 0x052f },		//  47 ,  5
	{ 0x2710, 0x0530 },		//  48 ,  5
	{ 0x2711, 0x0531 },		//  49 ,  5
	{ 0x2712, 0x0532 },		//  50 ,  5
	{ 0x2713, 0x0533 },		//  51 ,  5
	{ 0x2714, 0x0534 },		//  52 ,  5
	{ 0x2715, 0x0535 },		//  53 ,  5
	{ 0x2716, 0x0536 },		//  54 ,  5
	{ 0x2717, 0x0537 },		//  55 ,  5
	{ 0x2718, 0x0538 },		//  56 ,  5
	{ 0x2719, 0x0539 },		//  57 ,  5
	{ 0x271A, 0x053a },		//  58 ,  5
	{ 0x271B, 0x053b },		//  59 ,  5
	{ 0x271C, 0x053c },		//  60 ,  5
	{ 0x271D, 0x053d },		//  61 ,  5
	{ 0x271E, 0x053e },		//  62 ,  5
	{ 0x271F, 0x053f },		//  63 ,  5
	{ 0x2720, 0x0540 },		//  64 ,  5
	{ 0x2721, 0x0541 },		//  65 ,  5
	{ 0x2722, 0x0542 },		//  66 ,  5
	{ 0x2723, 0x0543 },		//  67 ,  5
	{ 0x2724, 0x0544 },		//  68 ,  5
	{ 0x2725, 0x0545 },		//  69 ,  5
	{ 0x2726, 0x0546 },		//  70 ,  5
	{ 0x2727, 0x0547 },		//  71 ,  5
	{ 0x2729, 0x0549 },		//  73 ,  5
	{ 0x272A, 0x054a },		//  74 ,  5
	{ 0x272B, 0x054b },		//  75 ,  5
	{ 0x272C, 0x054c },		//  76 ,  5
	{ 0x272D, 0x054d },		//  77 ,  5
	{ 0x272E, 0x054e },		//  78 ,  5
	{ 0x272F, 0x054f },		//  79 ,  5
	{ 0x2730, 0x0550 },		//  80 ,  5
	{ 0x2731, 0x0551 },		//  81 ,  5
	{ 0x2732, 0x0552 },		//  82 ,  5
	{ 0x2733, 0x0553 },		//  83 ,  5
	{ 0x2734, 0x0554 },		//  84 ,  5
	{ 0x2735, 0x0555 },		//  85 ,  5
	{ 0x2736, 0x0556 },		//  86 ,  5
	{ 0x2737, 0x0557 },		//  87 ,  5
	{ 0x2738, 0x0558 },		//  88 ,  5
	{ 0x2739, 0x0559 },		//  89 ,  5
	{ 0x273A, 0x055a },		//  90 ,  5
	{ 0x273B, 0x055b },		//  91 ,  5
	{ 0x273C, 0x055c },		//  92 ,  5
	{ 0x273D, 0x055d },		//  93 ,  5
	{ 0x273E, 0x055e },		//  94 ,  5
	{ 0x273F, 0x055f },		//  95 ,  5
	{ 0x2740, 0x0560 },		//  96 ,  5
	{ 0x2741, 0x0561 },		//  97 ,  5
	{ 0x2742, 0x0562 },		//  98 ,  5
	{ 0x2743, 0x0563 },		//  99 ,  5
	{ 0x2744, 0x0564 },		//  100,  5
	{ 0x2745, 0x0565 },		//  101,  5
	{ 0x2746, 0x0566 },		//  102,  5
	{ 0x2747, 0x0567 },		//  103,  5
	{ 0x2748, 0x0568 },		//  104,  5
	{ 0x2749, 0x0569 },		//  105,  5
	{ 0x274A, 0x056a },		//  106,  5
	{ 0x274B, 0x056b },		//  107,  5
	{ 0x274D, 0x056d },		//  109,  5
	{ 0x274F, 0x056f },		//  111,  5
	{ 0x2750, 0x0570 },		//  112,  5
	{ 0x2751, 0x0571 },		//  113,  5
	{ 0x2752, 0x0572 },		//  114,  5
	{ 0x2756, 0x0576 },		//  118,  5
	{ 0x2758, 0x0578 },		//  120,  5
	{ 0x2759, 0x0579 },		//  121,  5
	{ 0x275A, 0x057a },		//  122,  5
	{ 0x275B, 0x057b },		//  123,  5
	{ 0x275C, 0x057c },		//  124,  5
	{ 0x275D, 0x057d },		//  125,  5
	{ 0x275E, 0x057e },		//  126,  5
	{ 0x2761, 0x05a1 },		//  161,  5
	{ 0x2762, 0x05a2 },		//  162,  5
	{ 0x2763, 0x05a3 },		//  163,  5
	{ 0x2764, 0x05a4 },		//  164,  5
	{ 0x2765, 0x05a5 },		//  165,  5
	{ 0x2766, 0x05a6 },		//  166,  5
	{ 0x2767, 0x05a7 },		//  167,  5
	{ 0x2776, 0x05b6 },		//  182,  5
	{ 0x2777, 0x05b7 },		//  183,  5
	{ 0x2778, 0x05b8 },		//  184,  5
	{ 0x2779, 0x05b9 },		//  185,  5
	{ 0x277A, 0x05ba },		//  186,  5
	{ 0x277B, 0x05bb },		//  187,  5
	{ 0x277C, 0x05bc },		//  188,  5
	{ 0x277D, 0x05bd },		//  189,  5
	{ 0x277E, 0x05be },		//  190,  5
	{ 0x277F, 0x05bf },		//  191,  5
	{ 0x2780, 0x05c0 },		//  192,  5
	{ 0x2781, 0x05c1 },		//  193,  5
	{ 0x2782, 0x05c2 },		//  194,  5
	{ 0x2783, 0x05c3 },		//  195,  5
	{ 0x2784, 0x05c4 },		//  196,  5
	{ 0x2785, 0x05c5 },		//  197,  5
	{ 0x2786, 0x05c6 },		//  198,  5
	{ 0x2787, 0x05c7 },		//  199,  5
	{ 0x2788, 0x05c8 },		//  200,  5
	{ 0x2789, 0x05c9 },		//  201,  5
	{ 0x278A, 0x05ca },		//  202,  5
	{ 0x278B, 0x05cb },		//  203,  5
	{ 0x278C, 0x05cc },		//  204,  5
	{ 0x278D, 0x05cd },		//  205,  5
	{ 0x278E, 0x05ce },		//  206,  5
	{ 0x278F, 0x05cf },		//  207,  5
	{ 0x2790, 0x05d0 },		//  208,  5
	{ 0x2791, 0x05d1 },		//  209,  5
	{ 0x2792, 0x05d2 },		//  210,  5
	{ 0x2793, 0x05d3 },		//  211,  5
	{ 0x2794, 0x05d4 },		//  212,  5
	{ 0x2798, 0x05d8 },		//  216,  5
	{ 0x2799, 0x05d9 },		//  217,  5
	{ 0x279A, 0x05da },		//  218,  5
	{ 0x279B, 0x05db },		//  219,  5
	{ 0x279C, 0x05dc },		//  220,  5
	{ 0x279D, 0x05dd },		//  221,  5
	{ 0x279E, 0x05de },		//  222,  5
	{ 0x279F, 0x05df },		//  223,  5
	{ 0x27A0, 0x05e0 },		//  224,  5
	{ 0x27A1, 0x05e1 },		//  225,  5
	{ 0x27A2, 0x05e2 },		//  226,  5
	{ 0x27A3, 0x05e3 },		//  227,  5
	{ 0x27A4, 0x05e4 },		//  228,  5
	{ 0x27A5, 0x05e5 },		//  229,  5
	{ 0x27A6, 0x05e6 },		//  230,  5
	{ 0x27A7, 0x05e7 },		//  231,  5
	{ 0x27A8, 0x05e8 },		//  232,  5
	{ 0x27A9, 0x05e9 },		//  233,  5
	{ 0x27AA, 0x05ea },		//  234,  5
	{ 0x27AB, 0x05eb },		//  235,  5
	{ 0x27AC, 0x05ec },		//  236,  5
	{ 0x27AD, 0x05ed },		//  237,  5
	{ 0x27AE, 0x05ee },		//  238,  5
	{ 0x27AF, 0x05ef },		//  239,  5
	{ 0x27B1, 0x05f1 },		//  241,  5
	{ 0x27B2, 0x05f2 },		//  242,  5
	{ 0x27B3, 0x05f3 },		//  243,  5
	{ 0x27B4, 0x05f4 },		//  244,  5
	{ 0x27B5, 0x05f5 },		//  245,  5
	{ 0x27B6, 0x05f6 },		//  246,  5
	{ 0x27B7, 0x05f7 },		//  247,  5
	{ 0x27B8, 0x05f8 },		//  248,  5
	{ 0x27B9, 0x05f9 },		//  249,  5
	{ 0x27BA, 0x05fa },		//  250,  5
	{ 0x27BB, 0x05fb },		//  251,  5
	{ 0x27BC, 0x05fc },		//  252,  5
	{ 0x27BD, 0x05fd },		//  253,  5
	{ 0x27BE, 0x05fe },		//  254,  5

	// Range 0xE000 through 0xF8FF is reserved for private use.
	// We cannot try to interpret characters in this range nor
	// assign any default collation or meaning.

	{ 0xFB00, 0x0433 },		//  51 ,  4
	{ 0xFB01, 0x0436 },		//  54 ,  4
	{ 0xFB02, 0x0437 },		//  55 ,  4
	{ 0xFB03, 0x0434 },		//  52 ,  4
	{ 0xFB04, 0x0435 },		//  53 ,  4
	{ 0xFB1E, 0x0930 },		//  48 ,  9
	{ 0xFF61, 0x0b00 },		//   0 , 11
	{ 0xFF62, 0x0b01 },		//   1 , 11
	{ 0xFF63, 0x0b02 },		//   2 , 11
	{ 0xFF64, 0x0b03 },		//   3 , 11
	{ 0xFF65, 0x0b04 },		//   4 , 11
	{ 0xFF66, 0x0b05 },		//   5 , 11
	{ 0xFF67, 0x0b06 },		//   6 , 11
	{ 0xFF68, 0x0b07 },		//   7 , 11
	{ 0xFF69, 0x0b08 },		//   8 , 11
	{ 0xFF6A, 0x0b09 },		//   9 , 11
	{ 0xFF6B, 0x0b0a },		//  10 , 11
	{ 0xFF6C, 0x0b0b },		//  11 , 11
	{ 0xFF6D, 0x0b0c },		//  12 , 11
	{ 0xFF6E, 0x0b0d },		//  13 , 11
	{ 0xFF6F, 0x0b0e },		//  14 , 11
	{ 0xFF70, 0x0b0f },		//  15 , 11
	{ 0xFF71, 0x0b10 },		//  16 , 11
	{ 0xFF72, 0x0b11 },		//  17 , 11
	{ 0xFF73, 0x0b12 },		//  18 , 11
	{ 0xFF74, 0x0b13 },		//  19 , 11
	{ 0xFF75, 0x0b14 },		//  20 , 11
	{ 0xFF76, 0x0b15 },		//  21 , 11
	{ 0xFF77, 0x0b16 },		//  22 , 11
	{ 0xFF78, 0x0b17 },		//  23 , 11
	{ 0xFF79, 0x0b18 },		//  24 , 11
	{ 0xFF7A, 0x0b19 },		//  25 , 11
	{ 0xFF7B, 0x0b1a },		//  26 , 11
	{ 0xFF7C, 0x0b1b },		//  27 , 11
	{ 0xFF7D, 0x0b1c },		//  28 , 11
	{ 0xFF7E, 0x0b1d },		//  29 , 11
	{ 0xFF7F, 0x0b1e },		//  30 , 11
	{ 0xFF80, 0x0b1f },		//  31 , 11
	{ 0xFF81, 0x0b20 },		//  32 , 11
	{ 0xFF82, 0x0b21 },		//  33 , 11
	{ 0xFF83, 0x0b22 },		//  34 , 11
	{ 0xFF84, 0x0b23 },		//  35 , 11
	{ 0xFF85, 0x0b24 },		//  36 , 11
	{ 0xFF86, 0x0b25 },		//  37 , 11
	{ 0xFF87, 0x0b26 },		//  38 , 11
	{ 0xFF88, 0x0b27 },		//  39 , 11
	{ 0xFF89, 0x0b28 },		//  40 , 11
	{ 0xFF8A, 0x0b29 },		//  41 , 11
	{ 0xFF8B, 0x0b2a },		//  42 , 11
	{ 0xFF8C, 0x0b2b },		//  43 , 11
	{ 0xFF8D, 0x0b2c },		//  44 , 11
	{ 0xFF8E, 0x0b2d },		//  45 , 11
	{ 0xFF8F, 0x0b2e },		//  46 , 11
	{ 0xFF90, 0x0b2f },		//  47 , 11
	{ 0xFF91, 0x0b30 },		//  48 , 11
	{ 0xFF92, 0x0b31 },		//  49 , 11
	{ 0xFF93, 0x0b32 },		//  50 , 11
	{ 0xFF94, 0x0b33 },		//  51 , 11
	{ 0xFF95, 0x0b34 },		//  52 , 11
	{ 0xFF96, 0x0b35 },		//  53 , 11
	{ 0xFF97, 0x0b36 },		//  54 , 11
	{ 0xFF98, 0x0b37 },		//  55 , 11
	{ 0xFF99, 0x0b38 },		//  56 , 11
	{ 0xFF9A, 0x0b39 },		//  57 , 11
	{ 0xFF9B, 0x0b3a },		//  58 , 11
	{ 0xFF9C, 0x0b3b },		//  59 , 11
	{ 0xFF9D, 0x0b3c },		//  60 , 11
	{ 0xFF9E, 0x0b3d },		//  61 , 11
	{ 0xFF9F, 0x0b3e }		//  62 , 11
};

/****************************************************************************
Desc:		Encode a string into FLAIM's internal text format
			(SEN-prefixed, null-terminated UTF8).  The string is prefixed with
			a SEN that indicates the number of characters, not including the
			terminating NULL.

			This routine can be called with a NULL input buffer.  If it is
			called in this way, the length of the encoded string will be
			returned in *puiBufLength, but no encoding will actually be
			performed.
****************************************************************************/
RCODE	flmUnicode2Storage(
	const FLMUNICODE *	puzStr,			// UNICODE string to encode
	FLMUINT					uiStrLen,		// 0 = Unknown
	FLMBYTE *				pucBuf,			// Destination buffer
	FLMUINT *				puiBufLength,	// [IN ] Size of pucBuf,
													// [OUT] Amount of pucBuf used
	FLMUINT *				puiCharCount)
{
	RCODE						rc = NE_XFLM_OK;
	FLMBYTE *				pucEncPtr;
	const FLMUNICODE *	puzPtr = NULL;
	FLMUINT					uiMaxLen;
	FLMUINT					uiCharsEncoded = 0;
	FLMUINT					uiEncodedLen = 0;
	FLMUINT					uiTmp;
	FLMUNICODE				uChar;
	FLMBYTE					ucTmpSen[ 5];
	FLMBYTE *				pucTmpSen = &ucTmpSen[ 0];

	if( !pucBuf)
	{
		uiMaxLen = (~(FLMUINT)0);
	}
	else
	{
		uiMaxLen = *puiBufLength;
	}

	// If uiStrLen is 0, determine the number of characters.

	if( !uiStrLen)
	{
		uiStrLen = f_unilen( puzStr);
	}
	else if( puzStr[ uiStrLen] != 0)
	{
		rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
		goto Exit;
	}

	if( puiCharCount)
	{
		*puiCharCount = uiStrLen;
	}

	if( !uiStrLen)
	{
		// Nothing to encode

		*puiBufLength = 0;
		goto Exit;
	}

	pucEncPtr = pucBuf;

	// Encode the number of characters as a SEN.  If pucEncPtr is
	// NULL, the caller is only interested in the length of the encoded
	// string, so a temporary buffer is used to call flmEncodeSEN.

	uiTmp = flmEncodeSEN( uiStrLen, &pucTmpSen);

	if( pucEncPtr)
	{
		if( (uiEncodedLen + uiTmp) >= uiMaxLen)
		{
			rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
			goto Exit;
		}
		
		if( uiTmp == 1)
		{
			*pucEncPtr++ = ucTmpSen[ 0];
		}
		else
		{
			f_memcpy( pucEncPtr, &ucTmpSen[ 0], uiTmp);
			pucEncPtr += uiTmp;
		}
	}
	uiEncodedLen += uiTmp;

	// Encode the string using UTF-8

	puzPtr = puzStr;
	if( uiStrLen)
	{
		while( (uChar = *puzPtr) != 0)
		{
			if( (uiTmp = uiMaxLen - uiEncodedLen) == 0)
			{
				rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
				goto Exit;
			}

			if( uChar <= 127)
			{
				if( pucEncPtr)
				{
					*pucEncPtr++ = (FLMBYTE)uChar;
				}

				uiEncodedLen++;
			}
			else
			{
				if( RC_BAD( rc = flmUni2UTF8( uChar, pucEncPtr, &uiTmp)))
				{
					goto Exit;
				}

				if( pucEncPtr)
				{
					pucEncPtr += uiTmp;
				}

				uiEncodedLen += uiTmp;
			}

			puzPtr++;
			uiCharsEncoded++;
		}

		// Make sure the string length (which may have been provided by
		// the caller) was correct.

		if( uiCharsEncoded != uiStrLen)
		{
			rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
			goto Exit;
		}
	}

	// Terminate the string with a 0 byte

	if( (uiMaxLen - uiEncodedLen) < 1)
	{
		rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
		goto Exit;
	}

	if( pucEncPtr)
	{
		*pucEncPtr++ = 0;
	}
	uiEncodedLen++;

	// Return the length of the encoded string

	*puiBufLength = uiEncodedLen;

Exit:

	return( rc);
}

/****************************************************************************
Desc:		Encode a string into FLAIM's internal text format
			(SEN-prefixed, null-terminated UTF8).  The string is prefixed with
			a SEN that indicates the number of characters, not including the
			terminating NULL.

			This routine can be called with a NULL input buffer.  If it is
			called in this way, the length of the encoded string will be
			returned in *puiBufLength, but no encoding will actually be
			performed.
****************************************************************************/
RCODE	flmNative2Storage(
	char *			pszStr,			// Native string to encode
	FLMUINT			uiStrLen,		// 0 = Unknown
	FLMBYTE *		pucBuf,			// Destination buffer
	FLMUINT *		puiBufLength,	// [IN ] Size of pucBuf,
											// [OUT] Amount of pucBuf used
	FLMUINT *		puiCharCount)
{
	FLMBYTE *		pucEncPtr;
	char *			pszPtr = NULL;
	FLMUINT			uiMaxLen;
	FLMUINT			uiCharsEncoded = 0;
	FLMUINT			uiEncodedLen = 0;
	FLMUINT			uiTmp;
	FLMBYTE			ucTmpSen[ 5];
	FLMBYTE *		pucTmpSen = &ucTmpSen[ 0];
	FLMBOOL			bDirectCopy = FALSE;
	RCODE				rc = NE_XFLM_OK;

	if( !pucBuf)
	{
		uiMaxLen = (~(FLMUINT)0);
	}
	else
	{
		uiMaxLen = *puiBufLength;
	}

	// If uiStrLen is 0, determine the number of characters.

	if( !uiStrLen)
	{
#ifdef FLM_ASCII_PLATFORM
		bDirectCopy = TRUE;
		for( pszPtr = pszStr; *pszPtr; pszPtr++, uiStrLen++)
		{
			if( (FLMBYTE)*pszPtr > 0x7F)
			{
				bDirectCopy = FALSE;
			}
		}
#else
		uiStrLen = f_strlen( pszStr);
#endif
	}
	else if( pszStr[ uiStrLen] != 0)
	{
		rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
		goto Exit;
	}

	if( puiCharCount)
	{
		*puiCharCount = uiStrLen;
	}

	if( !uiStrLen)
	{
		// Nothing to encode

		*puiBufLength = 0;
		goto Exit;
	}

	pucEncPtr = pucBuf;

	// Encode the number of characters as a SEN.  If pucEncPtr is
	// NULL, the caller is only interested in the length of the encoded
	// string, so a temporary buffer is used to call flmEncodeSEN.

	uiTmp = flmEncodeSEN( uiStrLen, &pucTmpSen);
	if( pucEncPtr)
	{
		if( (uiEncodedLen + uiTmp) >= uiMaxLen)
		{
			rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
			goto Exit;
		}
		f_memcpy( pucEncPtr, &ucTmpSen[ 0], uiTmp);
		pucEncPtr += uiTmp;
	}
	uiEncodedLen += uiTmp;

	// Encode the string using UTF-8

	if( uiStrLen)
	{
		if( bDirectCopy)
		{
			// Since all of the characters are ASCII and have
			// values <= 0x7F, the string can be copied directly
			// into the destination buffer buffer.

			if( uiEncodedLen + uiStrLen >= uiMaxLen)
			{
				rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
				goto Exit;
			}

			if( pucEncPtr)
			{
				f_memcpy( pucEncPtr, pszStr, uiStrLen);
				pucEncPtr += uiStrLen;
			}
			uiEncodedLen += uiStrLen;
		}
		else
		{
			pszPtr = pszStr;
			while( *pszPtr)
			{
				if( (uiTmp = uiMaxLen - uiEncodedLen) == 0)
				{
					rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
					goto Exit;
				}

				// Convert the native character to ASCII before
				// mapping it to Unicode.

				if( RC_BAD( rc = flmUni2UTF8( (FLMUNICODE)f_toascii( *pszPtr),
					pucEncPtr, &uiTmp)))
				{
					goto Exit;
				}

				uiEncodedLen += uiTmp;

				if( pucEncPtr)
				{
					pucEncPtr += uiTmp;
				}

				pszPtr++;
				uiCharsEncoded++;
			}

			// Make sure the string length (which may have been provided by
			// the caller) was correct.

			if( uiCharsEncoded != uiStrLen)
			{
				rc = RC_SET_AND_ASSERT( NE_XFLM_INVALID_PARM);
				goto Exit;
			}
		}
	}

	// Terminate the string with a 0 byte

	if( (uiMaxLen - uiEncodedLen) == 0)
	{
		rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
		goto Exit;
	}

	if( pucEncPtr)
	{
		*pucEncPtr++ = 0;
	}
	uiEncodedLen++;

	// Return the length of the encoded string

	*puiBufLength = uiEncodedLen;

Exit:

	return( rc);
}

/****************************************************************************
Desc:		Encode a string into FLAIM's internal text format
			(SEN-prefixed, null-terminated UTF8).  The string is prefixed with
			a SEN that indicates the number of characters, not including the
			terminating NULL.

			This routine can be called with a NULL input buffer.  If it is
			called in this way, the length of the encoded string will be
			returned in *puiBufLength, but no encoding will actually be
			performed.
****************************************************************************/
RCODE	flmUTF8ToStorage(
	const FLMBYTE *	pucUTF8,					// UTF8 string to encode
	FLMUINT				uiBytesInBuffer,		// Maximum bytes to process from source
	FLMBYTE *			pucBuf,					// Destination buffer
	FLMUINT *			puiBufLength)			// [IN ] Size of pucBuf,
														// [OUT] Amount of pucBuf used
{
	RCODE					rc = NE_XFLM_OK;
	FLMBYTE *			pucEncPtr;
	const FLMBYTE *	pucPtr = NULL;
	FLMUINT				uiMaxLen;
	FLMUINT				uiEncodedLen = 0;
	FLMUINT				uiCharCount;
	FLMUINT				uiByteCount;
	FLMUINT				uiTmp;
	FLMUNICODE			uChar;
	FLMBYTE				ucTmpSen[ 5];
	FLMBYTE *			pucTmpSen = &ucTmpSen[ 0];
	const FLMBYTE *	pucEnd = NULL;

	if( !pucBuf)
	{
		uiMaxLen = (~(FLMUINT)0);
	}
	else
	{
		uiMaxLen = *puiBufLength;
	}
	
	if( uiBytesInBuffer)
	{
		pucEnd = &pucUTF8[ uiBytesInBuffer];
	}

	// Determine the number of bytes and characters in the
	// string

	uiCharCount = 0;
	pucPtr = pucUTF8;
	for( ;;)
	{
		if( RC_BAD( rc = flmGetCharFromUTF8Buf( &pucPtr, pucEnd, &uChar)))
		{
			goto Exit;
		}

		if( !uChar)
		{
			break;
		}
		
		uiCharCount++;
	}

	if( !uiCharCount)
	{
		*puiBufLength = 0;
		goto Exit;
	}

	pucEncPtr = pucBuf;

	// Encode the number of characters as a SEN.  If pucEncPtr is
	// NULL, the caller is only interested in the length of the encoded
	// string, so a temporary buffer is used to call flmEncodeSEN.

	uiTmp = flmEncodeSEN( uiCharCount, &pucTmpSen);
	if( pucEncPtr)
	{
		if( (uiEncodedLen + uiTmp) >= uiMaxLen)
		{
			rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
			goto Exit;
		}
		f_memcpy( pucEncPtr, &ucTmpSen[ 0], uiTmp);
		pucEncPtr += uiTmp;
	}
	uiEncodedLen += uiTmp;

	// Copy the UTF8 characters into the destination buffer

	uiByteCount = (FLMUINT)(pucPtr - pucUTF8);
	if( pucEncPtr)
	{
		if( (uiMaxLen - uiEncodedLen) < uiByteCount)
		{
			rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
			goto Exit;
		}
		f_memcpy( pucEncPtr, pucUTF8, uiByteCount);
		pucEncPtr += uiByteCount;
	}
	uiEncodedLen += uiByteCount;

	// Terminate the string with a 0 byte

	if( uiEncodedLen == uiMaxLen)
	{
		rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
		goto Exit;
	}

	if( pucEncPtr)
	{
		*pucEncPtr++ = 0;
	}
	uiEncodedLen++;

	// Return the length of the encoded string

	*puiBufLength = uiEncodedLen;

Exit:

	return( rc);
}

/****************************************************************************
Desc: 	Convert text storage string to Unicode.
Notes:	If puzOutBuf is NULL, only a count is returned
			in puiOutBufLen to indicate the number of bytes needed to
			contain the data.  Two (unicode) bytes must be
			added to this value to account for null termination.
****************************************************************************/
RCODE flmStorage2Unicode(
	FLMUINT				uiType,
	FLMUINT				uiBufLength,
	const FLMBYTE *	pucBuffer,
	FLMUINT *			puiOutBufLen,
			// [IN] Number of bytes available in buffer
			// [OUT] Returns the number of bytes that are needed to
			// represent the data.  The null termination byte(s) are
			// not included in this value.
	void *				pOutBuf)
			// [IN/OUT] Buffer to hold the data.
{
	RCODE					rc = NE_XFLM_OK;
	FLMUNICODE			uChar;
	FLMUINT				uiOffset = 0;
	FLMUINT				uiSenLen;
	FLMUINT				uiNumChars;
	FLMUINT				uiMaxOutChars;
	FLMBYTE				ucTempBuf[ 64];
	FLMUNICODE *		puzOutBuf = NULL;
	FLMBYTE *			pszOutBuf = NULL;
	const FLMBYTE *	pucEnd;
	FLMUINT				uiDecodeCount;

	if( !pucBuffer || !uiBufLength)
	{
		ucTempBuf[ 0] = 0;	// SEN encoding of 0
		ucTempBuf[ 1] = 0;	// String terminator
		pucBuffer = &ucTempBuf[ 0];
		uiBufLength = 2;
	}
	else if( uiType != XFLM_TEXT_TYPE)
	{
		// If the value is a number, convert to text

		if( uiType == XFLM_NUMBER_TYPE)
		{
			FLMUINT	uiTmp;

			uiTmp = sizeof( ucTempBuf);
			if( RC_BAD( rc = flmStorageNum2StorageText( pucBuffer, uiBufLength,
				ucTempBuf, &uiTmp)))
			{
				goto Exit;
			}
			pucBuffer = &ucTempBuf[ 0];
			uiBufLength = uiTmp;
		}
		else
		{
			rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
			goto Exit;
		}
	}

	if( !uiBufLength)
	{
		if( puiOutBufLen)
		{
			if( *puiOutBufLen >= 2)
			{
				*((FLMUNICODE *)pOutBuf) = 0;
			}
			
			*puiOutBufLen = 0;
		}
		goto Exit;
	}

	pucEnd = &pucBuffer[ uiBufLength];

	uiSenLen = flmGetSENLength( *pucBuffer);
	if( pucBuffer + uiSenLen >= pucEnd)
	{
		rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
		goto Exit;
	}

	if( RC_BAD( rc = flmDecodeSEN( &pucBuffer, pucEnd, &uiNumChars)))
	{
		goto Exit;
	}

	// If only a length is needed (number of bytes), we can
	// return that without parsing the string

	if( !pOutBuf)
	{
		uiOffset = uiNumChars;
		goto Exit;
	}

	flmAssert( puiOutBufLen);
	uiMaxOutChars = (*puiOutBufLen) / sizeof( FLMUNICODE);
	puzOutBuf = (FLMUNICODE *)pOutBuf;

	// If we have a zero-length string, jump to exit.

	if( !uiNumChars)
	{
		if( (pucBuffer + 1) != pucEnd || *pucBuffer != 0)
		{
			rc = RC_SET( NE_XFLM_DATA_ERROR);
			goto Exit;
		}

		if( *pucBuffer != 0)
		{
			rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
		}
		else if (!uiMaxOutChars)
		{
			goto Overflow_Error;
		}

		if( puzOutBuf)
		{
			*puzOutBuf = 0;
		}
		else
		{
			*pszOutBuf = 0;
		}
		
		goto Exit;
	}

	// Parse through the string, outputting data to the buffer as we go.

	uChar = 0;
	uiDecodeCount = 0;
	for( ;;)
	{
		// Decode the bytes.

		if( RC_BAD( rc = flmGetCharFromUTF8Buf( &pucBuffer, pucEnd, &uChar)))
		{
			goto Exit;
		}

		if( !uChar)
		{
			break;
		}

		if( uiOffset == uiMaxOutChars)
		{
			goto Overflow_Error;
		}

		if( puzOutBuf)
		{
			puzOutBuf[ uiOffset++] = uChar;
		}
		else
		{
			if ( uChar <= 0xFF)
			{
				uChar = (FLMUNICODE)f_tonative( (FLMBYTE)uChar);
				pszOutBuf[ uiOffset++] = (FLMBYTE)uChar;
			}
			else
			{
				rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
				goto Exit;
			}
		}
		
		uiDecodeCount++;
	}

	if( uChar || uiDecodeCount != uiNumChars)
	{
		rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
		goto Exit;
	}

	// There is room for the 0 terminating character, but we
	// will not increment return length.

	if( uiOffset < uiMaxOutChars)
	{
		if( puzOutBuf)
		{
			puzOutBuf[ uiOffset] = 0;
		}
		else
		{
			pszOutBuf[ uiOffset] = 0;
		}
	}
	else
	{
Overflow_Error:
		flmAssert( uiOffset == uiMaxOutChars);

		// If uiOffset is zero, so is uiMaxOutChars, which means
		// that we can't even put out the zero terminator.

		if (uiOffset)
		{
			uiOffset--;
			if( puzOutBuf)
			{
				puzOutBuf[ uiOffset] = 0;
			}
			else
			{
				pszOutBuf[ uiOffset] = 0;
			}
		}
		rc = RC_SET( NE_XFLM_CONV_DEST_OVERFLOW);
		goto Exit;
	}

Exit:

	if( puiOutBufLen)
	{
		*puiOutBufLen = uiOffset + uiOffset;
	}

	return( rc);
}

/****************************************************************************
Desc:	Converts storage formats to UNICODE
****************************************************************************/
RCODE flmStorage2Unicode(
	FLMUINT				uiType,
	FLMUINT				uiStorageLength,
	const FLMBYTE *	pucStorageBuffer,
	IF_DynaBuf *		pBuffer)
{
	RCODE					rc = NE_XFLM_OK;
	FLMBYTE				ucTempBuf[ 80];
	const FLMBYTE *	pucEnd;
	FLMUINT				uiSenLen;
	FLMUINT				uiNumChars;
	FLMUNICODE *		puzDestBuffer;

	pBuffer->truncateData( 0);
	
	if( uiType != XFLM_TEXT_TYPE)
	{
		// If the value is a number, convert to text

		if( uiType == XFLM_NUMBER_TYPE)
		{
			FLMUINT	uiTmp;

			uiStorageLength = sizeof( ucTempBuf);
			if( RC_BAD( rc = flmStorageNum2StorageText( pucStorageBuffer, 
				uiStorageLength, ucTempBuf, &uiTmp)))
			{
				goto Exit;
			}
			pucStorageBuffer = &ucTempBuf[ 0];
			uiStorageLength = uiTmp;
		}
		else
		{
			rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
			goto Exit;
		}
	}

	pucEnd = &pucStorageBuffer[ uiStorageLength];
	uiSenLen = flmGetSENLength( *pucStorageBuffer);
	
	if( pucStorageBuffer + uiSenLen >= pucEnd)
	{
		rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
		goto Exit;
	}
	
	if( RC_BAD( rc = flmDecodeSEN( &pucStorageBuffer, pucEnd, &uiNumChars)))
	{
		goto Exit;
	}

	if( RC_BAD( rc = pBuffer->allocSpace( 
		(uiNumChars + 1) * sizeof( FLMUNICODE), (void **)&puzDestBuffer)))
	{
		goto Exit;
	}

	// Parse through the string outputting data to the buffer as we go

	for( ;;)
	{
		if( RC_BAD( rc = flmGetCharFromUTF8Buf( 
			&pucStorageBuffer, pucEnd, puzDestBuffer)))
		{
			goto Exit;
		}
		
		if( !(*puzDestBuffer))
		{
			break;
		}

		puzDestBuffer++;
	}
	
Exit:

	return( rc);
}

/****************************************************************************
Desc: 	Converts a storage buffer to UTF-8 (null-terminated) text
****************************************************************************/
RCODE flmStorage2UTF8(
	FLMUINT				uiType,
	FLMUINT				uiBufLength,
	const FLMBYTE *	pucBuffer,
	FLMUINT *			puiOutBufLen,
			// [IN] Number of bytes available in buffer
			// [OUT] Returns the number of bytes that are needed to
			// represent the data.  The null termination byte is not
			// included in this value.
	FLMBYTE *			pucOutBuf)
			// [OUT] Buffer to hold the data.
{
	RCODE					rc = NE_XFLM_OK;
	const FLMBYTE *	pucEnd;
	FLMBYTE				ucTempBuf[ 64];
	FLMUINT				uiSenLen;

	if( !pucBuffer)
	{
		ucTempBuf[ 0] = 0;	// SEN encoding of 0
		ucTempBuf[ 1] = 0;	// String terminator
		pucBuffer = &ucTempBuf[ 0];
		uiBufLength = 2;
	}
	else if( uiType != XFLM_TEXT_TYPE)
	{
		// If the value is a number, convert to text

		if( uiType == XFLM_NUMBER_TYPE)
		{
			FLMUINT	uiTmp;

			uiTmp = sizeof( ucTempBuf);
			if( RC_BAD( rc = flmStorageNum2StorageText( pucBuffer, uiBufLength,
				ucTempBuf, &uiTmp)))
			{
				goto Exit;
			}
			pucBuffer = &ucTempBuf[ 0];
			uiBufLength = uiTmp;
		}
		else
		{
			rc = RC_SET( NE_XFLM_CONV_ILLEGAL);
			goto Exit;
		}
	}

	if( !uiBufLength)
	{
		if( *puiOutBufLen && pucOutBuf)
		{
			*pucOutBuf = 0;
		}
		*puiOutBufLen = 0;
		goto Exit;
	}

	pucEnd = &pucBuffer[ uiBufLength];

	uiSenLen = flmGetSENLength( *pucBuffer);
	if( pucBuffer + uiSenLen >= pucEnd)
	{
		rc = RC_SET_AND_ASSERT( NE_XFLM_DATA_ERROR);
		goto Exit;
	}

	if( RC_BAD( rc = flmDecodeSEN( &pucBuffer, pucEnd, NULL)))
	{
		goto Exit;
	}

	if( pucOutBuf)
	{
		if( *puiOutBufLen >= uiBufLength - uiSenLen)
		{
			f_memcpy( pucOutBuf, pucBuffer, uiBufLength - uiSenLen);
		}
	}

	*puiOutBufLen = (uiBufLength - uiSenLen) - 1;

Exit:

	return( rc);
}

/****************************************************************************
Desc:	Reads and returns the value of the SEN indicating the number of
		characters encoded into the storage (UTF-8) string
****************************************************************************/
RCODE flmGetCharCountFromStorageBuf(
	const FLMBYTE **	ppucBuf,
	FLMUINT				uiBufSize,
	FLMUINT *			puiNumChars,
	FLMUINT *			puiSenLen)
{
	RCODE			rc = NE_XFLM_OK;
	FLMUINT		uiSenLen;
	FLMUINT		uiNumChars;

	if( !uiBufSize)
	{
		if( puiNumChars)
		{
			*puiNumChars = 0;
		}

		if( puiSenLen)
		{
			*puiSenLen = 0;
		}
		goto Exit;
	}

	if( (uiSenLen = flmGetSENLength( (*ppucBuf)[ 0])) >= uiBufSize)
	{
		rc = RC_SET( NE_XFLM_DATA_ERROR);
		goto Exit;
	}

	if( RC_BAD( rc = flmDecodeSEN( ppucBuf, *ppucBuf + uiSenLen, &uiNumChars)))
	{
		goto Exit;
	}

	if( puiNumChars)
	{
		*puiNumChars = uiNumChars;
	}

	if( puiSenLen)
	{
		*puiSenLen = uiSenLen;
	}

Exit:

	return( rc);
}

/****************************************************************************
Desc:		This routine converts an internal number to internal (ASCII) text.
Notes:	If the buffer pointer is NULL, the routine just determines how
			much buffer space is needed to store the number in a text string.
****************************************************************************/
RCODE flmStorageNum2StorageText(
	const FLMBYTE *	pucNum,
	FLMUINT				uiNumLen,
	FLMBYTE *			pucBuffer,
	FLMUINT *			puiBufLen)
{
	RCODE			rc = NE_XFLM_OK;
	FLMUINT64	ui64Num;
	FLMINT64		i64Num;
	FLMUINT		uiOffset = 0;
	FLMBOOL		bNeg = FALSE;
	char			szTmpBuf[ 64];

	if( RC_BAD( rc = flmStorage2Number64( XFLM_NUMBER_TYPE, uiNumLen,
		pucNum, &ui64Num, NULL)))
	{
		if( rc == NE_XFLM_CONV_NUM_UNDERFLOW)
		{
			if( RC_BAD( rc = flmStorage2Number64( XFLM_NUMBER_TYPE, uiNumLen,
				pucNum, NULL, &i64Num)))
			{
				goto Exit;
			}

			ui64Num = (FLMUINT64)-i64Num;
			bNeg = TRUE;
		}
		else
		{
			goto Exit;
		}
	}

	if( bNeg)
	{
		szTmpBuf[ uiOffset++] = '-';
	}

	uiOffset += f_sprintf( &szTmpBuf[ uiOffset], "%I64u", ui64Num);

	if( RC_BAD( rc = flmNative2Storage( szTmpBuf, uiOffset,
									pucBuffer, puiBufLen, NULL)))
	{
		goto Exit;
	}

Exit:

	return( rc);
}

/****************************************************************************
Desc:		Called by FlmStartup, this routine initializes the Unicode to
			WP and WP to Unicode mapping tables.
****************************************************************************/
RCODE F_DbSystem::initCharMappingTables( void)
{
	FLMUINT16 *		puStaticPtr;
	FLMUINT			uiLoop;
	FLMUINT			uiEntries;
	FLMUINT			uiOffset;
	RCODE				rc = NE_XFLM_OK;

	if( gv_pUnicodeToWP60 || gv_pWP60ToUnicode)
	{
		rc = RC_SET_AND_ASSERT( NE_XFLM_FAILURE);
		goto Exit;
	}

	gv_uiMinUniChar = 0;
	gv_uiMaxUniChar = 0;

	gv_uiMinWPChar = 0;
	gv_uiMaxWPChar = 0;

	// Make an initial pass over the table to determine
	// what our allocation sizes will need to be.

	for( uiLoop = 0, puStaticPtr = (FLMUINT16 *)WP_UTOWP60;
		uiLoop < UTOWP60_ENTRIES;
		uiLoop++, puStaticPtr += 2)
	{
		// Unicode

		if( (FLMUINT)puStaticPtr[ 0] < gv_uiMinUniChar ||
			!gv_uiMinUniChar)
		{
			flmAssert( puStaticPtr[ 0] != 0);
			gv_uiMinUniChar = (FLMUINT)puStaticPtr[ 0];
		}

		if( (FLMUINT)puStaticPtr[ 0] > gv_uiMaxUniChar)
		{
			gv_uiMaxUniChar = (FLMUINT)puStaticPtr[ 0];
		}

		// WordPerfect

		if( (FLMUINT)puStaticPtr[ 1] < gv_uiMinWPChar ||
			!gv_uiMinWPChar)
		{
			flmAssert( puStaticPtr[ 1] != 0);
			gv_uiMinWPChar = (FLMUINT)puStaticPtr[ 1];
		}

		if( (FLMUINT)puStaticPtr[ 1] > gv_uiMaxWPChar)
		{
			gv_uiMaxWPChar = (FLMUINT)puStaticPtr[ 1];
		}
	}

	// Allocate the Unicode table

	uiEntries = (gv_uiMaxUniChar - gv_uiMinUniChar) + 1;
	if (RC_BAD( rc = f_calloc( uiEntries * sizeof( FLMUINT16),
		&gv_pUnicodeToWP60)))
	{
		goto Exit;
	}

	// Populate the Unicode table

	for( uiLoop = 0, puStaticPtr = (FLMUINT16 *)WP_UTOWP60;
		uiLoop < UTOWP60_ENTRIES; uiLoop++, puStaticPtr += 2)
	{
		uiOffset = (FLMUINT)puStaticPtr[ 0] - gv_uiMinUniChar;

		flmAssert( gv_pUnicodeToWP60[ uiOffset] == 0);
		gv_pUnicodeToWP60[ uiOffset] = puStaticPtr[ 1];
	}

	// Allocate the WordPerfect table

	uiEntries = (gv_uiMaxWPChar - gv_uiMinWPChar) + 1;
	if (RC_BAD( rc = f_calloc( uiEntries * sizeof( FLMUINT16),
		&gv_pWP60ToUnicode)))
	{
		goto Exit;
	}

	// Populate the WordPerfect table

	for( uiLoop = 0, puStaticPtr = (FLMUINT16 *)WP_UTOWP60;
		uiLoop < UTOWP60_ENTRIES; uiLoop++, puStaticPtr += 2)
	{
		uiOffset = (FLMUINT)puStaticPtr[ 1] - gv_uiMinWPChar;

		flmAssert( gv_pWP60ToUnicode[ uiOffset] == 0);
		gv_pWP60ToUnicode[ uiOffset] = puStaticPtr[ 0];
	}

Exit:

	if( RC_BAD( rc))
	{
		if( gv_pUnicodeToWP60)
		{
			f_free( &gv_pUnicodeToWP60);
		}

		if( gv_pWP60ToUnicode)
		{
			f_free( &gv_pWP60ToUnicode);
		}

		gv_uiMinUniChar = 0;
		gv_uiMaxUniChar = 0;

		gv_uiMinWPChar = 0;
		gv_uiMaxWPChar = 0;
	}

	return( rc);
}

/****************************************************************************
Desc:		Called by FlmShutdown, this routine frees the Unicode to WP and
			WP to Unicode mapping tables.
****************************************************************************/
void F_DbSystem::freeCharMappingTables( void)
{
	if( gv_pUnicodeToWP60)
	{
		f_free( &gv_pUnicodeToWP60);
	}

	if( gv_pWP60ToUnicode)
	{
		f_free( &gv_pWP60ToUnicode);
	}

	gv_uiMinUniChar = 0;
	gv_uiMaxUniChar = 0;

	gv_uiMinWPChar = 0;
	gv_uiMaxWPChar = 0;
}