LCOV - code coverage report
Current view: directory - extensions/spellcheck/hunspell/src - csutil.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 571 323 56.6 %
Date: 2012-06-02 Functions: 43 27 62.8 %

       1                 : /******* BEGIN LICENSE BLOCK *******
       2                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
       3                 :  * 
       4                 :  * The contents of this file are subject to the Mozilla Public License Version
       5                 :  * 1.1 (the "License"); you may not use this file except in compliance with
       6                 :  * the License. You may obtain a copy of the License at
       7                 :  * http://www.mozilla.org/MPL/
       8                 :  * 
       9                 :  * Software distributed under the License is distributed on an "AS IS" basis,
      10                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
      11                 :  * for the specific language governing rights and limitations under the
      12                 :  * License.
      13                 :  * 
      14                 :  * The Initial Developers of the Original Code are Kevin Hendricks (MySpell)
      15                 :  * and László Németh (Hunspell). Portions created by the Initial Developers
      16                 :  * are Copyright (C) 2002-2005 the Initial Developers. All Rights Reserved.
      17                 :  * 
      18                 :  * Contributor(s): Kevin Hendricks (kevin.hendricks@sympatico.ca)
      19                 :  *                 David Einstein (deinst@world.std.com)
      20                 :  *                 László Németh (nemethl@gyorsposta.hu)
      21                 :  *                 L. David Baron (dbaron@dbaron.org)
      22                 :  *                 Caolan McNamara (caolanm@redhat.com)
      23                 :  *                 Davide Prina
      24                 :  *                 Giuseppe Modugno
      25                 :  *                 Gianluca Turconi
      26                 :  *                 Simon Brouwer
      27                 :  *                 Noll Janos
      28                 :  *                 Biro Arpad
      29                 :  *                 Goldman Eleonora
      30                 :  *                 Sarlos Tamas
      31                 :  *                 Bencsath Boldizsar
      32                 :  *                 Halacsy Peter
      33                 :  *                 Dvornik Laszlo
      34                 :  *                 Gefferth Andras
      35                 :  *                 Nagy Viktor
      36                 :  *                 Varga Daniel
      37                 :  *                 Chris Halls
      38                 :  *                 Rene Engelhard
      39                 :  *                 Bram Moolenaar
      40                 :  *                 Dafydd Jones
      41                 :  *                 Harri Pitkanen
      42                 :  *                 Andras Timar
      43                 :  *                 Tor Lillqvist
      44                 :  * 
      45                 :  * Alternatively, the contents of this file may be used under the terms of
      46                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
      47                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      48                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      49                 :  * of those above. If you wish to allow use of your version of this file only
      50                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      51                 :  * use your version of this file under the terms of the MPL, indicate your
      52                 :  * decision by deleting the provisions above and replace them with the notice
      53                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      54                 :  * the provisions above, a recipient may use your version of this file under
      55                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      56                 :  *
      57                 :  ******* END LICENSE BLOCK *******/
      58                 : 
      59                 : #include <stdlib.h> 
      60                 : #include <string.h>
      61                 : #include <stdio.h> 
      62                 : #include <ctype.h>
      63                 : 
      64                 : #include "csutil.hxx"
      65                 : #include "atypes.hxx"
      66                 : #include "langnum.hxx"
      67                 : 
      68                 : // Unicode character encoding information
      69                 : struct unicode_info {
      70                 :   unsigned short c;
      71                 :   unsigned short cupper;
      72                 :   unsigned short clower;
      73                 : };
      74                 : 
      75                 : #ifdef OPENOFFICEORG
      76                 : #  include <unicode/uchar.h>
      77                 : #else
      78                 : #  ifndef MOZILLA_CLIENT
      79                 : #    include "utf_info.cxx"
      80                 : #    define UTF_LST_LEN (sizeof(utf_lst) / (sizeof(unicode_info)))
      81                 : #  endif
      82                 : #endif
      83                 : 
      84                 : #ifdef MOZILLA_CLIENT
      85                 : #include "nsCOMPtr.h"
      86                 : #include "nsServiceManagerUtils.h"
      87                 : #include "nsIUnicodeEncoder.h"
      88                 : #include "nsIUnicodeDecoder.h"
      89                 : #include "nsUnicharUtils.h"
      90                 : #include "nsICharsetConverterManager.h"
      91                 : 
      92                 : static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
      93                 : #endif
      94                 : 
      95                 : struct unicode_info2 {
      96                 :   char cletter;
      97                 :   unsigned short cupper;
      98                 :   unsigned short clower;
      99                 : };
     100                 : 
     101                 : static struct unicode_info2 * utf_tbl = NULL;
     102                 : static int utf_tbl_count = 0; // utf_tbl can be used by multiple Hunspell instances
     103                 : 
     104                 : /* only UTF-16 (BMP) implementation */
     105              86 : char * u16_u8(char * dest, int size, const w_char * src, int srclen) {
     106              86 :     signed char * u8 = (signed char *)dest;
     107              86 :     signed char * u8_max = (signed char *)(u8 + size);
     108              86 :     const w_char * u2 = src;
     109              86 :     const w_char * u2_max = src + srclen;
     110             779 :     while ((u2 < u2_max) && (u8 < u8_max)) {
     111             607 :         if (u2->h) { // > 0xFF
     112                 :             // XXX 4-byte haven't implemented yet.
     113              80 :             if (u2->h >= 0x08) {   // >= 0x800 (3-byte UTF-8 character)
     114              28 :                 *u8 = 0xe0 + (u2->h >> 4);
     115              28 :                 u8++;
     116              28 :                 if (u8 < u8_max) {
     117              28 :                     *u8 = 0x80 + ((u2->h & 0xf) << 2) + (u2->l >> 6);
     118              28 :                     u8++;
     119              28 :                     if (u8 < u8_max) {
     120              28 :                         *u8 = 0x80 + (u2->l & 0x3f);
     121              28 :                         u8++;
     122                 :                     }
     123                 :                 }
     124                 :             } else { // < 0x800 (2-byte UTF-8 character)
     125              52 :                 *u8 = 0xc0 + (u2->h << 2) + (u2->l >> 6);
     126              52 :                 u8++;
     127              52 :                 if (u8 < u8_max) {
     128              52 :                     *u8 = 0x80 + (u2->l & 0x3f);
     129              52 :                     u8++;
     130                 :                 }
     131                 :             }
     132                 :         } else { // <= 0xFF
     133             527 :             if (u2->l & 0x80) { // >0x80 (2-byte UTF-8 character)
     134              21 :                 *u8 = 0xc0 + (u2->l >> 6);
     135              21 :                 u8++;
     136              21 :                 if (u8 < u8_max) {
     137              21 :                     *u8 = 0x80 + (u2->l & 0x3f);
     138              21 :                     u8++;
     139                 :                 }
     140                 :             } else { // < 0x80 (1-byte UTF-8 character)
     141             506 :                 *u8 = u2->l;
     142             506 :                 u8++;
     143                 :             }
     144                 :         }
     145             607 :         u2++;
     146                 :     }
     147              86 :     *u8 = '\0';
     148              86 :     return dest;
     149                 : }
     150                 : 
     151                 : 
     152                 : /* only UTF-16 (BMP) implementation */
     153             467 : int u8_u16(w_char * dest, int size, const char * src) {
     154             467 :     const signed char * u8 = (const signed char *)src;
     155             467 :     w_char * u2 = dest;
     156             467 :     w_char * u2_max = u2 + size;
     157                 :     
     158            4083 :     while ((u2 < u2_max) && *u8) {
     159            3158 :     switch ((*u8) & 0xf0) {
     160                 :         case 0x00:
     161                 :         case 0x10:
     162                 :         case 0x20:
     163                 :         case 0x30:
     164                 :         case 0x40:
     165                 :         case 0x50:
     166                 :         case 0x60:
     167                 :         case 0x70: {
     168            2580 :             u2->h = 0;
     169            2580 :             u2->l = *u8;
     170            2580 :             break;
     171                 :         }
     172                 :         case 0x80:
     173                 :         case 0x90:
     174                 :         case 0xa0:
     175                 :         case 0xb0: {
     176               0 :             HUNSPELL_WARNING(stderr, "UTF-8 encoding error. Unexpected continuation bytes in %ld. character position\n%s\n", static_cast<long>(u8 - (signed char *)src), src);    
     177               0 :             u2->h = 0xff;
     178               0 :             u2->l = 0xfd;
     179               0 :             break;
     180                 :         }
     181                 :         case 0xc0:
     182                 :         case 0xd0: {    // 2-byte UTF-8 codes
     183             487 :             if ((*(u8+1) & 0xc0) == 0x80) {
     184             487 :                 u2->h = (*u8 & 0x1f) >> 2;
     185             487 :                 u2->l = (*u8 << 6) + (*(u8+1) & 0x3f);
     186             487 :                 u8++;
     187                 :             } else {
     188               0 :                 HUNSPELL_WARNING(stderr, "UTF-8 encoding error. Missing continuation byte in %ld. character position:\n%s\n", static_cast<long>(u8 - (signed char *)src), src);
     189               0 :                 u2->h = 0xff;
     190               0 :                 u2->l = 0xfd;
     191                 :             }
     192             487 :             break;
     193                 :         }
     194                 :         case 0xe0: {    // 3-byte UTF-8 codes
     195              82 :             if ((*(u8+1) & 0xc0) == 0x80) {
     196              82 :                 u2->h = ((*u8 & 0x0f) << 4) + ((*(u8+1) & 0x3f) >> 2);
     197              82 :                 u8++;
     198              82 :                 if ((*(u8+1) & 0xc0) == 0x80) {
     199              82 :                     u2->l = (*u8 << 6) + (*(u8+1) & 0x3f);
     200              82 :                     u8++;
     201                 :                 } else {
     202               0 :                     HUNSPELL_WARNING(stderr, "UTF-8 encoding error. Missing continuation byte in %ld. character position:\n%s\n", static_cast<long>(u8 - (signed char *)src), src);
     203               0 :                     u2->h = 0xff;
     204               0 :                     u2->l = 0xfd;
     205                 :                 }
     206                 :             } else {
     207               0 :                 HUNSPELL_WARNING(stderr, "UTF-8 encoding error. Missing continuation byte in %ld. character position:\n%s\n", static_cast<long>(u8 - (signed char *)src), src);
     208               0 :                 u2->h = 0xff;
     209               0 :                 u2->l = 0xfd;
     210                 :             }
     211              82 :             break;
     212                 :         }
     213                 :         case 0xf0: {    // 4 or more byte UTF-8 codes
     214               9 :             HUNSPELL_WARNING(stderr, "This UTF-8 encoding can't convert to UTF-16:\n%s\n", src);
     215               9 :             u2->h = 0xff;
     216               9 :             u2->l = 0xfd;
     217               9 :             return -1;
     218                 :         }
     219                 :     }
     220            3149 :     u8++;
     221            3149 :     u2++;
     222                 :     }
     223             458 :     return (int)(u2 - dest);
     224                 : }
     225                 : 
     226            2208 : void flag_qsort(unsigned short flags[], int begin, int end) {
     227                 :     unsigned short reg;
     228            2208 :     if (end > begin) {
     229             885 :         unsigned short pivot = flags[begin];
     230             885 :         int l = begin + 1;
     231             885 :         int r = end;
     232            2489 :         while(l < r) {
     233             719 :             if (flags[l] <= pivot) {
     234             323 :                 l++;
     235                 :             } else {
     236             396 :              r--;
     237             396 :              reg = flags[l];
     238             396 :              flags[l] = flags[r];
     239             396 :              flags[r] = reg;
     240                 :           }
     241                 :        }
     242             885 :        l--;
     243             885 :        reg = flags[begin];
     244             885 :        flags[begin] = flags[l];
     245             885 :        flags[l] = reg;
     246                 : 
     247             885 :        flag_qsort(flags, begin, l);
     248             885 :        flag_qsort(flags, r, end);
     249                 :     }
     250            2208 :  }
     251                 : 
     252           37660 : int flag_bsearch(unsigned short flags[], unsigned short flag, int length) {
     253                 :    int mid;
     254           37660 :    int left = 0;
     255           37660 :    int right = length - 1;
     256          132314 :    while (left <= right) {
     257           74907 :       mid = (left + right) / 2;
     258           74907 :       if (flags[mid] == flag) return 1;
     259           56994 :       if (flag < flags[mid]) right = mid - 1;
     260           28444 :       else left = mid + 1;
     261                 :    }
     262           19747 :    return 0;
     263                 : }
     264                 : 
     265                 :  // strip strings into token based on single char delimiter
     266                 :  // acts like strsep() but only uses a delim char and not
     267                 :  // a delim string
     268                 :  // default delimiter: white space characters
     269                 :  
     270           10087 :  char * mystrsep(char ** stringp, const char delim)
     271                 :  {
     272           10087 :    char * mp = *stringp;
     273           10087 :    if (*mp != '\0') {
     274                 :       char * dp;
     275            8729 :       if (delim) {
     276              14 :         dp = strchr(mp, delim);
     277                 :       } else {
     278                 :         // don't use isspace() here, the string can be in some random charset
     279                 :         // that's way different than the locale's
     280            8715 :         for (dp = mp; (*dp && *dp != ' ' && *dp != '\t'); dp++);
     281            8715 :         if (!*dp) dp = NULL;
     282                 :       }
     283            8729 :       if (dp) {
     284            7388 :          *stringp = dp+1;
     285            7388 :          *dp = '\0';
     286                 :       } else {
     287            1341 :          *stringp = mp + strlen(mp);
     288                 :       }
     289            8729 :       return mp;
     290                 :    }
     291            1358 :    return NULL;
     292                 :  }
     293                 : 
     294                 :  // replaces strdup with ansi version
     295            3408 :  char * mystrdup(const char * s)
     296                 :  {
     297            3408 :    char * d = NULL;
     298            3408 :    if (s) {
     299            3408 :       size_t sl = strlen(s)+1;
     300            3408 :       d = (char *) malloc(sl);
     301            3408 :       if (d) {
     302            3408 :          memcpy(d,s,sl);
     303                 :       } else {
     304               0 :          HUNSPELL_WARNING(stderr, "Can't allocate memory.\n");
     305                 :       }
     306                 :    }
     307            3408 :    return d;
     308                 :  }
     309                 : 
     310                 :  // strcat for limited length destination string
     311               0 :  char * mystrcat(char * dest, const char * st, int max) {
     312                 :    int len;
     313                 :    int len2;
     314               0 :    if (dest == NULL || st == NULL) return dest;
     315               0 :    len = strlen(dest);
     316               0 :    len2 = strlen(st);
     317               0 :    if (len + len2 + 1 > max) return dest;
     318               0 :    strcpy(dest + len, st);
     319               0 :    return dest;
     320                 :  }
     321                 : 
     322                 :  // remove cross-platform text line end characters
     323            3514 :  void mychomp(char * s)
     324                 :  {
     325            3514 :    size_t k = strlen(s);
     326            3514 :    if ((k > 0) && ((*(s+k-1)=='\r') || (*(s+k-1)=='\n'))) *(s+k-1) = '\0';
     327            3514 :    if ((k > 1) && (*(s+k-2) == '\r')) *(s+k-2) = '\0';
     328            3514 :  }
     329                 :  
     330                 :  
     331                 :  //  does an ansi strdup of the reverse of a string
     332             283 :  char * myrevstrdup(const char * s)
     333                 :  {
     334             283 :      char * d = NULL;
     335             283 :      if (s) {
     336             283 :         size_t sl = strlen(s);
     337             283 :         d = (char *) malloc(sl+1);
     338             283 :         if (d) {
     339             283 :           const char * p = s + sl - 1;
     340             283 :           char * q = d;
     341             283 :           while (p >= s) *q++ = *p--;
     342             283 :           *q = '\0';
     343                 :         } else {
     344               0 :           HUNSPELL_WARNING(stderr, "Can't allocate memory.\n");
     345                 :         }
     346                 :      }
     347             283 :      return d;
     348                 :  }
     349                 : 
     350                 : // break text to lines
     351                 : // return number of lines
     352               0 : int line_tok(const char * text, char *** lines, char breakchar) {
     353               0 :     int linenum = 0;
     354               0 :     if (!text) {
     355               0 :         return linenum;
     356                 :     }
     357               0 :     char * dup = mystrdup(text);
     358               0 :     char * p = strchr(dup, breakchar);
     359               0 :     while (p) {
     360               0 :         linenum++;
     361               0 :         *p = '\0';
     362               0 :         p++;
     363               0 :         p = strchr(p, breakchar);
     364                 :     }
     365               0 :     linenum++;
     366               0 :     *lines = (char **) malloc(linenum * sizeof(char *));
     367               0 :     if (!(*lines)) {
     368               0 :         free(dup);
     369               0 :         return 0;
     370                 :     }
     371                 : 
     372               0 :     p = dup;
     373               0 :     int l = 0;
     374               0 :     for (int i = 0; i < linenum; i++) {
     375               0 :         if (*p != '\0') {
     376               0 :             (*lines)[l] = mystrdup(p);
     377               0 :             if (!(*lines)[l]) {
     378               0 :                 for (i = 0; i < l; i++) free((*lines)[i]);
     379               0 :                 free(dup);
     380               0 :                 return 0;
     381                 :             }
     382               0 :             l++;
     383                 :         }
     384               0 :         p += strlen(p) + 1;
     385                 :     }
     386               0 :     free(dup);
     387               0 :     if (!l) free(*lines);
     388               0 :     return l;
     389                 : }
     390                 : 
     391                 : // uniq line in place
     392               0 : char * line_uniq(char * text, char breakchar) {
     393                 :     char ** lines;
     394               0 :     int linenum = line_tok(text, &lines, breakchar);
     395                 :     int i;
     396               0 :     strcpy(text, lines[0]);
     397               0 :     for ( i = 1; i < linenum; i++ ) {
     398               0 :         int dup = 0;
     399               0 :         for (int j = 0; j < i; j++) {
     400               0 :             if (strcmp(lines[i], lines[j]) == 0) dup = 1;
     401                 :         }
     402               0 :         if (!dup) {
     403               0 :             if ((i > 1) || (*(lines[0]) != '\0')) {
     404               0 :                 sprintf(text + strlen(text), "%c", breakchar);
     405                 :             }
     406               0 :             strcat(text, lines[i]);
     407                 :         }
     408                 :     }
     409               0 :     for ( i = 0; i < linenum; i++ ) {
     410               0 :         if (lines[i]) free(lines[i]);
     411                 :     }
     412               0 :     if (lines) free(lines);
     413               0 :     return text;
     414                 : }
     415                 : 
     416                 : // uniq and boundary for compound analysis: "1\n\2\n\1" -> " ( \1 | \2 ) "
     417               0 : char * line_uniq_app(char ** text, char breakchar) {
     418               0 :     if (!strchr(*text, breakchar)) {
     419               0 :         return *text;
     420                 :     }
     421                 :     
     422                 :     char ** lines;
     423                 :     int i;
     424               0 :     int linenum = line_tok(*text, &lines, breakchar);
     425               0 :     int dup = 0;
     426               0 :     for (i = 0; i < linenum; i++) {
     427               0 :         for (int j = 0; j < (i - 1); j++) {
     428               0 :             if (strcmp(lines[i], lines[j]) == 0) {
     429               0 :                 *(lines[i]) = '\0';
     430               0 :                 dup++;
     431               0 :                 break;
     432                 :             }
     433                 :         }
     434                 :     }
     435               0 :     if ((linenum - dup) == 1) {
     436               0 :         strcpy(*text, lines[0]);
     437               0 :         freelist(&lines, linenum);
     438               0 :         return *text;
     439                 :     }
     440               0 :     char * newtext = (char *) malloc(strlen(*text) + 2 * linenum + 3 + 1);
     441               0 :     if (newtext) {
     442               0 :         free(*text);
     443               0 :         *text = newtext;
     444                 :     } else {
     445               0 :         freelist(&lines, linenum);
     446               0 :         return *text;
     447                 :     }    
     448               0 :     strcpy(*text," ( ");
     449               0 :     for (i = 0; i < linenum; i++) if (*(lines[i])) {
     450               0 :         sprintf(*text + strlen(*text), "%s%s", lines[i], " | ");
     451                 :     }
     452               0 :     (*text)[strlen(*text) - 2] = ')'; // " ) "
     453               0 :     freelist(&lines, linenum);
     454               0 :     return *text;
     455                 : }
     456                 : 
     457                 :  // append s to ends of every lines in text
     458               0 :  void strlinecat(char * dest, const char * s)
     459                 :  {
     460               0 :     char * dup = mystrdup(dest);
     461               0 :     char * source = dup;
     462               0 :     int len = strlen(s);
     463               0 :     if (dup) {
     464               0 :         while (*source) {
     465               0 :             if (*source == '\n') {
     466               0 :                 strncpy(dest, s, len);
     467               0 :                 dest += len;
     468                 :             }
     469               0 :             *dest = *source;
     470               0 :             source++; dest++;
     471                 :         }
     472               0 :         strcpy(dest, s);
     473               0 :         free(dup);
     474                 :     }
     475               0 :  }
     476                 : 
     477                 : // change \n to char c
     478               0 : char * tr(char * text, char oldc, char newc) {
     479                 :     char * p;
     480               0 :     for (p = text; *p; p++) if (*p == oldc) *p = newc;
     481               0 :     return text;
     482                 : }
     483                 : 
     484                 : // morphcmp(): compare MORPH_DERI_SFX, MORPH_INFL_SFX and MORPH_TERM_SFX fields
     485                 : // in the first line of the inputs
     486                 : // return 0, if inputs equal
     487                 : // return 1, if inputs may equal with a secondary suffix
     488                 : // otherwise return -1
     489               0 : int morphcmp(const char * s, const char * t)
     490                 : {
     491               0 :     int se = 0;
     492               0 :     int te = 0;
     493                 :     const char * sl;
     494                 :     const char * tl;    
     495                 :     const char * olds;
     496                 :     const char * oldt;
     497               0 :     if (!s || !t) return 1;
     498               0 :     olds = s;
     499               0 :     sl = strchr(s, '\n');
     500               0 :     s = strstr(s, MORPH_DERI_SFX);
     501               0 :     if (!s || (sl && sl < s)) s = strstr(olds, MORPH_INFL_SFX);
     502               0 :     if (!s || (sl && sl < s)) {
     503               0 :         s= strstr(olds, MORPH_TERM_SFX);
     504               0 :         olds = NULL;
     505                 :     }
     506               0 :     oldt = t;
     507               0 :     tl = strchr(t, '\n');
     508               0 :     t = strstr(t, MORPH_DERI_SFX);
     509               0 :     if (!t || (tl && tl < t)) t = strstr(oldt, MORPH_INFL_SFX);
     510               0 :     if (!t || (tl && tl < t)) {
     511               0 :         t = strstr(oldt, MORPH_TERM_SFX);
     512               0 :         oldt = NULL;
     513                 :     }
     514               0 :     while (s && t && (!sl || sl > s) && (!tl || tl > t)) {
     515               0 :         s += MORPH_TAG_LEN;
     516               0 :         t += MORPH_TAG_LEN;
     517               0 :         se = 0;
     518               0 :         te = 0;
     519               0 :         while ((*s == *t) && !se && !te) {
     520               0 :             s++;
     521               0 :             t++;
     522               0 :             switch(*s) {
     523                 :                 case ' ':
     524                 :                 case '\n':
     525                 :                 case '\t':
     526               0 :                 case '\0': se = 1;
     527                 :             }
     528               0 :             switch(*t) {
     529                 :                 case ' ':
     530                 :                 case '\n':
     531                 :                 case '\t':
     532               0 :                 case '\0': te = 1;
     533                 :             }
     534                 :         }
     535               0 :         if (!se || !te) {
     536                 :             // not terminal suffix difference
     537               0 :             if (olds) return -1;
     538               0 :             return 1;
     539                 :         }
     540               0 :         olds = s;
     541               0 :         s = strstr(s, MORPH_DERI_SFX);
     542               0 :         if (!s || (sl && sl < s)) s = strstr(olds, MORPH_INFL_SFX);
     543               0 :         if (!s || (sl && sl < s)) {
     544               0 :             s = strstr(olds, MORPH_TERM_SFX);
     545               0 :             olds = NULL;
     546                 :         }
     547               0 :         oldt = t;
     548               0 :         t = strstr(t, MORPH_DERI_SFX);
     549               0 :         if (!t || (tl && tl < t)) t = strstr(oldt, MORPH_INFL_SFX);
     550               0 :         if (!t || (tl && tl < t)) {
     551               0 :             t = strstr(oldt, MORPH_TERM_SFX);
     552               0 :             oldt = NULL;
     553                 :         }
     554                 :     }
     555               0 :     if (!s && !t && se && te) return 0;
     556               0 :     return 1;
     557                 : }
     558                 : 
     559               0 : int get_sfxcount(const char * morph)
     560                 : {
     561               0 :     if (!morph || !*morph) return 0;
     562               0 :     int n = 0;
     563               0 :     const char * old = morph;
     564               0 :     morph = strstr(morph, MORPH_DERI_SFX);
     565               0 :     if (!morph) morph = strstr(old, MORPH_INFL_SFX);
     566               0 :     if (!morph) morph = strstr(old, MORPH_TERM_SFX);
     567               0 :     while (morph) {
     568               0 :         n++;
     569               0 :         old = morph;
     570               0 :         morph = strstr(morph + 1, MORPH_DERI_SFX);
     571               0 :         if (!morph) morph = strstr(old + 1, MORPH_INFL_SFX);
     572               0 :         if (!morph) morph = strstr(old + 1, MORPH_TERM_SFX);
     573                 :     }
     574               0 :     return n;
     575                 : }
     576                 : 
     577                 : 
     578               0 : int fieldlen(const char * r)
     579                 : {
     580               0 :     int n = 0;
     581               0 :     while (r && *r != ' ' && *r != '\t' && *r != '\0' && *r != '\n') {
     582               0 :         r++;
     583               0 :         n++;
     584                 :     }
     585               0 :     return n;
     586                 : }
     587                 : 
     588               0 : char * copy_field(char * dest, const char * morph, const char * var)
     589                 : {
     590               0 :     if (!morph) return NULL;
     591               0 :     const char * beg = strstr(morph, var);
     592               0 :     if (beg) {
     593               0 :        char * d = dest;
     594               0 :        for (beg += MORPH_TAG_LEN; *beg != ' ' && *beg != '\t' &&
     595                 :             *beg != '\n' && *beg != '\0'; d++, beg++) {
     596               0 :          *d = *beg;
     597                 :        }
     598               0 :        *d = '\0';
     599               0 :        return dest;
     600                 :   }
     601               0 :   return NULL;
     602                 : }
     603                 : 
     604             810 : char * mystrrep(char * word, const char * pat, const char * rep) {
     605             810 :     char * pos = strstr(word, pat);
     606             810 :     if (pos) {
     607              24 :       int replen = strlen(rep);
     608              24 :       int patlen = strlen(pat);
     609              73 :       while (pos) {
     610              25 :         if (replen < patlen) {
     611              19 :             char * end = word + strlen(word);
     612              19 :             char * next = pos + replen;
     613              19 :             char * prev = pos + strlen(pat);
     614              19 :             for (; prev < end; *next = *prev, prev++, next++);
     615              19 :             *next = '\0';
     616               6 :         } else if (replen > patlen) {
     617               0 :             char * end = pos + patlen;
     618               0 :             char * next = word + strlen(word) + replen - patlen;
     619               0 :             char * prev = next - replen + patlen;
     620               0 :             for (; prev >= end; *next = *prev, prev--, next--);
     621                 :         }
     622              25 :         strncpy(pos, rep, replen);
     623              25 :         pos = strstr(word, pat);
     624                 :       }
     625                 :     }
     626             810 :     return word;
     627                 : }
     628                 : 
     629                 :  // reverse word 
     630             329 :  int reverseword(char * word) {
     631                 :    char r;
     632             887 :    for (char * dest = word + strlen(word) - 1; word < dest; word++, dest--) {
     633             558 :      r=*word;
     634             558 :      *word = *dest;
     635             558 :      *dest = r;
     636                 :    }
     637             329 :    return 0;
     638                 :  }
     639                 : 
     640                 :  // reverse word (error: 1)
     641              10 :  int reverseword_utf(char * word) {
     642                 :    w_char w[MAXWORDLEN];
     643                 :    w_char * p;
     644                 :    w_char r;
     645              10 :    int l = u8_u16(w, MAXWORDLEN, word);
     646              10 :    if (l == -1) return 1;
     647              10 :    p = w;
     648              22 :    for (w_char * dest = w + l - 1; p < dest; p++, dest--) {
     649              12 :      r=*p;
     650              12 :      *p = *dest;
     651              12 :      *dest = r;
     652                 :    }
     653              10 :    u16_u8(word, MAXWORDUTF8LEN, w, l);
     654              10 :    return 0;
     655                 :  }
     656                 : 
     657               0 :  int uniqlist(char ** list, int n) {
     658                 :    int i;
     659               0 :    if (n < 2) return n;
     660               0 :    for (i = 0; i < n; i++) {
     661               0 :      for (int j = 0; j < i; j++) {
     662               0 :         if (list[j] && list[i] && (strcmp(list[j], list[i]) == 0)) {
     663               0 :             free(list[i]);
     664               0 :             list[i] = NULL;
     665               0 :             break;
     666                 :         }
     667                 :      }
     668                 :    } 
     669               0 :    int m = 1;  
     670               0 :    for (i = 1; i < n; i++) if (list[i]) {
     671               0 :         list[m] = list[i];
     672               0 :         m++;
     673                 :     }
     674               0 :    return m;
     675                 :  }
     676                 :  
     677               0 :  void freelist(char *** list, int n) {
     678               0 :    if (list && *list && n > 0) {
     679               0 :      for (int i = 0; i < n; i++) if ((*list)[i]) free((*list)[i]);
     680               0 :      free(*list);
     681               0 :      *list = NULL;
     682                 :    }
     683               0 :  }
     684                 :  
     685                 :  // convert null terminated string to all caps
     686               0 :  void mkallcap(char * p, const struct cs_info * csconv)
     687                 :  {
     688               0 :    while (*p != '\0') {
     689               0 :      *p = csconv[((unsigned char) *p)].cupper;
     690               0 :      p++;
     691                 :    }
     692               0 :  }
     693                 :   
     694                 :  // convert null terminated string to all little
     695              13 :  void mkallsmall(char * p, const struct cs_info * csconv)
     696                 :  {
     697             102 :    while (*p != '\0') {
     698              76 :      *p = csconv[((unsigned char) *p)].clower;
     699              76 :      p++;
     700                 :    }
     701              13 :  }
     702                 : 
     703               4 : void mkallsmall_utf(w_char * u, int nc, int langnum) {
     704              35 :     for (int i = 0; i < nc; i++) {
     705              31 :         unsigned short idx = (u[i].h << 8) + u[i].l;
     706              31 :         if (idx != unicodetolower(idx, langnum)) {
     707              13 :             u[i].h = (unsigned char) (unicodetolower(idx, langnum) >> 8);
     708              13 :             u[i].l = (unsigned char) (unicodetolower(idx, langnum) & 0x00FF);
     709                 :         }
     710                 :     }
     711               4 : }
     712                 : 
     713               4 : void mkallcap_utf(w_char * u, int nc, int langnum) {
     714               8 :     for (int i = 0; i < nc; i++) {
     715               4 :         unsigned short idx = (u[i].h << 8) + u[i].l;
     716               4 :         if (idx != unicodetoupper(idx, langnum)) {
     717               4 :             u[i].h = (unsigned char) (unicodetoupper(idx, langnum) >> 8);
     718               4 :             u[i].l = (unsigned char) (unicodetoupper(idx, langnum) & 0x00FF);
     719                 :         }
     720                 :     }
     721               4 : }
     722                 :  
     723                 :  // convert null terminated string to have initial capital
     724              13 :  void mkinitcap(char * p, const struct cs_info * csconv)
     725                 :  {
     726              13 :    if (*p != '\0') *p = csconv[((unsigned char)*p)].cupper;
     727              13 :  }
     728                 : 
     729                 :  // conversion function for protected memory
     730               2 :  void store_pointer(char * dest, char * source)
     731                 :  {
     732               2 :     memcpy(dest, &source, sizeof(char *));
     733               2 :  }
     734                 : 
     735                 :  // conversion function for protected memory
     736               2 :  char * get_stored_pointer(const char * s)
     737                 :  {
     738                 :     char * p;
     739               2 :     memcpy(&p, s, sizeof(char *));
     740               2 :     return p;
     741                 :  }
     742                 : 
     743                 : #ifndef MOZILLA_CLIENT
     744                 :  // convert null terminated string to all caps using encoding
     745                 :  void enmkallcap(char * d, const char * p, const char * encoding)
     746                 :  
     747                 :  {
     748                 :    struct cs_info * csconv = get_current_cs(encoding);
     749                 :    while (*p != '\0') {
     750                 :      *d++ = csconv[((unsigned char) *p)].cupper;
     751                 :      p++;
     752                 :    }
     753                 :    *d = '\0';
     754                 :  }
     755                 : 
     756                 :  // convert null terminated string to all little using encoding
     757                 :  void enmkallsmall(char * d, const char * p, const char * encoding)
     758                 :  {
     759                 :    struct cs_info * csconv = get_current_cs(encoding);
     760                 :    while (*p != '\0') {
     761                 :      *d++ = csconv[((unsigned char) *p)].clower;
     762                 :      p++;
     763                 :    }
     764                 :    *d = '\0';
     765                 :  }
     766                 : 
     767                 :  // convert null terminated string to have initial capital using encoding
     768                 :  void enmkinitcap(char * d, const char * p, const char * encoding)
     769                 :  {
     770                 :    struct cs_info * csconv = get_current_cs(encoding);
     771                 :    memcpy(d,p,(strlen(p)+1));
     772                 :    if (*p != '\0') *d= csconv[((unsigned char)*p)].cupper;
     773                 :  }
     774                 : 
     775                 : // these are simple character mappings for the 
     776                 : // encodings supported
     777                 : // supplying isupper, tolower, and toupper
     778                 : 
     779                 : static struct cs_info iso1_tbl[] = {
     780                 : { 0x00, 0x00, 0x00 },
     781                 : { 0x00, 0x01, 0x01 },
     782                 : { 0x00, 0x02, 0x02 },
     783                 : { 0x00, 0x03, 0x03 },
     784                 : { 0x00, 0x04, 0x04 },
     785                 : { 0x00, 0x05, 0x05 },
     786                 : { 0x00, 0x06, 0x06 },
     787                 : { 0x00, 0x07, 0x07 },
     788                 : { 0x00, 0x08, 0x08 },
     789                 : { 0x00, 0x09, 0x09 },
     790                 : { 0x00, 0x0a, 0x0a },
     791                 : { 0x00, 0x0b, 0x0b },
     792                 : { 0x00, 0x0c, 0x0c },
     793                 : { 0x00, 0x0d, 0x0d },
     794                 : { 0x00, 0x0e, 0x0e },
     795                 : { 0x00, 0x0f, 0x0f },
     796                 : { 0x00, 0x10, 0x10 },
     797                 : { 0x00, 0x11, 0x11 },
     798                 : { 0x00, 0x12, 0x12 },
     799                 : { 0x00, 0x13, 0x13 },
     800                 : { 0x00, 0x14, 0x14 },
     801                 : { 0x00, 0x15, 0x15 },
     802                 : { 0x00, 0x16, 0x16 },
     803                 : { 0x00, 0x17, 0x17 },
     804                 : { 0x00, 0x18, 0x18 },
     805                 : { 0x00, 0x19, 0x19 },
     806                 : { 0x00, 0x1a, 0x1a },
     807                 : { 0x00, 0x1b, 0x1b },
     808                 : { 0x00, 0x1c, 0x1c },
     809                 : { 0x00, 0x1d, 0x1d },
     810                 : { 0x00, 0x1e, 0x1e },
     811                 : { 0x00, 0x1f, 0x1f },
     812                 : { 0x00, 0x20, 0x20 },
     813                 : { 0x00, 0x21, 0x21 },
     814                 : { 0x00, 0x22, 0x22 },
     815                 : { 0x00, 0x23, 0x23 },
     816                 : { 0x00, 0x24, 0x24 },
     817                 : { 0x00, 0x25, 0x25 },
     818                 : { 0x00, 0x26, 0x26 },
     819                 : { 0x00, 0x27, 0x27 },
     820                 : { 0x00, 0x28, 0x28 },
     821                 : { 0x00, 0x29, 0x29 },
     822                 : { 0x00, 0x2a, 0x2a },
     823                 : { 0x00, 0x2b, 0x2b },
     824                 : { 0x00, 0x2c, 0x2c },
     825                 : { 0x00, 0x2d, 0x2d },
     826                 : { 0x00, 0x2e, 0x2e },
     827                 : { 0x00, 0x2f, 0x2f },
     828                 : { 0x00, 0x30, 0x30 },
     829                 : { 0x00, 0x31, 0x31 },
     830                 : { 0x00, 0x32, 0x32 },
     831                 : { 0x00, 0x33, 0x33 },
     832                 : { 0x00, 0x34, 0x34 },
     833                 : { 0x00, 0x35, 0x35 },
     834                 : { 0x00, 0x36, 0x36 },
     835                 : { 0x00, 0x37, 0x37 },
     836                 : { 0x00, 0x38, 0x38 },
     837                 : { 0x00, 0x39, 0x39 },
     838                 : { 0x00, 0x3a, 0x3a },
     839                 : { 0x00, 0x3b, 0x3b },
     840                 : { 0x00, 0x3c, 0x3c },
     841                 : { 0x00, 0x3d, 0x3d },
     842                 : { 0x00, 0x3e, 0x3e },
     843                 : { 0x00, 0x3f, 0x3f },
     844                 : { 0x00, 0x40, 0x40 },
     845                 : { 0x01, 0x61, 0x41 },
     846                 : { 0x01, 0x62, 0x42 },
     847                 : { 0x01, 0x63, 0x43 },
     848                 : { 0x01, 0x64, 0x44 },
     849                 : { 0x01, 0x65, 0x45 },
     850                 : { 0x01, 0x66, 0x46 },
     851                 : { 0x01, 0x67, 0x47 },
     852                 : { 0x01, 0x68, 0x48 },
     853                 : { 0x01, 0x69, 0x49 },
     854                 : { 0x01, 0x6a, 0x4a },
     855                 : { 0x01, 0x6b, 0x4b },
     856                 : { 0x01, 0x6c, 0x4c },
     857                 : { 0x01, 0x6d, 0x4d },
     858                 : { 0x01, 0x6e, 0x4e },
     859                 : { 0x01, 0x6f, 0x4f },
     860                 : { 0x01, 0x70, 0x50 },
     861                 : { 0x01, 0x71, 0x51 },
     862                 : { 0x01, 0x72, 0x52 },
     863                 : { 0x01, 0x73, 0x53 },
     864                 : { 0x01, 0x74, 0x54 },
     865                 : { 0x01, 0x75, 0x55 },
     866                 : { 0x01, 0x76, 0x56 },
     867                 : { 0x01, 0x77, 0x57 },
     868                 : { 0x01, 0x78, 0x58 },
     869                 : { 0x01, 0x79, 0x59 },
     870                 : { 0x01, 0x7a, 0x5a },
     871                 : { 0x00, 0x5b, 0x5b },
     872                 : { 0x00, 0x5c, 0x5c },
     873                 : { 0x00, 0x5d, 0x5d },
     874                 : { 0x00, 0x5e, 0x5e },
     875                 : { 0x00, 0x5f, 0x5f },
     876                 : { 0x00, 0x60, 0x60 },
     877                 : { 0x00, 0x61, 0x41 },
     878                 : { 0x00, 0x62, 0x42 },
     879                 : { 0x00, 0x63, 0x43 },
     880                 : { 0x00, 0x64, 0x44 },
     881                 : { 0x00, 0x65, 0x45 },
     882                 : { 0x00, 0x66, 0x46 },
     883                 : { 0x00, 0x67, 0x47 },
     884                 : { 0x00, 0x68, 0x48 },
     885                 : { 0x00, 0x69, 0x49 },
     886                 : { 0x00, 0x6a, 0x4a },
     887                 : { 0x00, 0x6b, 0x4b },
     888                 : { 0x00, 0x6c, 0x4c },
     889                 : { 0x00, 0x6d, 0x4d },
     890                 : { 0x00, 0x6e, 0x4e },
     891                 : { 0x00, 0x6f, 0x4f },
     892                 : { 0x00, 0x70, 0x50 },
     893                 : { 0x00, 0x71, 0x51 },
     894                 : { 0x00, 0x72, 0x52 },
     895                 : { 0x00, 0x73, 0x53 },
     896                 : { 0x00, 0x74, 0x54 },
     897                 : { 0x00, 0x75, 0x55 },
     898                 : { 0x00, 0x76, 0x56 },
     899                 : { 0x00, 0x77, 0x57 },
     900                 : { 0x00, 0x78, 0x58 },
     901                 : { 0x00, 0x79, 0x59 },
     902                 : { 0x00, 0x7a, 0x5a },
     903                 : { 0x00, 0x7b, 0x7b },
     904                 : { 0x00, 0x7c, 0x7c },
     905                 : { 0x00, 0x7d, 0x7d },
     906                 : { 0x00, 0x7e, 0x7e },
     907                 : { 0x00, 0x7f, 0x7f },
     908                 : { 0x00, 0x80, 0x80 },
     909                 : { 0x00, 0x81, 0x81 },
     910                 : { 0x00, 0x82, 0x82 },
     911                 : { 0x00, 0x83, 0x83 },
     912                 : { 0x00, 0x84, 0x84 },
     913                 : { 0x00, 0x85, 0x85 },
     914                 : { 0x00, 0x86, 0x86 },
     915                 : { 0x00, 0x87, 0x87 },
     916                 : { 0x00, 0x88, 0x88 },
     917                 : { 0x00, 0x89, 0x89 },
     918                 : { 0x00, 0x8a, 0x8a },
     919                 : { 0x00, 0x8b, 0x8b },
     920                 : { 0x00, 0x8c, 0x8c },
     921                 : { 0x00, 0x8d, 0x8d },
     922                 : { 0x00, 0x8e, 0x8e },
     923                 : { 0x00, 0x8f, 0x8f },
     924                 : { 0x00, 0x90, 0x90 },
     925                 : { 0x00, 0x91, 0x91 },
     926                 : { 0x00, 0x92, 0x92 },
     927                 : { 0x00, 0x93, 0x93 },
     928                 : { 0x00, 0x94, 0x94 },
     929                 : { 0x00, 0x95, 0x95 },
     930                 : { 0x00, 0x96, 0x96 },
     931                 : { 0x00, 0x97, 0x97 },
     932                 : { 0x00, 0x98, 0x98 },
     933                 : { 0x00, 0x99, 0x99 },
     934                 : { 0x00, 0x9a, 0x9a },
     935                 : { 0x00, 0x9b, 0x9b },
     936                 : { 0x00, 0x9c, 0x9c },
     937                 : { 0x00, 0x9d, 0x9d },
     938                 : { 0x00, 0x9e, 0x9e },
     939                 : { 0x00, 0x9f, 0x9f },
     940                 : { 0x00, 0xa0, 0xa0 },
     941                 : { 0x00, 0xa1, 0xa1 },
     942                 : { 0x00, 0xa2, 0xa2 },
     943                 : { 0x00, 0xa3, 0xa3 },
     944                 : { 0x00, 0xa4, 0xa4 },
     945                 : { 0x00, 0xa5, 0xa5 },
     946                 : { 0x00, 0xa6, 0xa6 },
     947                 : { 0x00, 0xa7, 0xa7 },
     948                 : { 0x00, 0xa8, 0xa8 },
     949                 : { 0x00, 0xa9, 0xa9 },
     950                 : { 0x00, 0xaa, 0xaa },
     951                 : { 0x00, 0xab, 0xab },
     952                 : { 0x00, 0xac, 0xac },
     953                 : { 0x00, 0xad, 0xad },
     954                 : { 0x00, 0xae, 0xae },
     955                 : { 0x00, 0xaf, 0xaf },
     956                 : { 0x00, 0xb0, 0xb0 },
     957                 : { 0x00, 0xb1, 0xb1 },
     958                 : { 0x00, 0xb2, 0xb2 },
     959                 : { 0x00, 0xb3, 0xb3 },
     960                 : { 0x00, 0xb4, 0xb4 },
     961                 : { 0x00, 0xb5, 0xb5 },
     962                 : { 0x00, 0xb6, 0xb6 },
     963                 : { 0x00, 0xb7, 0xb7 },
     964                 : { 0x00, 0xb8, 0xb8 },
     965                 : { 0x00, 0xb9, 0xb9 },
     966                 : { 0x00, 0xba, 0xba },
     967                 : { 0x00, 0xbb, 0xbb },
     968                 : { 0x00, 0xbc, 0xbc },
     969                 : { 0x00, 0xbd, 0xbd },
     970                 : { 0x00, 0xbe, 0xbe },
     971                 : { 0x00, 0xbf, 0xbf },
     972                 : { 0x01, 0xe0, 0xc0 },
     973                 : { 0x01, 0xe1, 0xc1 },
     974                 : { 0x01, 0xe2, 0xc2 },
     975                 : { 0x01, 0xe3, 0xc3 },
     976                 : { 0x01, 0xe4, 0xc4 },
     977                 : { 0x01, 0xe5, 0xc5 },
     978                 : { 0x01, 0xe6, 0xc6 },
     979                 : { 0x01, 0xe7, 0xc7 },
     980                 : { 0x01, 0xe8, 0xc8 },
     981                 : { 0x01, 0xe9, 0xc9 },
     982                 : { 0x01, 0xea, 0xca },
     983                 : { 0x01, 0xeb, 0xcb },
     984                 : { 0x01, 0xec, 0xcc },
     985                 : { 0x01, 0xed, 0xcd },
     986                 : { 0x01, 0xee, 0xce },
     987                 : { 0x01, 0xef, 0xcf },
     988                 : { 0x01, 0xf0, 0xd0 },
     989                 : { 0x01, 0xf1, 0xd1 },
     990                 : { 0x01, 0xf2, 0xd2 },
     991                 : { 0x01, 0xf3, 0xd3 },
     992                 : { 0x01, 0xf4, 0xd4 },
     993                 : { 0x01, 0xf5, 0xd5 },
     994                 : { 0x01, 0xf6, 0xd6 },
     995                 : { 0x00, 0xd7, 0xd7 },
     996                 : { 0x01, 0xf8, 0xd8 },
     997                 : { 0x01, 0xf9, 0xd9 },
     998                 : { 0x01, 0xfa, 0xda },
     999                 : { 0x01, 0xfb, 0xdb },
    1000                 : { 0x01, 0xfc, 0xdc },
    1001                 : { 0x01, 0xfd, 0xdd },
    1002                 : { 0x01, 0xfe, 0xde },
    1003                 : { 0x00, 0xdf, 0xdf },
    1004                 : { 0x00, 0xe0, 0xc0 },
    1005                 : { 0x00, 0xe1, 0xc1 },
    1006                 : { 0x00, 0xe2, 0xc2 },
    1007                 : { 0x00, 0xe3, 0xc3 },
    1008                 : { 0x00, 0xe4, 0xc4 },
    1009                 : { 0x00, 0xe5, 0xc5 },
    1010                 : { 0x00, 0xe6, 0xc6 },
    1011                 : { 0x00, 0xe7, 0xc7 },
    1012                 : { 0x00, 0xe8, 0xc8 },
    1013                 : { 0x00, 0xe9, 0xc9 },
    1014                 : { 0x00, 0xea, 0xca },
    1015                 : { 0x00, 0xeb, 0xcb },
    1016                 : { 0x00, 0xec, 0xcc },
    1017                 : { 0x00, 0xed, 0xcd },
    1018                 : { 0x00, 0xee, 0xce },
    1019                 : { 0x00, 0xef, 0xcf },
    1020                 : { 0x00, 0xf0, 0xd0 },
    1021                 : { 0x00, 0xf1, 0xd1 },
    1022                 : { 0x00, 0xf2, 0xd2 },
    1023                 : { 0x00, 0xf3, 0xd3 },
    1024                 : { 0x00, 0xf4, 0xd4 },
    1025                 : { 0x00, 0xf5, 0xd5 },
    1026                 : { 0x00, 0xf6, 0xd6 },
    1027                 : { 0x00, 0xf7, 0xf7 },
    1028                 : { 0x00, 0xf8, 0xd8 },
    1029                 : { 0x00, 0xf9, 0xd9 },
    1030                 : { 0x00, 0xfa, 0xda },
    1031                 : { 0x00, 0xfb, 0xdb },
    1032                 : { 0x00, 0xfc, 0xdc },
    1033                 : { 0x00, 0xfd, 0xdd },
    1034                 : { 0x00, 0xfe, 0xde },
    1035                 : { 0x00, 0xff, 0xff }
    1036                 : };
    1037                 : 
    1038                 : 
    1039                 : static struct cs_info iso2_tbl[] = {
    1040                 : { 0x00, 0x00, 0x00 },
    1041                 : { 0x00, 0x01, 0x01 },
    1042                 : { 0x00, 0x02, 0x02 },
    1043                 : { 0x00, 0x03, 0x03 },
    1044                 : { 0x00, 0x04, 0x04 },
    1045                 : { 0x00, 0x05, 0x05 },
    1046                 : { 0x00, 0x06, 0x06 },
    1047                 : { 0x00, 0x07, 0x07 },
    1048                 : { 0x00, 0x08, 0x08 },
    1049                 : { 0x00, 0x09, 0x09 },
    1050                 : { 0x00, 0x0a, 0x0a },
    1051                 : { 0x00, 0x0b, 0x0b },
    1052                 : { 0x00, 0x0c, 0x0c },
    1053                 : { 0x00, 0x0d, 0x0d },
    1054                 : { 0x00, 0x0e, 0x0e },
    1055                 : { 0x00, 0x0f, 0x0f },
    1056                 : { 0x00, 0x10, 0x10 },
    1057                 : { 0x00, 0x11, 0x11 },
    1058                 : { 0x00, 0x12, 0x12 },
    1059                 : { 0x00, 0x13, 0x13 },
    1060                 : { 0x00, 0x14, 0x14 },
    1061                 : { 0x00, 0x15, 0x15 },
    1062                 : { 0x00, 0x16, 0x16 },
    1063                 : { 0x00, 0x17, 0x17 },
    1064                 : { 0x00, 0x18, 0x18 },
    1065                 : { 0x00, 0x19, 0x19 },
    1066                 : { 0x00, 0x1a, 0x1a },
    1067                 : { 0x00, 0x1b, 0x1b },
    1068                 : { 0x00, 0x1c, 0x1c },
    1069                 : { 0x00, 0x1d, 0x1d },
    1070                 : { 0x00, 0x1e, 0x1e },
    1071                 : { 0x00, 0x1f, 0x1f },
    1072                 : { 0x00, 0x20, 0x20 },
    1073                 : { 0x00, 0x21, 0x21 },
    1074                 : { 0x00, 0x22, 0x22 },
    1075                 : { 0x00, 0x23, 0x23 },
    1076                 : { 0x00, 0x24, 0x24 },
    1077                 : { 0x00, 0x25, 0x25 },
    1078                 : { 0x00, 0x26, 0x26 },
    1079                 : { 0x00, 0x27, 0x27 },
    1080                 : { 0x00, 0x28, 0x28 },
    1081                 : { 0x00, 0x29, 0x29 },
    1082                 : { 0x00, 0x2a, 0x2a },
    1083                 : { 0x00, 0x2b, 0x2b },
    1084                 : { 0x00, 0x2c, 0x2c },
    1085                 : { 0x00, 0x2d, 0x2d },
    1086                 : { 0x00, 0x2e, 0x2e },
    1087                 : { 0x00, 0x2f, 0x2f },
    1088                 : { 0x00, 0x30, 0x30 },
    1089                 : { 0x00, 0x31, 0x31 },
    1090                 : { 0x00, 0x32, 0x32 },
    1091                 : { 0x00, 0x33, 0x33 },
    1092                 : { 0x00, 0x34, 0x34 },
    1093                 : { 0x00, 0x35, 0x35 },
    1094                 : { 0x00, 0x36, 0x36 },
    1095                 : { 0x00, 0x37, 0x37 },
    1096                 : { 0x00, 0x38, 0x38 },
    1097                 : { 0x00, 0x39, 0x39 },
    1098                 : { 0x00, 0x3a, 0x3a },
    1099                 : { 0x00, 0x3b, 0x3b },
    1100                 : { 0x00, 0x3c, 0x3c },
    1101                 : { 0x00, 0x3d, 0x3d },
    1102                 : { 0x00, 0x3e, 0x3e },
    1103                 : { 0x00, 0x3f, 0x3f },
    1104                 : { 0x00, 0x40, 0x40 },
    1105                 : { 0x01, 0x61, 0x41 },
    1106                 : { 0x01, 0x62, 0x42 },
    1107                 : { 0x01, 0x63, 0x43 },
    1108                 : { 0x01, 0x64, 0x44 },
    1109                 : { 0x01, 0x65, 0x45 },
    1110                 : { 0x01, 0x66, 0x46 },
    1111                 : { 0x01, 0x67, 0x47 },
    1112                 : { 0x01, 0x68, 0x48 },
    1113                 : { 0x01, 0x69, 0x49 },
    1114                 : { 0x01, 0x6a, 0x4a },
    1115                 : { 0x01, 0x6b, 0x4b },
    1116                 : { 0x01, 0x6c, 0x4c },
    1117                 : { 0x01, 0x6d, 0x4d },
    1118                 : { 0x01, 0x6e, 0x4e },
    1119                 : { 0x01, 0x6f, 0x4f },
    1120                 : { 0x01, 0x70, 0x50 },
    1121                 : { 0x01, 0x71, 0x51 },
    1122                 : { 0x01, 0x72, 0x52 },
    1123                 : { 0x01, 0x73, 0x53 },
    1124                 : { 0x01, 0x74, 0x54 },
    1125                 : { 0x01, 0x75, 0x55 },
    1126                 : { 0x01, 0x76, 0x56 },
    1127                 : { 0x01, 0x77, 0x57 },
    1128                 : { 0x01, 0x78, 0x58 },
    1129                 : { 0x01, 0x79, 0x59 },
    1130                 : { 0x01, 0x7a, 0x5a },
    1131                 : { 0x00, 0x5b, 0x5b },
    1132                 : { 0x00, 0x5c, 0x5c },
    1133                 : { 0x00, 0x5d, 0x5d },
    1134                 : { 0x00, 0x5e, 0x5e },
    1135                 : { 0x00, 0x5f, 0x5f },
    1136                 : { 0x00, 0x60, 0x60 },
    1137                 : { 0x00, 0x61, 0x41 },
    1138                 : { 0x00, 0x62, 0x42 },
    1139                 : { 0x00, 0x63, 0x43 },
    1140                 : { 0x00, 0x64, 0x44 },
    1141                 : { 0x00, 0x65, 0x45 },
    1142                 : { 0x00, 0x66, 0x46 },
    1143                 : { 0x00, 0x67, 0x47 },
    1144                 : { 0x00, 0x68, 0x48 },
    1145                 : { 0x00, 0x69, 0x49 },
    1146                 : { 0x00, 0x6a, 0x4a },
    1147                 : { 0x00, 0x6b, 0x4b },
    1148                 : { 0x00, 0x6c, 0x4c },
    1149                 : { 0x00, 0x6d, 0x4d },
    1150                 : { 0x00, 0x6e, 0x4e },
    1151                 : { 0x00, 0x6f, 0x4f },
    1152                 : { 0x00, 0x70, 0x50 },
    1153                 : { 0x00, 0x71, 0x51 },
    1154                 : { 0x00, 0x72, 0x52 },
    1155                 : { 0x00, 0x73, 0x53 },
    1156                 : { 0x00, 0x74, 0x54 },
    1157                 : { 0x00, 0x75, 0x55 },
    1158                 : { 0x00, 0x76, 0x56 },
    1159                 : { 0x00, 0x77, 0x57 },
    1160                 : { 0x00, 0x78, 0x58 },
    1161                 : { 0x00, 0x79, 0x59 },
    1162                 : { 0x00, 0x7a, 0x5a },
    1163                 : { 0x00, 0x7b, 0x7b },
    1164                 : { 0x00, 0x7c, 0x7c },
    1165                 : { 0x00, 0x7d, 0x7d },
    1166                 : { 0x00, 0x7e, 0x7e },
    1167                 : { 0x00, 0x7f, 0x7f },
    1168                 : { 0x00, 0x80, 0x80 },
    1169                 : { 0x00, 0x81, 0x81 },
    1170                 : { 0x00, 0x82, 0x82 },
    1171                 : { 0x00, 0x83, 0x83 },
    1172                 : { 0x00, 0x84, 0x84 },
    1173                 : { 0x00, 0x85, 0x85 },
    1174                 : { 0x00, 0x86, 0x86 },
    1175                 : { 0x00, 0x87, 0x87 },
    1176                 : { 0x00, 0x88, 0x88 },
    1177                 : { 0x00, 0x89, 0x89 },
    1178                 : { 0x00, 0x8a, 0x8a },
    1179                 : { 0x00, 0x8b, 0x8b },
    1180                 : { 0x00, 0x8c, 0x8c },
    1181                 : { 0x00, 0x8d, 0x8d },
    1182                 : { 0x00, 0x8e, 0x8e },
    1183                 : { 0x00, 0x8f, 0x8f },
    1184                 : { 0x00, 0x90, 0x90 },
    1185                 : { 0x00, 0x91, 0x91 },
    1186                 : { 0x00, 0x92, 0x92 },
    1187                 : { 0x00, 0x93, 0x93 },
    1188                 : { 0x00, 0x94, 0x94 },
    1189                 : { 0x00, 0x95, 0x95 },
    1190                 : { 0x00, 0x96, 0x96 },
    1191                 : { 0x00, 0x97, 0x97 },
    1192                 : { 0x00, 0x98, 0x98 },
    1193                 : { 0x00, 0x99, 0x99 },
    1194                 : { 0x00, 0x9a, 0x9a },
    1195                 : { 0x00, 0x9b, 0x9b },
    1196                 : { 0x00, 0x9c, 0x9c },
    1197                 : { 0x00, 0x9d, 0x9d },
    1198                 : { 0x00, 0x9e, 0x9e },
    1199                 : { 0x00, 0x9f, 0x9f },
    1200                 : { 0x00, 0xa0, 0xa0 },
    1201                 : { 0x01, 0xb1, 0xa1 },
    1202                 : { 0x00, 0xa2, 0xa2 },
    1203                 : { 0x01, 0xb3, 0xa3 },
    1204                 : { 0x00, 0xa4, 0xa4 },
    1205                 : { 0x01, 0xb5, 0xa5 },
    1206                 : { 0x01, 0xb6, 0xa6 },
    1207                 : { 0x00, 0xa7, 0xa7 },
    1208                 : { 0x00, 0xa8, 0xa8 },
    1209                 : { 0x01, 0xb9, 0xa9 },
    1210                 : { 0x01, 0xba, 0xaa },
    1211                 : { 0x01, 0xbb, 0xab },
    1212                 : { 0x01, 0xbc, 0xac },
    1213                 : { 0x00, 0xad, 0xad },
    1214                 : { 0x01, 0xbe, 0xae },
    1215                 : { 0x01, 0xbf, 0xaf },
    1216                 : { 0x00, 0xb0, 0xb0 },
    1217                 : { 0x00, 0xb1, 0xa1 },
    1218                 : { 0x00, 0xb2, 0xb2 },
    1219                 : { 0x00, 0xb3, 0xa3 },
    1220                 : { 0x00, 0xb4, 0xb4 },
    1221                 : { 0x00, 0xb5, 0xa5 },
    1222                 : { 0x00, 0xb6, 0xa6 },
    1223                 : { 0x00, 0xb7, 0xb7 },
    1224                 : { 0x00, 0xb8, 0xb8 },
    1225                 : { 0x00, 0xb9, 0xa9 },
    1226                 : { 0x00, 0xba, 0xaa },
    1227                 : { 0x00, 0xbb, 0xab },
    1228                 : { 0x00, 0xbc, 0xac },
    1229                 : { 0x00, 0xbd, 0xbd },
    1230                 : { 0x00, 0xbe, 0xae },
    1231                 : { 0x00, 0xbf, 0xaf },
    1232                 : { 0x01, 0xe0, 0xc0 },
    1233                 : { 0x01, 0xe1, 0xc1 },
    1234                 : { 0x01, 0xe2, 0xc2 },
    1235                 : { 0x01, 0xe3, 0xc3 },
    1236                 : { 0x01, 0xe4, 0xc4 },
    1237                 : { 0x01, 0xe5, 0xc5 },
    1238                 : { 0x01, 0xe6, 0xc6 },
    1239                 : { 0x01, 0xe7, 0xc7 },
    1240                 : { 0x01, 0xe8, 0xc8 },
    1241                 : { 0x01, 0xe9, 0xc9 },
    1242                 : { 0x01, 0xea, 0xca },
    1243                 : { 0x01, 0xeb, 0xcb },
    1244                 : { 0x01, 0xec, 0xcc },
    1245                 : { 0x01, 0xed, 0xcd },
    1246                 : { 0x01, 0xee, 0xce },
    1247                 : { 0x01, 0xef, 0xcf },
    1248                 : { 0x01, 0xf0, 0xd0 },
    1249                 : { 0x01, 0xf1, 0xd1 },
    1250                 : { 0x01, 0xf2, 0xd2 },
    1251                 : { 0x01, 0xf3, 0xd3 },
    1252                 : { 0x01, 0xf4, 0xd4 },
    1253                 : { 0x01, 0xf5, 0xd5 },
    1254                 : { 0x01, 0xf6, 0xd6 },
    1255                 : { 0x00, 0xd7, 0xd7 },
    1256                 : { 0x01, 0xf8, 0xd8 },
    1257                 : { 0x01, 0xf9, 0xd9 },
    1258                 : { 0x01, 0xfa, 0xda },
    1259                 : { 0x01, 0xfb, 0xdb },
    1260                 : { 0x01, 0xfc, 0xdc },
    1261                 : { 0x01, 0xfd, 0xdd },
    1262                 : { 0x01, 0xfe, 0xde },
    1263                 : { 0x00, 0xdf, 0xdf },
    1264                 : { 0x00, 0xe0, 0xc0 },
    1265                 : { 0x00, 0xe1, 0xc1 },
    1266                 : { 0x00, 0xe2, 0xc2 },
    1267                 : { 0x00, 0xe3, 0xc3 },
    1268                 : { 0x00, 0xe4, 0xc4 },
    1269                 : { 0x00, 0xe5, 0xc5 },
    1270                 : { 0x00, 0xe6, 0xc6 },
    1271                 : { 0x00, 0xe7, 0xc7 },
    1272                 : { 0x00, 0xe8, 0xc8 },
    1273                 : { 0x00, 0xe9, 0xc9 },
    1274                 : { 0x00, 0xea, 0xca },
    1275                 : { 0x00, 0xeb, 0xcb },
    1276                 : { 0x00, 0xec, 0xcc },
    1277                 : { 0x00, 0xed, 0xcd },
    1278                 : { 0x00, 0xee, 0xce },
    1279                 : { 0x00, 0xef, 0xcf },
    1280                 : { 0x00, 0xf0, 0xd0 },
    1281                 : { 0x00, 0xf1, 0xd1 },
    1282                 : { 0x00, 0xf2, 0xd2 },
    1283                 : { 0x00, 0xf3, 0xd3 },
    1284                 : { 0x00, 0xf4, 0xd4 },
    1285                 : { 0x00, 0xf5, 0xd5 },
    1286                 : { 0x00, 0xf6, 0xd6 },
    1287                 : { 0x00, 0xf7, 0xf7 },
    1288                 : { 0x00, 0xf8, 0xd8 },
    1289                 : { 0x00, 0xf9, 0xd9 },
    1290                 : { 0x00, 0xfa, 0xda },
    1291                 : { 0x00, 0xfb, 0xdb },
    1292                 : { 0x00, 0xfc, 0xdc },
    1293                 : { 0x00, 0xfd, 0xdd },
    1294                 : { 0x00, 0xfe, 0xde },
    1295                 : { 0x00, 0xff, 0xff }
    1296                 : };
    1297                 : 
    1298                 : 
    1299                 : static struct cs_info iso3_tbl[] = {
    1300                 : { 0x00, 0x00, 0x00 },
    1301                 : { 0x00, 0x01, 0x01 },
    1302                 : { 0x00, 0x02, 0x02 },
    1303                 : { 0x00, 0x03, 0x03 },
    1304                 : { 0x00, 0x04, 0x04 },
    1305                 : { 0x00, 0x05, 0x05 },
    1306                 : { 0x00, 0x06, 0x06 },
    1307                 : { 0x00, 0x07, 0x07 },
    1308                 : { 0x00, 0x08, 0x08 },
    1309                 : { 0x00, 0x09, 0x09 },
    1310                 : { 0x00, 0x0a, 0x0a },
    1311                 : { 0x00, 0x0b, 0x0b },
    1312                 : { 0x00, 0x0c, 0x0c },
    1313                 : { 0x00, 0x0d, 0x0d },
    1314                 : { 0x00, 0x0e, 0x0e },
    1315                 : { 0x00, 0x0f, 0x0f },
    1316                 : { 0x00, 0x10, 0x10 },
    1317                 : { 0x00, 0x11, 0x11 },
    1318                 : { 0x00, 0x12, 0x12 },
    1319                 : { 0x00, 0x13, 0x13 },
    1320                 : { 0x00, 0x14, 0x14 },
    1321                 : { 0x00, 0x15, 0x15 },
    1322                 : { 0x00, 0x16, 0x16 },
    1323                 : { 0x00, 0x17, 0x17 },
    1324                 : { 0x00, 0x18, 0x18 },
    1325                 : { 0x00, 0x19, 0x19 },
    1326                 : { 0x00, 0x1a, 0x1a },
    1327                 : { 0x00, 0x1b, 0x1b },
    1328                 : { 0x00, 0x1c, 0x1c },
    1329                 : { 0x00, 0x1d, 0x1d },
    1330                 : { 0x00, 0x1e, 0x1e },
    1331                 : { 0x00, 0x1f, 0x1f },
    1332                 : { 0x00, 0x20, 0x20 },
    1333                 : { 0x00, 0x21, 0x21 },
    1334                 : { 0x00, 0x22, 0x22 },
    1335                 : { 0x00, 0x23, 0x23 },
    1336                 : { 0x00, 0x24, 0x24 },
    1337                 : { 0x00, 0x25, 0x25 },
    1338                 : { 0x00, 0x26, 0x26 },
    1339                 : { 0x00, 0x27, 0x27 },
    1340                 : { 0x00, 0x28, 0x28 },
    1341                 : { 0x00, 0x29, 0x29 },
    1342                 : { 0x00, 0x2a, 0x2a },
    1343                 : { 0x00, 0x2b, 0x2b },
    1344                 : { 0x00, 0x2c, 0x2c },
    1345                 : { 0x00, 0x2d, 0x2d },
    1346                 : { 0x00, 0x2e, 0x2e },
    1347                 : { 0x00, 0x2f, 0x2f },
    1348                 : { 0x00, 0x30, 0x30 },
    1349                 : { 0x00, 0x31, 0x31 },
    1350                 : { 0x00, 0x32, 0x32 },
    1351                 : { 0x00, 0x33, 0x33 },
    1352                 : { 0x00, 0x34, 0x34 },
    1353                 : { 0x00, 0x35, 0x35 },
    1354                 : { 0x00, 0x36, 0x36 },
    1355                 : { 0x00, 0x37, 0x37 },
    1356                 : { 0x00, 0x38, 0x38 },
    1357                 : { 0x00, 0x39, 0x39 },
    1358                 : { 0x00, 0x3a, 0x3a },
    1359                 : { 0x00, 0x3b, 0x3b },
    1360                 : { 0x00, 0x3c, 0x3c },
    1361                 : { 0x00, 0x3d, 0x3d },
    1362                 : { 0x00, 0x3e, 0x3e },
    1363                 : { 0x00, 0x3f, 0x3f },
    1364                 : { 0x00, 0x40, 0x40 },
    1365                 : { 0x01, 0x61, 0x41 },
    1366                 : { 0x01, 0x62, 0x42 },
    1367                 : { 0x01, 0x63, 0x43 },
    1368                 : { 0x01, 0x64, 0x44 },
    1369                 : { 0x01, 0x65, 0x45 },
    1370                 : { 0x01, 0x66, 0x46 },
    1371                 : { 0x01, 0x67, 0x47 },
    1372                 : { 0x01, 0x68, 0x48 },
    1373                 : { 0x01, 0x69, 0x49 },
    1374                 : { 0x01, 0x6a, 0x4a },
    1375                 : { 0x01, 0x6b, 0x4b },
    1376                 : { 0x01, 0x6c, 0x4c },
    1377                 : { 0x01, 0x6d, 0x4d },
    1378                 : { 0x01, 0x6e, 0x4e },
    1379                 : { 0x01, 0x6f, 0x4f },
    1380                 : { 0x01, 0x70, 0x50 },
    1381                 : { 0x01, 0x71, 0x51 },
    1382                 : { 0x01, 0x72, 0x52 },
    1383                 : { 0x01, 0x73, 0x53 },
    1384                 : { 0x01, 0x74, 0x54 },
    1385                 : { 0x01, 0x75, 0x55 },
    1386                 : { 0x01, 0x76, 0x56 },
    1387                 : { 0x01, 0x77, 0x57 },
    1388                 : { 0x01, 0x78, 0x58 },
    1389                 : { 0x01, 0x79, 0x59 },
    1390                 : { 0x01, 0x7a, 0x5a },
    1391                 : { 0x00, 0x5b, 0x5b },
    1392                 : { 0x00, 0x5c, 0x5c },
    1393                 : { 0x00, 0x5d, 0x5d },
    1394                 : { 0x00, 0x5e, 0x5e },
    1395                 : { 0x00, 0x5f, 0x5f },
    1396                 : { 0x00, 0x60, 0x60 },
    1397                 : { 0x00, 0x61, 0x41 },
    1398                 : { 0x00, 0x62, 0x42 },
    1399                 : { 0x00, 0x63, 0x43 },
    1400                 : { 0x00, 0x64, 0x44 },
    1401                 : { 0x00, 0x65, 0x45 },
    1402                 : { 0x00, 0x66, 0x46 },
    1403                 : { 0x00, 0x67, 0x47 },
    1404                 : { 0x00, 0x68, 0x48 },
    1405                 : { 0x00, 0x69, 0x49 },
    1406                 : { 0x00, 0x6a, 0x4a },
    1407                 : { 0x00, 0x6b, 0x4b },
    1408                 : { 0x00, 0x6c, 0x4c },
    1409                 : { 0x00, 0x6d, 0x4d },
    1410                 : { 0x00, 0x6e, 0x4e },
    1411                 : { 0x00, 0x6f, 0x4f },
    1412                 : { 0x00, 0x70, 0x50 },
    1413                 : { 0x00, 0x71, 0x51 },
    1414                 : { 0x00, 0x72, 0x52 },
    1415                 : { 0x00, 0x73, 0x53 },
    1416                 : { 0x00, 0x74, 0x54 },
    1417                 : { 0x00, 0x75, 0x55 },
    1418                 : { 0x00, 0x76, 0x56 },
    1419                 : { 0x00, 0x77, 0x57 },
    1420                 : { 0x00, 0x78, 0x58 },
    1421                 : { 0x00, 0x79, 0x59 },
    1422                 : { 0x00, 0x7a, 0x5a },
    1423                 : { 0x00, 0x7b, 0x7b },
    1424                 : { 0x00, 0x7c, 0x7c },
    1425                 : { 0x00, 0x7d, 0x7d },
    1426                 : { 0x00, 0x7e, 0x7e },
    1427                 : { 0x00, 0x7f, 0x7f },
    1428                 : { 0x00, 0x80, 0x80 },
    1429                 : { 0x00, 0x81, 0x81 },
    1430                 : { 0x00, 0x82, 0x82 },
    1431                 : { 0x00, 0x83, 0x83 },
    1432                 : { 0x00, 0x84, 0x84 },
    1433                 : { 0x00, 0x85, 0x85 },
    1434                 : { 0x00, 0x86, 0x86 },
    1435                 : { 0x00, 0x87, 0x87 },
    1436                 : { 0x00, 0x88, 0x88 },
    1437                 : { 0x00, 0x89, 0x89 },
    1438                 : { 0x00, 0x8a, 0x8a },
    1439                 : { 0x00, 0x8b, 0x8b },
    1440                 : { 0x00, 0x8c, 0x8c },
    1441                 : { 0x00, 0x8d, 0x8d },
    1442                 : { 0x00, 0x8e, 0x8e },
    1443                 : { 0x00, 0x8f, 0x8f },
    1444                 : { 0x00, 0x90, 0x90 },
    1445                 : { 0x00, 0x91, 0x91 },
    1446                 : { 0x00, 0x92, 0x92 },
    1447                 : { 0x00, 0x93, 0x93 },
    1448                 : { 0x00, 0x94, 0x94 },
    1449                 : { 0x00, 0x95, 0x95 },
    1450                 : { 0x00, 0x96, 0x96 },
    1451                 : { 0x00, 0x97, 0x97 },
    1452                 : { 0x00, 0x98, 0x98 },
    1453                 : { 0x00, 0x99, 0x99 },
    1454                 : { 0x00, 0x9a, 0x9a },
    1455                 : { 0x00, 0x9b, 0x9b },
    1456                 : { 0x00, 0x9c, 0x9c },
    1457                 : { 0x00, 0x9d, 0x9d },
    1458                 : { 0x00, 0x9e, 0x9e },
    1459                 : { 0x00, 0x9f, 0x9f },
    1460                 : { 0x00, 0xa0, 0xa0 },
    1461                 : { 0x01, 0xb1, 0xa1 },
    1462                 : { 0x00, 0xa2, 0xa2 },
    1463                 : { 0x00, 0xa3, 0xa3 },
    1464                 : { 0x00, 0xa4, 0xa4 },
    1465                 : { 0x00, 0xa5, 0xa5 },
    1466                 : { 0x01, 0xb6, 0xa6 },
    1467                 : { 0x00, 0xa7, 0xa7 },
    1468                 : { 0x00, 0xa8, 0xa8 },
    1469                 : { 0x01, 0x69, 0xa9 },
    1470                 : { 0x01, 0xba, 0xaa },
    1471                 : { 0x01, 0xbb, 0xab },
    1472                 : { 0x01, 0xbc, 0xac },
    1473                 : { 0x00, 0xad, 0xad },
    1474                 : { 0x00, 0xae, 0xae },
    1475                 : { 0x01, 0xbf, 0xaf },
    1476                 : { 0x00, 0xb0, 0xb0 },
    1477                 : { 0x00, 0xb1, 0xa1 },
    1478                 : { 0x00, 0xb2, 0xb2 },
    1479                 : { 0x00, 0xb3, 0xb3 },
    1480                 : { 0x00, 0xb4, 0xb4 },
    1481                 : { 0x00, 0xb5, 0xb5 },
    1482                 : { 0x00, 0xb6, 0xa6 },
    1483                 : { 0x00, 0xb7, 0xb7 },
    1484                 : { 0x00, 0xb8, 0xb8 },
    1485                 : { 0x00, 0xb9, 0x49 },
    1486                 : { 0x00, 0xba, 0xaa },
    1487                 : { 0x00, 0xbb, 0xab },
    1488                 : { 0x00, 0xbc, 0xac },
    1489                 : { 0x00, 0xbd, 0xbd },
    1490                 : { 0x00, 0xbe, 0xbe },
    1491                 : { 0x00, 0xbf, 0xaf },
    1492                 : { 0x01, 0xe0, 0xc0 },
    1493                 : { 0x01, 0xe1, 0xc1 },
    1494                 : { 0x01, 0xe2, 0xc2 },
    1495                 : { 0x00, 0xc3, 0xc3 },
    1496                 : { 0x01, 0xe4, 0xc4 },
    1497                 : { 0x01, 0xe5, 0xc5 },
    1498                 : { 0x01, 0xe6, 0xc6 },
    1499                 : { 0x01, 0xe7, 0xc7 },
    1500                 : { 0x01, 0xe8, 0xc8 },
    1501                 : { 0x01, 0xe9, 0xc9 },
    1502                 : { 0x01, 0xea, 0xca },
    1503                 : { 0x01, 0xeb, 0xcb },
    1504                 : { 0x01, 0xec, 0xcc },
    1505                 : { 0x01, 0xed, 0xcd },
    1506                 : { 0x01, 0xee, 0xce },
    1507                 : { 0x01, 0xef, 0xcf },
    1508                 : { 0x00, 0xd0, 0xd0 },
    1509                 : { 0x01, 0xf1, 0xd1 },
    1510                 : { 0x01, 0xf2, 0xd2 },
    1511                 : { 0x01, 0xf3, 0xd3 },
    1512                 : { 0x01, 0xf4, 0xd4 },
    1513                 : { 0x01, 0xf5, 0xd5 },
    1514                 : { 0x01, 0xf6, 0xd6 },
    1515                 : { 0x00, 0xd7, 0xd7 },
    1516                 : { 0x01, 0xf8, 0xd8 },
    1517                 : { 0x01, 0xf9, 0xd9 },
    1518                 : { 0x01, 0xfa, 0xda },
    1519                 : { 0x01, 0xfb, 0xdb },
    1520                 : { 0x01, 0xfc, 0xdc },
    1521                 : { 0x01, 0xfd, 0xdd },
    1522                 : { 0x01, 0xfe, 0xde },
    1523                 : { 0x00, 0xdf, 0xdf },
    1524                 : { 0x00, 0xe0, 0xc0 },
    1525                 : { 0x00, 0xe1, 0xc1 },
    1526                 : { 0x00, 0xe2, 0xc2 },
    1527                 : { 0x00, 0xe3, 0xe3 },
    1528                 : { 0x00, 0xe4, 0xc4 },
    1529                 : { 0x00, 0xe5, 0xc5 },
    1530                 : { 0x00, 0xe6, 0xc6 },
    1531                 : { 0x00, 0xe7, 0xc7 },
    1532                 : { 0x00, 0xe8, 0xc8 },
    1533                 : { 0x00, 0xe9, 0xc9 },
    1534                 : { 0x00, 0xea, 0xca },
    1535                 : { 0x00, 0xeb, 0xcb },
    1536                 : { 0x00, 0xec, 0xcc },
    1537                 : { 0x00, 0xed, 0xcd },
    1538                 : { 0x00, 0xee, 0xce },
    1539                 : { 0x00, 0xef, 0xcf },
    1540                 : { 0x00, 0xf0, 0xf0 },
    1541                 : { 0x00, 0xf1, 0xd1 },
    1542                 : { 0x00, 0xf2, 0xd2 },
    1543                 : { 0x00, 0xf3, 0xd3 },
    1544                 : { 0x00, 0xf4, 0xd4 },
    1545                 : { 0x00, 0xf5, 0xd5 },
    1546                 : { 0x00, 0xf6, 0xd6 },
    1547                 : { 0x00, 0xf7, 0xf7 },
    1548                 : { 0x00, 0xf8, 0xd8 },
    1549                 : { 0x00, 0xf9, 0xd9 },
    1550                 : { 0x00, 0xfa, 0xda },
    1551                 : { 0x00, 0xfb, 0xdb },
    1552                 : { 0x00, 0xfc, 0xdc },
    1553                 : { 0x00, 0xfd, 0xdd },
    1554                 : { 0x00, 0xfe, 0xde },
    1555                 : { 0x00, 0xff, 0xff }
    1556                 : };
    1557                 : 
    1558                 : static struct cs_info iso4_tbl[] = {
    1559                 : { 0x00, 0x00, 0x00 },
    1560                 : { 0x00, 0x01, 0x01 },
    1561                 : { 0x00, 0x02, 0x02 },
    1562                 : { 0x00, 0x03, 0x03 },
    1563                 : { 0x00, 0x04, 0x04 },
    1564                 : { 0x00, 0x05, 0x05 },
    1565                 : { 0x00, 0x06, 0x06 },
    1566                 : { 0x00, 0x07, 0x07 },
    1567                 : { 0x00, 0x08, 0x08 },
    1568                 : { 0x00, 0x09, 0x09 },
    1569                 : { 0x00, 0x0a, 0x0a },
    1570                 : { 0x00, 0x0b, 0x0b },
    1571                 : { 0x00, 0x0c, 0x0c },
    1572                 : { 0x00, 0x0d, 0x0d },
    1573                 : { 0x00, 0x0e, 0x0e },
    1574                 : { 0x00, 0x0f, 0x0f },
    1575                 : { 0x00, 0x10, 0x10 },
    1576                 : { 0x00, 0x11, 0x11 },
    1577                 : { 0x00, 0x12, 0x12 },
    1578                 : { 0x00, 0x13, 0x13 },
    1579                 : { 0x00, 0x14, 0x14 },
    1580                 : { 0x00, 0x15, 0x15 },
    1581                 : { 0x00, 0x16, 0x16 },
    1582                 : { 0x00, 0x17, 0x17 },
    1583                 : { 0x00, 0x18, 0x18 },
    1584                 : { 0x00, 0x19, 0x19 },
    1585                 : { 0x00, 0x1a, 0x1a },
    1586                 : { 0x00, 0x1b, 0x1b },
    1587                 : { 0x00, 0x1c, 0x1c },
    1588                 : { 0x00, 0x1d, 0x1d },
    1589                 : { 0x00, 0x1e, 0x1e },
    1590                 : { 0x00, 0x1f, 0x1f },
    1591                 : { 0x00, 0x20, 0x20 },
    1592                 : { 0x00, 0x21, 0x21 },
    1593                 : { 0x00, 0x22, 0x22 },
    1594                 : { 0x00, 0x23, 0x23 },
    1595                 : { 0x00, 0x24, 0x24 },
    1596                 : { 0x00, 0x25, 0x25 },
    1597                 : { 0x00, 0x26, 0x26 },
    1598                 : { 0x00, 0x27, 0x27 },
    1599                 : { 0x00, 0x28, 0x28 },
    1600                 : { 0x00, 0x29, 0x29 },
    1601                 : { 0x00, 0x2a, 0x2a },
    1602                 : { 0x00, 0x2b, 0x2b },
    1603                 : { 0x00, 0x2c, 0x2c },
    1604                 : { 0x00, 0x2d, 0x2d },
    1605                 : { 0x00, 0x2e, 0x2e },
    1606                 : { 0x00, 0x2f, 0x2f },
    1607                 : { 0x00, 0x30, 0x30 },
    1608                 : { 0x00, 0x31, 0x31 },
    1609                 : { 0x00, 0x32, 0x32 },
    1610                 : { 0x00, 0x33, 0x33 },
    1611                 : { 0x00, 0x34, 0x34 },
    1612                 : { 0x00, 0x35, 0x35 },
    1613                 : { 0x00, 0x36, 0x36 },
    1614                 : { 0x00, 0x37, 0x37 },
    1615                 : { 0x00, 0x38, 0x38 },
    1616                 : { 0x00, 0x39, 0x39 },
    1617                 : { 0x00, 0x3a, 0x3a },
    1618                 : { 0x00, 0x3b, 0x3b },
    1619                 : { 0x00, 0x3c, 0x3c },
    1620                 : { 0x00, 0x3d, 0x3d },
    1621                 : { 0x00, 0x3e, 0x3e },
    1622                 : { 0x00, 0x3f, 0x3f },
    1623                 : { 0x00, 0x40, 0x40 },
    1624                 : { 0x01, 0x61, 0x41 },
    1625                 : { 0x01, 0x62, 0x42 },
    1626                 : { 0x01, 0x63, 0x43 },
    1627                 : { 0x01, 0x64, 0x44 },
    1628                 : { 0x01, 0x65, 0x45 },
    1629                 : { 0x01, 0x66, 0x46 },
    1630                 : { 0x01, 0x67, 0x47 },
    1631                 : { 0x01, 0x68, 0x48 },
    1632                 : { 0x01, 0x69, 0x49 },
    1633                 : { 0x01, 0x6a, 0x4a },
    1634                 : { 0x01, 0x6b, 0x4b },
    1635                 : { 0x01, 0x6c, 0x4c },
    1636                 : { 0x01, 0x6d, 0x4d },
    1637                 : { 0x01, 0x6e, 0x4e },
    1638                 : { 0x01, 0x6f, 0x4f },
    1639                 : { 0x01, 0x70, 0x50 },
    1640                 : { 0x01, 0x71, 0x51 },
    1641                 : { 0x01, 0x72, 0x52 },
    1642                 : { 0x01, 0x73, 0x53 },
    1643                 : { 0x01, 0x74, 0x54 },
    1644                 : { 0x01, 0x75, 0x55 },
    1645                 : { 0x01, 0x76, 0x56 },
    1646                 : { 0x01, 0x77, 0x57 },
    1647                 : { 0x01, 0x78, 0x58 },
    1648                 : { 0x01, 0x79, 0x59 },
    1649                 : { 0x01, 0x7a, 0x5a },
    1650                 : { 0x00, 0x5b, 0x5b },
    1651                 : { 0x00, 0x5c, 0x5c },
    1652                 : { 0x00, 0x5d, 0x5d },
    1653                 : { 0x00, 0x5e, 0x5e },
    1654                 : { 0x00, 0x5f, 0x5f },
    1655                 : { 0x00, 0x60, 0x60 },
    1656                 : { 0x00, 0x61, 0x41 },
    1657                 : { 0x00, 0x62, 0x42 },
    1658                 : { 0x00, 0x63, 0x43 },
    1659                 : { 0x00, 0x64, 0x44 },
    1660                 : { 0x00, 0x65, 0x45 },
    1661                 : { 0x00, 0x66, 0x46 },
    1662                 : { 0x00, 0x67, 0x47 },
    1663                 : { 0x00, 0x68, 0x48 },
    1664                 : { 0x00, 0x69, 0x49 },
    1665                 : { 0x00, 0x6a, 0x4a },
    1666                 : { 0x00, 0x6b, 0x4b },
    1667                 : { 0x00, 0x6c, 0x4c },
    1668                 : { 0x00, 0x6d, 0x4d },
    1669                 : { 0x00, 0x6e, 0x4e },
    1670                 : { 0x00, 0x6f, 0x4f },
    1671                 : { 0x00, 0x70, 0x50 },
    1672                 : { 0x00, 0x71, 0x51 },
    1673                 : { 0x00, 0x72, 0x52 },
    1674                 : { 0x00, 0x73, 0x53 },
    1675                 : { 0x00, 0x74, 0x54 },
    1676                 : { 0x00, 0x75, 0x55 },
    1677                 : { 0x00, 0x76, 0x56 },
    1678                 : { 0x00, 0x77, 0x57 },
    1679                 : { 0x00, 0x78, 0x58 },
    1680                 : { 0x00, 0x79, 0x59 },
    1681                 : { 0x00, 0x7a, 0x5a },
    1682                 : { 0x00, 0x7b, 0x7b },
    1683                 : { 0x00, 0x7c, 0x7c },
    1684                 : { 0x00, 0x7d, 0x7d },
    1685                 : { 0x00, 0x7e, 0x7e },
    1686                 : { 0x00, 0x7f, 0x7f },
    1687                 : { 0x00, 0x80, 0x80 },
    1688                 : { 0x00, 0x81, 0x81 },
    1689                 : { 0x00, 0x82, 0x82 },
    1690                 : { 0x00, 0x83, 0x83 },
    1691                 : { 0x00, 0x84, 0x84 },
    1692                 : { 0x00, 0x85, 0x85 },
    1693                 : { 0x00, 0x86, 0x86 },
    1694                 : { 0x00, 0x87, 0x87 },
    1695                 : { 0x00, 0x88, 0x88 },
    1696                 : { 0x00, 0x89, 0x89 },
    1697                 : { 0x00, 0x8a, 0x8a },
    1698                 : { 0x00, 0x8b, 0x8b },
    1699                 : { 0x00, 0x8c, 0x8c },
    1700                 : { 0x00, 0x8d, 0x8d },
    1701                 : { 0x00, 0x8e, 0x8e },
    1702                 : { 0x00, 0x8f, 0x8f },
    1703                 : { 0x00, 0x90, 0x90 },
    1704                 : { 0x00, 0x91, 0x91 },
    1705                 : { 0x00, 0x92, 0x92 },
    1706                 : { 0x00, 0x93, 0x93 },
    1707                 : { 0x00, 0x94, 0x94 },
    1708                 : { 0x00, 0x95, 0x95 },
    1709                 : { 0x00, 0x96, 0x96 },
    1710                 : { 0x00, 0x97, 0x97 },
    1711                 : { 0x00, 0x98, 0x98 },
    1712                 : { 0x00, 0x99, 0x99 },
    1713                 : { 0x00, 0x9a, 0x9a },
    1714                 : { 0x00, 0x9b, 0x9b },
    1715                 : { 0x00, 0x9c, 0x9c },
    1716                 : { 0x00, 0x9d, 0x9d },
    1717                 : { 0x00, 0x9e, 0x9e },
    1718                 : { 0x00, 0x9f, 0x9f },
    1719                 : { 0x00, 0xa0, 0xa0 },
    1720                 : { 0x01, 0xb1, 0xa1 },
    1721                 : { 0x00, 0xa2, 0xa2 },
    1722                 : { 0x01, 0xb3, 0xa3 },
    1723                 : { 0x00, 0xa4, 0xa4 },
    1724                 : { 0x01, 0xb5, 0xa5 },
    1725                 : { 0x01, 0xb6, 0xa6 },
    1726                 : { 0x00, 0xa7, 0xa7 },
    1727                 : { 0x00, 0xa8, 0xa8 },
    1728                 : { 0x01, 0xb9, 0xa9 },
    1729                 : { 0x01, 0xba, 0xaa },
    1730                 : { 0x01, 0xbb, 0xab },
    1731                 : { 0x01, 0xbc, 0xac },
    1732                 : { 0x00, 0xad, 0xad },
    1733                 : { 0x01, 0xbe, 0xae },
    1734                 : { 0x00, 0xaf, 0xaf },
    1735                 : { 0x00, 0xb0, 0xb0 },
    1736                 : { 0x00, 0xb1, 0xa1 },
    1737                 : { 0x00, 0xb2, 0xb2 },
    1738                 : { 0x00, 0xb3, 0xa3 },
    1739                 : { 0x00, 0xb4, 0xb4 },
    1740                 : { 0x00, 0xb5, 0xa5 },
    1741                 : { 0x00, 0xb6, 0xa6 },
    1742                 : { 0x00, 0xb7, 0xb7 },
    1743                 : { 0x00, 0xb8, 0xb8 },
    1744                 : { 0x00, 0xb9, 0xa9 },
    1745                 : { 0x00, 0xba, 0xaa },
    1746                 : { 0x00, 0xbb, 0xab },
    1747                 : { 0x00, 0xbc, 0xac },
    1748                 : { 0x00, 0xbd, 0xbd },
    1749                 : { 0x00, 0xbe, 0xae },
    1750                 : { 0x00, 0xbf, 0xbf },
    1751                 : { 0x01, 0xe0, 0xc0 },
    1752                 : { 0x01, 0xe1, 0xc1 },
    1753                 : { 0x01, 0xe2, 0xc2 },
    1754                 : { 0x01, 0xe3, 0xc3 },
    1755                 : { 0x01, 0xe4, 0xc4 },
    1756                 : { 0x01, 0xe5, 0xc5 },
    1757                 : { 0x01, 0xe6, 0xc6 },
    1758                 : { 0x01, 0xe7, 0xc7 },
    1759                 : { 0x01, 0xe8, 0xc8 },
    1760                 : { 0x01, 0xe9, 0xc9 },
    1761                 : { 0x01, 0xea, 0xca },
    1762                 : { 0x01, 0xeb, 0xcb },
    1763                 : { 0x01, 0xec, 0xcc },
    1764                 : { 0x01, 0xed, 0xcd },
    1765                 : { 0x01, 0xee, 0xce },
    1766                 : { 0x01, 0xef, 0xcf },
    1767                 : { 0x01, 0xf0, 0xd0 },
    1768                 : { 0x01, 0xf1, 0xd1 },
    1769                 : { 0x01, 0xf2, 0xd2 },
    1770                 : { 0x01, 0xf3, 0xd3 },
    1771                 : { 0x01, 0xf4, 0xd4 },
    1772                 : { 0x01, 0xf5, 0xd5 },
    1773                 : { 0x01, 0xf6, 0xd6 },
    1774                 : { 0x00, 0xd7, 0xd7 },
    1775                 : { 0x01, 0xf8, 0xd8 },
    1776                 : { 0x01, 0xf9, 0xd9 },
    1777                 : { 0x01, 0xfa, 0xda },
    1778                 : { 0x01, 0xfb, 0xdb },
    1779                 : { 0x01, 0xfc, 0xdc },
    1780                 : { 0x01, 0xfd, 0xdd },
    1781                 : { 0x01, 0xfe, 0xde },
    1782                 : { 0x00, 0xdf, 0xdf },
    1783                 : { 0x00, 0xe0, 0xc0 },
    1784                 : { 0x00, 0xe1, 0xc1 },
    1785                 : { 0x00, 0xe2, 0xc2 },
    1786                 : { 0x00, 0xe3, 0xc3 },
    1787                 : { 0x00, 0xe4, 0xc4 },
    1788                 : { 0x00, 0xe5, 0xc5 },
    1789                 : { 0x00, 0xe6, 0xc6 },
    1790                 : { 0x00, 0xe7, 0xc7 },
    1791                 : { 0x00, 0xe8, 0xc8 },
    1792                 : { 0x00, 0xe9, 0xc9 },
    1793                 : { 0x00, 0xea, 0xca },
    1794                 : { 0x00, 0xeb, 0xcb },
    1795                 : { 0x00, 0xec, 0xcc },
    1796                 : { 0x00, 0xed, 0xcd },
    1797                 : { 0x00, 0xee, 0xce },
    1798                 : { 0x00, 0xef, 0xcf },
    1799                 : { 0x00, 0xf0, 0xd0 },
    1800                 : { 0x00, 0xf1, 0xd1 },
    1801                 : { 0x00, 0xf2, 0xd2 },
    1802                 : { 0x00, 0xf3, 0xd3 },
    1803                 : { 0x00, 0xf4, 0xd4 },
    1804                 : { 0x00, 0xf5, 0xd5 },
    1805                 : { 0x00, 0xf6, 0xd6 },
    1806                 : { 0x00, 0xf7, 0xf7 },
    1807                 : { 0x00, 0xf8, 0xd8 },
    1808                 : { 0x00, 0xf9, 0xd9 },
    1809                 : { 0x00, 0xfa, 0xda },
    1810                 : { 0x00, 0xfb, 0xdb },
    1811                 : { 0x00, 0xfc, 0xdc },
    1812                 : { 0x00, 0xfd, 0xdd },
    1813                 : { 0x00, 0xfe, 0xde },
    1814                 : { 0x00, 0xff, 0xff }
    1815                 : };
    1816                 : 
    1817                 : static struct cs_info iso5_tbl[] = {
    1818                 : { 0x00, 0x00, 0x00 },
    1819                 : { 0x00, 0x01, 0x01 },
    1820                 : { 0x00, 0x02, 0x02 },
    1821                 : { 0x00, 0x03, 0x03 },
    1822                 : { 0x00, 0x04, 0x04 },
    1823                 : { 0x00, 0x05, 0x05 },
    1824                 : { 0x00, 0x06, 0x06 },
    1825                 : { 0x00, 0x07, 0x07 },
    1826                 : { 0x00, 0x08, 0x08 },
    1827                 : { 0x00, 0x09, 0x09 },
    1828                 : { 0x00, 0x0a, 0x0a },
    1829                 : { 0x00, 0x0b, 0x0b },
    1830                 : { 0x00, 0x0c, 0x0c },
    1831                 : { 0x00, 0x0d, 0x0d },
    1832                 : { 0x00, 0x0e, 0x0e },
    1833                 : { 0x00, 0x0f, 0x0f },
    1834                 : { 0x00, 0x10, 0x10 },
    1835                 : { 0x00, 0x11, 0x11 },
    1836                 : { 0x00, 0x12, 0x12 },
    1837                 : { 0x00, 0x13, 0x13 },
    1838                 : { 0x00, 0x14, 0x14 },
    1839                 : { 0x00, 0x15, 0x15 },
    1840                 : { 0x00, 0x16, 0x16 },
    1841                 : { 0x00, 0x17, 0x17 },
    1842                 : { 0x00, 0x18, 0x18 },
    1843                 : { 0x00, 0x19, 0x19 },
    1844                 : { 0x00, 0x1a, 0x1a },
    1845                 : { 0x00, 0x1b, 0x1b },
    1846                 : { 0x00, 0x1c, 0x1c },
    1847                 : { 0x00, 0x1d, 0x1d },
    1848                 : { 0x00, 0x1e, 0x1e },
    1849                 : { 0x00, 0x1f, 0x1f },
    1850                 : { 0x00, 0x20, 0x20 },
    1851                 : { 0x00, 0x21, 0x21 },
    1852                 : { 0x00, 0x22, 0x22 },
    1853                 : { 0x00, 0x23, 0x23 },
    1854                 : { 0x00, 0x24, 0x24 },
    1855                 : { 0x00, 0x25, 0x25 },
    1856                 : { 0x00, 0x26, 0x26 },
    1857                 : { 0x00, 0x27, 0x27 },
    1858                 : { 0x00, 0x28, 0x28 },
    1859                 : { 0x00, 0x29, 0x29 },
    1860                 : { 0x00, 0x2a, 0x2a },
    1861                 : { 0x00, 0x2b, 0x2b },
    1862                 : { 0x00, 0x2c, 0x2c },
    1863                 : { 0x00, 0x2d, 0x2d },
    1864                 : { 0x00, 0x2e, 0x2e },
    1865                 : { 0x00, 0x2f, 0x2f },
    1866                 : { 0x00, 0x30, 0x30 },
    1867                 : { 0x00, 0x31, 0x31 },
    1868                 : { 0x00, 0x32, 0x32 },
    1869                 : { 0x00, 0x33, 0x33 },
    1870                 : { 0x00, 0x34, 0x34 },
    1871                 : { 0x00, 0x35, 0x35 },
    1872                 : { 0x00, 0x36, 0x36 },
    1873                 : { 0x00, 0x37, 0x37 },
    1874                 : { 0x00, 0x38, 0x38 },
    1875                 : { 0x00, 0x39, 0x39 },
    1876                 : { 0x00, 0x3a, 0x3a },
    1877                 : { 0x00, 0x3b, 0x3b },
    1878                 : { 0x00, 0x3c, 0x3c },
    1879                 : { 0x00, 0x3d, 0x3d },
    1880                 : { 0x00, 0x3e, 0x3e },
    1881                 : { 0x00, 0x3f, 0x3f },
    1882                 : { 0x00, 0x40, 0x40 },
    1883                 : { 0x01, 0x61, 0x41 },
    1884                 : { 0x01, 0x62, 0x42 },
    1885                 : { 0x01, 0x63, 0x43 },
    1886                 : { 0x01, 0x64, 0x44 },
    1887                 : { 0x01, 0x65, 0x45 },
    1888                 : { 0x01, 0x66, 0x46 },
    1889                 : { 0x01, 0x67, 0x47 },
    1890                 : { 0x01, 0x68, 0x48 },
    1891                 : { 0x01, 0x69, 0x49 },
    1892                 : { 0x01, 0x6a, 0x4a },
    1893                 : { 0x01, 0x6b, 0x4b },
    1894                 : { 0x01, 0x6c, 0x4c },
    1895                 : { 0x01, 0x6d, 0x4d },
    1896                 : { 0x01, 0x6e, 0x4e },
    1897                 : { 0x01, 0x6f, 0x4f },
    1898                 : { 0x01, 0x70, 0x50 },
    1899                 : { 0x01, 0x71, 0x51 },
    1900                 : { 0x01, 0x72, 0x52 },
    1901                 : { 0x01, 0x73, 0x53 },
    1902                 : { 0x01, 0x74, 0x54 },
    1903                 : { 0x01, 0x75, 0x55 },
    1904                 : { 0x01, 0x76, 0x56 },
    1905                 : { 0x01, 0x77, 0x57 },
    1906                 : { 0x01, 0x78, 0x58 },
    1907                 : { 0x01, 0x79, 0x59 },
    1908                 : { 0x01, 0x7a, 0x5a },
    1909                 : { 0x00, 0x5b, 0x5b },
    1910                 : { 0x00, 0x5c, 0x5c },
    1911                 : { 0x00, 0x5d, 0x5d },
    1912                 : { 0x00, 0x5e, 0x5e },
    1913                 : { 0x00, 0x5f, 0x5f },
    1914                 : { 0x00, 0x60, 0x60 },
    1915                 : { 0x00, 0x61, 0x41 },
    1916                 : { 0x00, 0x62, 0x42 },
    1917                 : { 0x00, 0x63, 0x43 },
    1918                 : { 0x00, 0x64, 0x44 },
    1919                 : { 0x00, 0x65, 0x45 },
    1920                 : { 0x00, 0x66, 0x46 },
    1921                 : { 0x00, 0x67, 0x47 },
    1922                 : { 0x00, 0x68, 0x48 },
    1923                 : { 0x00, 0x69, 0x49 },
    1924                 : { 0x00, 0x6a, 0x4a },
    1925                 : { 0x00, 0x6b, 0x4b },
    1926                 : { 0x00, 0x6c, 0x4c },
    1927                 : { 0x00, 0x6d, 0x4d },
    1928                 : { 0x00, 0x6e, 0x4e },
    1929                 : { 0x00, 0x6f, 0x4f },
    1930                 : { 0x00, 0x70, 0x50 },
    1931                 : { 0x00, 0x71, 0x51 },
    1932                 : { 0x00, 0x72, 0x52 },
    1933                 : { 0x00, 0x73, 0x53 },
    1934                 : { 0x00, 0x74, 0x54 },
    1935                 : { 0x00, 0x75, 0x55 },
    1936                 : { 0x00, 0x76, 0x56 },
    1937                 : { 0x00, 0x77, 0x57 },
    1938                 : { 0x00, 0x78, 0x58 },
    1939                 : { 0x00, 0x79, 0x59 },
    1940                 : { 0x00, 0x7a, 0x5a },
    1941                 : { 0x00, 0x7b, 0x7b },
    1942                 : { 0x00, 0x7c, 0x7c },
    1943                 : { 0x00, 0x7d, 0x7d },
    1944                 : { 0x00, 0x7e, 0x7e },
    1945                 : { 0x00, 0x7f, 0x7f },
    1946                 : { 0x00, 0x80, 0x80 },
    1947                 : { 0x00, 0x81, 0x81 },
    1948                 : { 0x00, 0x82, 0x82 },
    1949                 : { 0x00, 0x83, 0x83 },
    1950                 : { 0x00, 0x84, 0x84 },
    1951                 : { 0x00, 0x85, 0x85 },
    1952                 : { 0x00, 0x86, 0x86 },
    1953                 : { 0x00, 0x87, 0x87 },
    1954                 : { 0x00, 0x88, 0x88 },
    1955                 : { 0x00, 0x89, 0x89 },
    1956                 : { 0x00, 0x8a, 0x8a },
    1957                 : { 0x00, 0x8b, 0x8b },
    1958                 : { 0x00, 0x8c, 0x8c },
    1959                 : { 0x00, 0x8d, 0x8d },
    1960                 : { 0x00, 0x8e, 0x8e },
    1961                 : { 0x00, 0x8f, 0x8f },
    1962                 : { 0x00, 0x90, 0x90 },
    1963                 : { 0x00, 0x91, 0x91 },
    1964                 : { 0x00, 0x92, 0x92 },
    1965                 : { 0x00, 0x93, 0x93 },
    1966                 : { 0x00, 0x94, 0x94 },
    1967                 : { 0x00, 0x95, 0x95 },
    1968                 : { 0x00, 0x96, 0x96 },
    1969                 : { 0x00, 0x97, 0x97 },
    1970                 : { 0x00, 0x98, 0x98 },
    1971                 : { 0x00, 0x99, 0x99 },
    1972                 : { 0x00, 0x9a, 0x9a },
    1973                 : { 0x00, 0x9b, 0x9b },
    1974                 : { 0x00, 0x9c, 0x9c },
    1975                 : { 0x00, 0x9d, 0x9d },
    1976                 : { 0x00, 0x9e, 0x9e },
    1977                 : { 0x00, 0x9f, 0x9f },
    1978                 : { 0x00, 0xa0, 0xa0 },
    1979                 : { 0x01, 0xf1, 0xa1 },
    1980                 : { 0x01, 0xf2, 0xa2 },
    1981                 : { 0x01, 0xf3, 0xa3 },
    1982                 : { 0x01, 0xf4, 0xa4 },
    1983                 : { 0x01, 0xf5, 0xa5 },
    1984                 : { 0x01, 0xf6, 0xa6 },
    1985                 : { 0x01, 0xf7, 0xa7 },
    1986                 : { 0x01, 0xf8, 0xa8 },
    1987                 : { 0x01, 0xf9, 0xa9 },
    1988                 : { 0x01, 0xfa, 0xaa },
    1989                 : { 0x01, 0xfb, 0xab },
    1990                 : { 0x01, 0xfc, 0xac },
    1991                 : { 0x00, 0xad, 0xad },
    1992                 : { 0x01, 0xfe, 0xae },
    1993                 : { 0x01, 0xff, 0xaf },
    1994                 : { 0x01, 0xd0, 0xb0 },
    1995                 : { 0x01, 0xd1, 0xb1 },
    1996                 : { 0x01, 0xd2, 0xb2 },
    1997                 : { 0x01, 0xd3, 0xb3 },
    1998                 : { 0x01, 0xd4, 0xb4 },
    1999                 : { 0x01, 0xd5, 0xb5 },
    2000                 : { 0x01, 0xd6, 0xb6 },
    2001                 : { 0x01, 0xd7, 0xb7 },
    2002                 : { 0x01, 0xd8, 0xb8 },
    2003                 : { 0x01, 0xd9, 0xb9 },
    2004                 : { 0x01, 0xda, 0xba },
    2005                 : { 0x01, 0xdb, 0xbb },
    2006                 : { 0x01, 0xdc, 0xbc },
    2007                 : { 0x01, 0xdd, 0xbd },
    2008                 : { 0x01, 0xde, 0xbe },
    2009                 : { 0x01, 0xdf, 0xbf },
    2010                 : { 0x01, 0xe0, 0xc0 },
    2011                 : { 0x01, 0xe1, 0xc1 },
    2012                 : { 0x01, 0xe2, 0xc2 },
    2013                 : { 0x01, 0xe3, 0xc3 },
    2014                 : { 0x01, 0xe4, 0xc4 },
    2015                 : { 0x01, 0xe5, 0xc5 },
    2016                 : { 0x01, 0xe6, 0xc6 },
    2017                 : { 0x01, 0xe7, 0xc7 },
    2018                 : { 0x01, 0xe8, 0xc8 },
    2019                 : { 0x01, 0xe9, 0xc9 },
    2020                 : { 0x01, 0xea, 0xca },
    2021                 : { 0x01, 0xeb, 0xcb },
    2022                 : { 0x01, 0xec, 0xcc },
    2023                 : { 0x01, 0xed, 0xcd },
    2024                 : { 0x01, 0xee, 0xce },
    2025                 : { 0x01, 0xef, 0xcf },
    2026                 : { 0x00, 0xd0, 0xb0 },
    2027                 : { 0x00, 0xd1, 0xb1 },
    2028                 : { 0x00, 0xd2, 0xb2 },
    2029                 : { 0x00, 0xd3, 0xb3 },
    2030                 : { 0x00, 0xd4, 0xb4 },
    2031                 : { 0x00, 0xd5, 0xb5 },
    2032                 : { 0x00, 0xd6, 0xb6 },
    2033                 : { 0x00, 0xd7, 0xb7 },
    2034                 : { 0x00, 0xd8, 0xb8 },
    2035                 : { 0x00, 0xd9, 0xb9 },
    2036                 : { 0x00, 0xda, 0xba },
    2037                 : { 0x00, 0xdb, 0xbb },
    2038                 : { 0x00, 0xdc, 0xbc },
    2039                 : { 0x00, 0xdd, 0xbd },
    2040                 : { 0x00, 0xde, 0xbe },
    2041                 : { 0x00, 0xdf, 0xbf },
    2042                 : { 0x00, 0xe0, 0xc0 },
    2043                 : { 0x00, 0xe1, 0xc1 },
    2044                 : { 0x00, 0xe2, 0xc2 },
    2045                 : { 0x00, 0xe3, 0xc3 },
    2046                 : { 0x00, 0xe4, 0xc4 },
    2047                 : { 0x00, 0xe5, 0xc5 },
    2048                 : { 0x00, 0xe6, 0xc6 },
    2049                 : { 0x00, 0xe7, 0xc7 },
    2050                 : { 0x00, 0xe8, 0xc8 },
    2051                 : { 0x00, 0xe9, 0xc9 },
    2052                 : { 0x00, 0xea, 0xca },
    2053                 : { 0x00, 0xeb, 0xcb },
    2054                 : { 0x00, 0xec, 0xcc },
    2055                 : { 0x00, 0xed, 0xcd },
    2056                 : { 0x00, 0xee, 0xce },
    2057                 : { 0x00, 0xef, 0xcf },
    2058                 : { 0x00, 0xf0, 0xf0 },
    2059                 : { 0x00, 0xf1, 0xa1 },
    2060                 : { 0x00, 0xf2, 0xa2 },
    2061                 : { 0x00, 0xf3, 0xa3 },
    2062                 : { 0x00, 0xf4, 0xa4 },
    2063                 : { 0x00, 0xf5, 0xa5 },
    2064                 : { 0x00, 0xf6, 0xa6 },
    2065                 : { 0x00, 0xf7, 0xa7 },
    2066                 : { 0x00, 0xf8, 0xa8 },
    2067                 : { 0x00, 0xf9, 0xa9 },
    2068                 : { 0x00, 0xfa, 0xaa },
    2069                 : { 0x00, 0xfb, 0xab },
    2070                 : { 0x00, 0xfc, 0xac },
    2071                 : { 0x00, 0xfd, 0xfd },
    2072                 : { 0x00, 0xfe, 0xae },
    2073                 : { 0x00, 0xff, 0xaf }
    2074                 : };
    2075                 : 
    2076                 : static struct cs_info iso6_tbl[] = {
    2077                 : { 0x00, 0x00, 0x00 },
    2078                 : { 0x00, 0x01, 0x01 },
    2079                 : { 0x00, 0x02, 0x02 },
    2080                 : { 0x00, 0x03, 0x03 },
    2081                 : { 0x00, 0x04, 0x04 },
    2082                 : { 0x00, 0x05, 0x05 },
    2083                 : { 0x00, 0x06, 0x06 },
    2084                 : { 0x00, 0x07, 0x07 },
    2085                 : { 0x00, 0x08, 0x08 },
    2086                 : { 0x00, 0x09, 0x09 },
    2087                 : { 0x00, 0x0a, 0x0a },
    2088                 : { 0x00, 0x0b, 0x0b },
    2089                 : { 0x00, 0x0c, 0x0c },
    2090                 : { 0x00, 0x0d, 0x0d },
    2091                 : { 0x00, 0x0e, 0x0e },
    2092                 : { 0x00, 0x0f, 0x0f },
    2093                 : { 0x00, 0x10, 0x10 },
    2094                 : { 0x00, 0x11, 0x11 },
    2095                 : { 0x00, 0x12, 0x12 },
    2096                 : { 0x00, 0x13, 0x13 },
    2097                 : { 0x00, 0x14, 0x14 },
    2098                 : { 0x00, 0x15, 0x15 },
    2099                 : { 0x00, 0x16, 0x16 },
    2100                 : { 0x00, 0x17, 0x17 },
    2101                 : { 0x00, 0x18, 0x18 },
    2102                 : { 0x00, 0x19, 0x19 },
    2103                 : { 0x00, 0x1a, 0x1a },
    2104                 : { 0x00, 0x1b, 0x1b },
    2105                 : { 0x00, 0x1c, 0x1c },
    2106                 : { 0x00, 0x1d, 0x1d },
    2107                 : { 0x00, 0x1e, 0x1e },
    2108                 : { 0x00, 0x1f, 0x1f },
    2109                 : { 0x00, 0x20, 0x20 },
    2110                 : { 0x00, 0x21, 0x21 },
    2111                 : { 0x00, 0x22, 0x22 },
    2112                 : { 0x00, 0x23, 0x23 },
    2113                 : { 0x00, 0x24, 0x24 },
    2114                 : { 0x00, 0x25, 0x25 },
    2115                 : { 0x00, 0x26, 0x26 },
    2116                 : { 0x00, 0x27, 0x27 },
    2117                 : { 0x00, 0x28, 0x28 },
    2118                 : { 0x00, 0x29, 0x29 },
    2119                 : { 0x00, 0x2a, 0x2a },
    2120                 : { 0x00, 0x2b, 0x2b },
    2121                 : { 0x00, 0x2c, 0x2c },
    2122                 : { 0x00, 0x2d, 0x2d },
    2123                 : { 0x00, 0x2e, 0x2e },
    2124                 : { 0x00, 0x2f, 0x2f },
    2125                 : { 0x00, 0x30, 0x30 },
    2126                 : { 0x00, 0x31, 0x31 },
    2127                 : { 0x00, 0x32, 0x32 },
    2128                 : { 0x00, 0x33, 0x33 },
    2129                 : { 0x00, 0x34, 0x34 },
    2130                 : { 0x00, 0x35, 0x35 },
    2131                 : { 0x00, 0x36, 0x36 },
    2132                 : { 0x00, 0x37, 0x37 },
    2133                 : { 0x00, 0x38, 0x38 },
    2134                 : { 0x00, 0x39, 0x39 },
    2135                 : { 0x00, 0x3a, 0x3a },
    2136                 : { 0x00, 0x3b, 0x3b },
    2137                 : { 0x00, 0x3c, 0x3c },
    2138                 : { 0x00, 0x3d, 0x3d },
    2139                 : { 0x00, 0x3e, 0x3e },
    2140                 : { 0x00, 0x3f, 0x3f },
    2141                 : { 0x00, 0x40, 0x40 },
    2142                 : { 0x01, 0x61, 0x41 },
    2143                 : { 0x01, 0x62, 0x42 },
    2144                 : { 0x01, 0x63, 0x43 },
    2145                 : { 0x01, 0x64, 0x44 },
    2146                 : { 0x01, 0x65, 0x45 },
    2147                 : { 0x01, 0x66, 0x46 },
    2148                 : { 0x01, 0x67, 0x47 },
    2149                 : { 0x01, 0x68, 0x48 },
    2150                 : { 0x01, 0x69, 0x49 },
    2151                 : { 0x01, 0x6a, 0x4a },
    2152                 : { 0x01, 0x6b, 0x4b },
    2153                 : { 0x01, 0x6c, 0x4c },
    2154                 : { 0x01, 0x6d, 0x4d },
    2155                 : { 0x01, 0x6e, 0x4e },
    2156                 : { 0x01, 0x6f, 0x4f },
    2157                 : { 0x01, 0x70, 0x50 },
    2158                 : { 0x01, 0x71, 0x51 },
    2159                 : { 0x01, 0x72, 0x52 },
    2160                 : { 0x01, 0x73, 0x53 },
    2161                 : { 0x01, 0x74, 0x54 },
    2162                 : { 0x01, 0x75, 0x55 },
    2163                 : { 0x01, 0x76, 0x56 },
    2164                 : { 0x01, 0x77, 0x57 },
    2165                 : { 0x01, 0x78, 0x58 },
    2166                 : { 0x01, 0x79, 0x59 },
    2167                 : { 0x01, 0x7a, 0x5a },
    2168                 : { 0x00, 0x5b, 0x5b },
    2169                 : { 0x00, 0x5c, 0x5c },
    2170                 : { 0x00, 0x5d, 0x5d },
    2171                 : { 0x00, 0x5e, 0x5e },
    2172                 : { 0x00, 0x5f, 0x5f },
    2173                 : { 0x00, 0x60, 0x60 },
    2174                 : { 0x00, 0x61, 0x41 },
    2175                 : { 0x00, 0x62, 0x42 },
    2176                 : { 0x00, 0x63, 0x43 },
    2177                 : { 0x00, 0x64, 0x44 },
    2178                 : { 0x00, 0x65, 0x45 },
    2179                 : { 0x00, 0x66, 0x46 },
    2180                 : { 0x00, 0x67, 0x47 },
    2181                 : { 0x00, 0x68, 0x48 },
    2182                 : { 0x00, 0x69, 0x49 },
    2183                 : { 0x00, 0x6a, 0x4a },
    2184                 : { 0x00, 0x6b, 0x4b },
    2185                 : { 0x00, 0x6c, 0x4c },
    2186                 : { 0x00, 0x6d, 0x4d },
    2187                 : { 0x00, 0x6e, 0x4e },
    2188                 : { 0x00, 0x6f, 0x4f },
    2189                 : { 0x00, 0x70, 0x50 },
    2190                 : { 0x00, 0x71, 0x51 },
    2191                 : { 0x00, 0x72, 0x52 },
    2192                 : { 0x00, 0x73, 0x53 },
    2193                 : { 0x00, 0x74, 0x54 },
    2194                 : { 0x00, 0x75, 0x55 },
    2195                 : { 0x00, 0x76, 0x56 },
    2196                 : { 0x00, 0x77, 0x57 },
    2197                 : { 0x00, 0x78, 0x58 },
    2198                 : { 0x00, 0x79, 0x59 },
    2199                 : { 0x00, 0x7a, 0x5a },
    2200                 : { 0x00, 0x7b, 0x7b },
    2201                 : { 0x00, 0x7c, 0x7c },
    2202                 : { 0x00, 0x7d, 0x7d },
    2203                 : { 0x00, 0x7e, 0x7e },
    2204                 : { 0x00, 0x7f, 0x7f },
    2205                 : { 0x00, 0x80, 0x80 },
    2206                 : { 0x00, 0x81, 0x81 },
    2207                 : { 0x00, 0x82, 0x82 },
    2208                 : { 0x00, 0x83, 0x83 },
    2209                 : { 0x00, 0x84, 0x84 },
    2210                 : { 0x00, 0x85, 0x85 },
    2211                 : { 0x00, 0x86, 0x86 },
    2212                 : { 0x00, 0x87, 0x87 },
    2213                 : { 0x00, 0x88, 0x88 },
    2214                 : { 0x00, 0x89, 0x89 },
    2215                 : { 0x00, 0x8a, 0x8a },
    2216                 : { 0x00, 0x8b, 0x8b },
    2217                 : { 0x00, 0x8c, 0x8c },
    2218                 : { 0x00, 0x8d, 0x8d },
    2219                 : { 0x00, 0x8e, 0x8e },
    2220                 : { 0x00, 0x8f, 0x8f },
    2221                 : { 0x00, 0x90, 0x90 },
    2222                 : { 0x00, 0x91, 0x91 },
    2223                 : { 0x00, 0x92, 0x92 },
    2224                 : { 0x00, 0x93, 0x93 },
    2225                 : { 0x00, 0x94, 0x94 },
    2226                 : { 0x00, 0x95, 0x95 },
    2227                 : { 0x00, 0x96, 0x96 },
    2228                 : { 0x00, 0x97, 0x97 },
    2229                 : { 0x00, 0x98, 0x98 },
    2230                 : { 0x00, 0x99, 0x99 },
    2231                 : { 0x00, 0x9a, 0x9a },
    2232                 : { 0x00, 0x9b, 0x9b },
    2233                 : { 0x00, 0x9c, 0x9c },
    2234                 : { 0x00, 0x9d, 0x9d },
    2235                 : { 0x00, 0x9e, 0x9e },
    2236                 : { 0x00, 0x9f, 0x9f },
    2237                 : { 0x00, 0xa0, 0xa0 },
    2238                 : { 0x00, 0xa1, 0xa1 },
    2239                 : { 0x00, 0xa2, 0xa2 },
    2240                 : { 0x00, 0xa3, 0xa3 },
    2241                 : { 0x00, 0xa4, 0xa4 },
    2242                 : { 0x00, 0xa5, 0xa5 },
    2243                 : { 0x00, 0xa6, 0xa6 },
    2244                 : { 0x00, 0xa7, 0xa7 },
    2245                 : { 0x00, 0xa8, 0xa8 },
    2246                 : { 0x00, 0xa9, 0xa9 },
    2247                 : { 0x00, 0xaa, 0xaa },
    2248                 : { 0x00, 0xab, 0xab },
    2249                 : { 0x00, 0xac, 0xac },
    2250                 : { 0x00, 0xad, 0xad },
    2251                 : { 0x00, 0xae, 0xae },
    2252                 : { 0x00, 0xaf, 0xaf },
    2253                 : { 0x00, 0xb0, 0xb0 },
    2254                 : { 0x00, 0xb1, 0xb1 },
    2255                 : { 0x00, 0xb2, 0xb2 },
    2256                 : { 0x00, 0xb3, 0xb3 },
    2257                 : { 0x00, 0xb4, 0xb4 },
    2258                 : { 0x00, 0xb5, 0xb5 },
    2259                 : { 0x00, 0xb6, 0xb6 },
    2260                 : { 0x00, 0xb7, 0xb7 },
    2261                 : { 0x00, 0xb8, 0xb8 },
    2262                 : { 0x00, 0xb9, 0xb9 },
    2263                 : { 0x00, 0xba, 0xba },
    2264                 : { 0x00, 0xbb, 0xbb },
    2265                 : { 0x00, 0xbc, 0xbc },
    2266                 : { 0x00, 0xbd, 0xbd },
    2267                 : { 0x00, 0xbe, 0xbe },
    2268                 : { 0x00, 0xbf, 0xbf },
    2269                 : { 0x00, 0xc0, 0xc0 },
    2270                 : { 0x00, 0xc1, 0xc1 },
    2271                 : { 0x00, 0xc2, 0xc2 },
    2272                 : { 0x00, 0xc3, 0xc3 },
    2273                 : { 0x00, 0xc4, 0xc4 },
    2274                 : { 0x00, 0xc5, 0xc5 },
    2275                 : { 0x00, 0xc6, 0xc6 },
    2276                 : { 0x00, 0xc7, 0xc7 },
    2277                 : { 0x00, 0xc8, 0xc8 },
    2278                 : { 0x00, 0xc9, 0xc9 },
    2279                 : { 0x00, 0xca, 0xca },
    2280                 : { 0x00, 0xcb, 0xcb },
    2281                 : { 0x00, 0xcc, 0xcc },
    2282                 : { 0x00, 0xcd, 0xcd },
    2283                 : { 0x00, 0xce, 0xce },
    2284                 : { 0x00, 0xcf, 0xcf },
    2285                 : { 0x00, 0xd0, 0xd0 },
    2286                 : { 0x00, 0xd1, 0xd1 },
    2287                 : { 0x00, 0xd2, 0xd2 },
    2288                 : { 0x00, 0xd3, 0xd3 },
    2289                 : { 0x00, 0xd4, 0xd4 },
    2290                 : { 0x00, 0xd5, 0xd5 },
    2291                 : { 0x00, 0xd6, 0xd6 },
    2292                 : { 0x00, 0xd7, 0xd7 },
    2293                 : { 0x00, 0xd8, 0xd8 },
    2294                 : { 0x00, 0xd9, 0xd9 },
    2295                 : { 0x00, 0xda, 0xda },
    2296                 : { 0x00, 0xdb, 0xdb },
    2297                 : { 0x00, 0xdc, 0xdc },
    2298                 : { 0x00, 0xdd, 0xdd },
    2299                 : { 0x00, 0xde, 0xde },
    2300                 : { 0x00, 0xdf, 0xdf },
    2301                 : { 0x00, 0xe0, 0xe0 },
    2302                 : { 0x00, 0xe1, 0xe1 },
    2303                 : { 0x00, 0xe2, 0xe2 },
    2304                 : { 0x00, 0xe3, 0xe3 },
    2305                 : { 0x00, 0xe4, 0xe4 },
    2306                 : { 0x00, 0xe5, 0xe5 },
    2307                 : { 0x00, 0xe6, 0xe6 },
    2308                 : { 0x00, 0xe7, 0xe7 },
    2309                 : { 0x00, 0xe8, 0xe8 },
    2310                 : { 0x00, 0xe9, 0xe9 },
    2311                 : { 0x00, 0xea, 0xea },
    2312                 : { 0x00, 0xeb, 0xeb },
    2313                 : { 0x00, 0xec, 0xec },
    2314                 : { 0x00, 0xed, 0xed },
    2315                 : { 0x00, 0xee, 0xee },
    2316                 : { 0x00, 0xef, 0xef },
    2317                 : { 0x00, 0xf0, 0xf0 },
    2318                 : { 0x00, 0xf1, 0xf1 },
    2319                 : { 0x00, 0xf2, 0xf2 },
    2320                 : { 0x00, 0xf3, 0xf3 },
    2321                 : { 0x00, 0xf4, 0xf4 },
    2322                 : { 0x00, 0xf5, 0xf5 },
    2323                 : { 0x00, 0xf6, 0xf6 },
    2324                 : { 0x00, 0xf7, 0xf7 },
    2325                 : { 0x00, 0xf8, 0xf8 },
    2326                 : { 0x00, 0xf9, 0xf9 },
    2327                 : { 0x00, 0xfa, 0xfa },
    2328                 : { 0x00, 0xfb, 0xfb },
    2329                 : { 0x00, 0xfc, 0xfc },
    2330                 : { 0x00, 0xfd, 0xfd },
    2331                 : { 0x00, 0xfe, 0xfe },
    2332                 : { 0x00, 0xff, 0xff }
    2333                 : };
    2334                 : 
    2335                 : static struct cs_info iso7_tbl[] = {
    2336                 : { 0x00, 0x00, 0x00 },
    2337                 : { 0x00, 0x01, 0x01 },
    2338                 : { 0x00, 0x02, 0x02 },
    2339                 : { 0x00, 0x03, 0x03 },
    2340                 : { 0x00, 0x04, 0x04 },
    2341                 : { 0x00, 0x05, 0x05 },
    2342                 : { 0x00, 0x06, 0x06 },
    2343                 : { 0x00, 0x07, 0x07 },
    2344                 : { 0x00, 0x08, 0x08 },
    2345                 : { 0x00, 0x09, 0x09 },
    2346                 : { 0x00, 0x0a, 0x0a },
    2347                 : { 0x00, 0x0b, 0x0b },
    2348                 : { 0x00, 0x0c, 0x0c },
    2349                 : { 0x00, 0x0d, 0x0d },
    2350                 : { 0x00, 0x0e, 0x0e },
    2351                 : { 0x00, 0x0f, 0x0f },
    2352                 : { 0x00, 0x10, 0x10 },
    2353                 : { 0x00, 0x11, 0x11 },
    2354                 : { 0x00, 0x12, 0x12 },
    2355                 : { 0x00, 0x13, 0x13 },
    2356                 : { 0x00, 0x14, 0x14 },
    2357                 : { 0x00, 0x15, 0x15 },
    2358                 : { 0x00, 0x16, 0x16 },
    2359                 : { 0x00, 0x17, 0x17 },
    2360                 : { 0x00, 0x18, 0x18 },
    2361                 : { 0x00, 0x19, 0x19 },
    2362                 : { 0x00, 0x1a, 0x1a },
    2363                 : { 0x00, 0x1b, 0x1b },
    2364                 : { 0x00, 0x1c, 0x1c },
    2365                 : { 0x00, 0x1d, 0x1d },
    2366                 : { 0x00, 0x1e, 0x1e },
    2367                 : { 0x00, 0x1f, 0x1f },
    2368                 : { 0x00, 0x20, 0x20 },
    2369                 : { 0x00, 0x21, 0x21 },
    2370                 : { 0x00, 0x22, 0x22 },
    2371                 : { 0x00, 0x23, 0x23 },
    2372                 : { 0x00, 0x24, 0x24 },
    2373                 : { 0x00, 0x25, 0x25 },
    2374                 : { 0x00, 0x26, 0x26 },
    2375                 : { 0x00, 0x27, 0x27 },
    2376                 : { 0x00, 0x28, 0x28 },
    2377                 : { 0x00, 0x29, 0x29 },
    2378                 : { 0x00, 0x2a, 0x2a },
    2379                 : { 0x00, 0x2b, 0x2b },
    2380                 : { 0x00, 0x2c, 0x2c },
    2381                 : { 0x00, 0x2d, 0x2d },
    2382                 : { 0x00, 0x2e, 0x2e },
    2383                 : { 0x00, 0x2f, 0x2f },
    2384                 : { 0x00, 0x30, 0x30 },
    2385                 : { 0x00, 0x31, 0x31 },
    2386                 : { 0x00, 0x32, 0x32 },
    2387                 : { 0x00, 0x33, 0x33 },
    2388                 : { 0x00, 0x34, 0x34 },
    2389                 : { 0x00, 0x35, 0x35 },
    2390                 : { 0x00, 0x36, 0x36 },
    2391                 : { 0x00, 0x37, 0x37 },
    2392                 : { 0x00, 0x38, 0x38 },
    2393                 : { 0x00, 0x39, 0x39 },
    2394                 : { 0x00, 0x3a, 0x3a },
    2395                 : { 0x00, 0x3b, 0x3b },
    2396                 : { 0x00, 0x3c, 0x3c },
    2397                 : { 0x00, 0x3d, 0x3d },
    2398                 : { 0x00, 0x3e, 0x3e },
    2399                 : { 0x00, 0x3f, 0x3f },
    2400                 : { 0x00, 0x40, 0x40 },
    2401                 : { 0x01, 0x61, 0x41 },
    2402                 : { 0x01, 0x62, 0x42 },
    2403                 : { 0x01, 0x63, 0x43 },
    2404                 : { 0x01, 0x64, 0x44 },
    2405                 : { 0x01, 0x65, 0x45 },
    2406                 : { 0x01, 0x66, 0x46 },
    2407                 : { 0x01, 0x67, 0x47 },
    2408                 : { 0x01, 0x68, 0x48 },
    2409                 : { 0x01, 0x69, 0x49 },
    2410                 : { 0x01, 0x6a, 0x4a },
    2411                 : { 0x01, 0x6b, 0x4b },
    2412                 : { 0x01, 0x6c, 0x4c },
    2413                 : { 0x01, 0x6d, 0x4d },
    2414                 : { 0x01, 0x6e, 0x4e },
    2415                 : { 0x01, 0x6f, 0x4f },
    2416                 : { 0x01, 0x70, 0x50 },
    2417                 : { 0x01, 0x71, 0x51 },
    2418                 : { 0x01, 0x72, 0x52 },
    2419                 : { 0x01, 0x73, 0x53 },
    2420                 : { 0x01, 0x74, 0x54 },
    2421                 : { 0x01, 0x75, 0x55 },
    2422                 : { 0x01, 0x76, 0x56 },
    2423                 : { 0x01, 0x77, 0x57 },
    2424                 : { 0x01, 0x78, 0x58 },
    2425                 : { 0x01, 0x79, 0x59 },
    2426                 : { 0x01, 0x7a, 0x5a },
    2427                 : { 0x00, 0x5b, 0x5b },
    2428                 : { 0x00, 0x5c, 0x5c },
    2429                 : { 0x00, 0x5d, 0x5d },
    2430                 : { 0x00, 0x5e, 0x5e },
    2431                 : { 0x00, 0x5f, 0x5f },
    2432                 : { 0x00, 0x60, 0x60 },
    2433                 : { 0x00, 0x61, 0x41 },
    2434                 : { 0x00, 0x62, 0x42 },
    2435                 : { 0x00, 0x63, 0x43 },
    2436                 : { 0x00, 0x64, 0x44 },
    2437                 : { 0x00, 0x65, 0x45 },
    2438                 : { 0x00, 0x66, 0x46 },
    2439                 : { 0x00, 0x67, 0x47 },
    2440                 : { 0x00, 0x68, 0x48 },
    2441                 : { 0x00, 0x69, 0x49 },
    2442                 : { 0x00, 0x6a, 0x4a },
    2443                 : { 0x00, 0x6b, 0x4b },
    2444                 : { 0x00, 0x6c, 0x4c },
    2445                 : { 0x00, 0x6d, 0x4d },
    2446                 : { 0x00, 0x6e, 0x4e },
    2447                 : { 0x00, 0x6f, 0x4f },
    2448                 : { 0x00, 0x70, 0x50 },
    2449                 : { 0x00, 0x71, 0x51 },
    2450                 : { 0x00, 0x72, 0x52 },
    2451                 : { 0x00, 0x73, 0x53 },
    2452                 : { 0x00, 0x74, 0x54 },
    2453                 : { 0x00, 0x75, 0x55 },
    2454                 : { 0x00, 0x76, 0x56 },
    2455                 : { 0x00, 0x77, 0x57 },
    2456                 : { 0x00, 0x78, 0x58 },
    2457                 : { 0x00, 0x79, 0x59 },
    2458                 : { 0x00, 0x7a, 0x5a },
    2459                 : { 0x00, 0x7b, 0x7b },
    2460                 : { 0x00, 0x7c, 0x7c },
    2461                 : { 0x00, 0x7d, 0x7d },
    2462                 : { 0x00, 0x7e, 0x7e },
    2463                 : { 0x00, 0x7f, 0x7f },
    2464                 : { 0x00, 0x80, 0x80 },
    2465                 : { 0x00, 0x81, 0x81 },
    2466                 : { 0x00, 0x82, 0x82 },
    2467                 : { 0x00, 0x83, 0x83 },
    2468                 : { 0x00, 0x84, 0x84 },
    2469                 : { 0x00, 0x85, 0x85 },
    2470                 : { 0x00, 0x86, 0x86 },
    2471                 : { 0x00, 0x87, 0x87 },
    2472                 : { 0x00, 0x88, 0x88 },
    2473                 : { 0x00, 0x89, 0x89 },
    2474                 : { 0x00, 0x8a, 0x8a },
    2475                 : { 0x00, 0x8b, 0x8b },
    2476                 : { 0x00, 0x8c, 0x8c },
    2477                 : { 0x00, 0x8d, 0x8d },
    2478                 : { 0x00, 0x8e, 0x8e },
    2479                 : { 0x00, 0x8f, 0x8f },
    2480                 : { 0x00, 0x90, 0x90 },
    2481                 : { 0x00, 0x91, 0x91 },
    2482                 : { 0x00, 0x92, 0x92 },
    2483                 : { 0x00, 0x93, 0x93 },
    2484                 : { 0x00, 0x94, 0x94 },
    2485                 : { 0x00, 0x95, 0x95 },
    2486                 : { 0x00, 0x96, 0x96 },
    2487                 : { 0x00, 0x97, 0x97 },
    2488                 : { 0x00, 0x98, 0x98 },
    2489                 : { 0x00, 0x99, 0x99 },
    2490                 : { 0x00, 0x9a, 0x9a },
    2491                 : { 0x00, 0x9b, 0x9b },
    2492                 : { 0x00, 0x9c, 0x9c },
    2493                 : { 0x00, 0x9d, 0x9d },
    2494                 : { 0x00, 0x9e, 0x9e },
    2495                 : { 0x00, 0x9f, 0x9f },
    2496                 : { 0x00, 0xa0, 0xa0 },
    2497                 : { 0x00, 0xa1, 0xa1 },
    2498                 : { 0x00, 0xa2, 0xa2 },
    2499                 : { 0x00, 0xa3, 0xa3 },
    2500                 : { 0x00, 0xa4, 0xa4 },
    2501                 : { 0x00, 0xa5, 0xa5 },
    2502                 : { 0x00, 0xa6, 0xa6 },
    2503                 : { 0x00, 0xa7, 0xa7 },
    2504                 : { 0x00, 0xa8, 0xa8 },
    2505                 : { 0x00, 0xa9, 0xa9 },
    2506                 : { 0x00, 0xaa, 0xaa },
    2507                 : { 0x00, 0xab, 0xab },
    2508                 : { 0x00, 0xac, 0xac },
    2509                 : { 0x00, 0xad, 0xad },
    2510                 : { 0x00, 0xae, 0xae },
    2511                 : { 0x00, 0xaf, 0xaf },
    2512                 : { 0x00, 0xb0, 0xb0 },
    2513                 : { 0x00, 0xb1, 0xb1 },
    2514                 : { 0x00, 0xb2, 0xb2 },
    2515                 : { 0x00, 0xb3, 0xb3 },
    2516                 : { 0x00, 0xb4, 0xb4 },
    2517                 : { 0x00, 0xb5, 0xb5 },
    2518                 : { 0x01, 0xdc, 0xb6 },
    2519                 : { 0x00, 0xb7, 0xb7 },
    2520                 : { 0x01, 0xdd, 0xb8 },
    2521                 : { 0x01, 0xde, 0xb9 },
    2522                 : { 0x01, 0xdf, 0xba },
    2523                 : { 0x00, 0xbb, 0xbb },
    2524                 : { 0x01, 0xfc, 0xbc },
    2525                 : { 0x00, 0xbd, 0xbd },
    2526                 : { 0x01, 0xfd, 0xbe },
    2527                 : { 0x01, 0xfe, 0xbf },
    2528                 : { 0x00, 0xc0, 0xc0 },
    2529                 : { 0x01, 0xe1, 0xc1 },
    2530                 : { 0x01, 0xe2, 0xc2 },
    2531                 : { 0x01, 0xe3, 0xc3 },
    2532                 : { 0x01, 0xe4, 0xc4 },
    2533                 : { 0x01, 0xe5, 0xc5 },
    2534                 : { 0x01, 0xe6, 0xc6 },
    2535                 : { 0x01, 0xe7, 0xc7 },
    2536                 : { 0x01, 0xe8, 0xc8 },
    2537                 : { 0x01, 0xe9, 0xc9 },
    2538                 : { 0x01, 0xea, 0xca },
    2539                 : { 0x01, 0xeb, 0xcb },
    2540                 : { 0x01, 0xec, 0xcc },
    2541                 : { 0x01, 0xed, 0xcd },
    2542                 : { 0x01, 0xee, 0xce },
    2543                 : { 0x01, 0xef, 0xcf },
    2544                 : { 0x01, 0xf0, 0xd0 },
    2545                 : { 0x01, 0xf1, 0xd1 },
    2546                 : { 0x00, 0xd2, 0xd2 },
    2547                 : { 0x01, 0xf3, 0xd3 },
    2548                 : { 0x01, 0xf4, 0xd4 },
    2549                 : { 0x01, 0xf5, 0xd5 },
    2550                 : { 0x01, 0xf6, 0xd6 },
    2551                 : { 0x01, 0xf7, 0xd7 },
    2552                 : { 0x01, 0xf8, 0xd8 },
    2553                 : { 0x01, 0xf9, 0xd9 },
    2554                 : { 0x01, 0xfa, 0xda },
    2555                 : { 0x01, 0xfb, 0xdb },
    2556                 : { 0x00, 0xdc, 0xb6 },
    2557                 : { 0x00, 0xdd, 0xb8 },
    2558                 : { 0x00, 0xde, 0xb9 },
    2559                 : { 0x00, 0xdf, 0xba },
    2560                 : { 0x00, 0xe0, 0xe0 },
    2561                 : { 0x00, 0xe1, 0xc1 },
    2562                 : { 0x00, 0xe2, 0xc2 },
    2563                 : { 0x00, 0xe3, 0xc3 },
    2564                 : { 0x00, 0xe4, 0xc4 },
    2565                 : { 0x00, 0xe5, 0xc5 },
    2566                 : { 0x00, 0xe6, 0xc6 },
    2567                 : { 0x00, 0xe7, 0xc7 },
    2568                 : { 0x00, 0xe8, 0xc8 },
    2569                 : { 0x00, 0xe9, 0xc9 },
    2570                 : { 0x00, 0xea, 0xca },
    2571                 : { 0x00, 0xeb, 0xcb },
    2572                 : { 0x00, 0xec, 0xcc },
    2573                 : { 0x00, 0xed, 0xcd },
    2574                 : { 0x00, 0xee, 0xce },
    2575                 : { 0x00, 0xef, 0xcf },
    2576                 : { 0x00, 0xf0, 0xd0 },
    2577                 : { 0x00, 0xf1, 0xd1 },
    2578                 : { 0x00, 0xf2, 0xd3 },
    2579                 : { 0x00, 0xf3, 0xd3 },
    2580                 : { 0x00, 0xf4, 0xd4 },
    2581                 : { 0x00, 0xf5, 0xd5 },
    2582                 : { 0x00, 0xf6, 0xd6 },
    2583                 : { 0x00, 0xf7, 0xd7 },
    2584                 : { 0x00, 0xf8, 0xd8 },
    2585                 : { 0x00, 0xf9, 0xd9 },
    2586                 : { 0x00, 0xfa, 0xda },
    2587                 : { 0x00, 0xfb, 0xdb },
    2588                 : { 0x00, 0xfc, 0xbc },
    2589                 : { 0x00, 0xfd, 0xbe },
    2590                 : { 0x00, 0xfe, 0xbf },
    2591                 : { 0x00, 0xff, 0xff }
    2592                 : };
    2593                 : 
    2594                 : static struct cs_info iso8_tbl[] = {
    2595                 : { 0x00, 0x00, 0x00 },
    2596                 : { 0x00, 0x01, 0x01 },
    2597                 : { 0x00, 0x02, 0x02 },
    2598                 : { 0x00, 0x03, 0x03 },
    2599                 : { 0x00, 0x04, 0x04 },
    2600                 : { 0x00, 0x05, 0x05 },
    2601                 : { 0x00, 0x06, 0x06 },
    2602                 : { 0x00, 0x07, 0x07 },
    2603                 : { 0x00, 0x08, 0x08 },
    2604                 : { 0x00, 0x09, 0x09 },
    2605                 : { 0x00, 0x0a, 0x0a },
    2606                 : { 0x00, 0x0b, 0x0b },
    2607                 : { 0x00, 0x0c, 0x0c },
    2608                 : { 0x00, 0x0d, 0x0d },
    2609                 : { 0x00, 0x0e, 0x0e },
    2610                 : { 0x00, 0x0f, 0x0f },
    2611                 : { 0x00, 0x10, 0x10 },
    2612                 : { 0x00, 0x11, 0x11 },
    2613                 : { 0x00, 0x12, 0x12 },
    2614                 : { 0x00, 0x13, 0x13 },
    2615                 : { 0x00, 0x14, 0x14 },
    2616                 : { 0x00, 0x15, 0x15 },
    2617                 : { 0x00, 0x16, 0x16 },
    2618                 : { 0x00, 0x17, 0x17 },
    2619                 : { 0x00, 0x18, 0x18 },
    2620                 : { 0x00, 0x19, 0x19 },
    2621                 : { 0x00, 0x1a, 0x1a },
    2622                 : { 0x00, 0x1b, 0x1b },
    2623                 : { 0x00, 0x1c, 0x1c },
    2624                 : { 0x00, 0x1d, 0x1d },
    2625                 : { 0x00, 0x1e, 0x1e },
    2626                 : { 0x00, 0x1f, 0x1f },
    2627                 : { 0x00, 0x20, 0x20 },
    2628                 : { 0x00, 0x21, 0x21 },
    2629                 : { 0x00, 0x22, 0x22 },
    2630                 : { 0x00, 0x23, 0x23 },
    2631                 : { 0x00, 0x24, 0x24 },
    2632                 : { 0x00, 0x25, 0x25 },
    2633                 : { 0x00, 0x26, 0x26 },
    2634                 : { 0x00, 0x27, 0x27 },
    2635                 : { 0x00, 0x28, 0x28 },
    2636                 : { 0x00, 0x29, 0x29 },
    2637                 : { 0x00, 0x2a, 0x2a },
    2638                 : { 0x00, 0x2b, 0x2b },
    2639                 : { 0x00, 0x2c, 0x2c },
    2640                 : { 0x00, 0x2d, 0x2d },
    2641                 : { 0x00, 0x2e, 0x2e },
    2642                 : { 0x00, 0x2f, 0x2f },
    2643                 : { 0x00, 0x30, 0x30 },
    2644                 : { 0x00, 0x31, 0x31 },
    2645                 : { 0x00, 0x32, 0x32 },
    2646                 : { 0x00, 0x33, 0x33 },
    2647                 : { 0x00, 0x34, 0x34 },
    2648                 : { 0x00, 0x35, 0x35 },
    2649                 : { 0x00, 0x36, 0x36 },
    2650                 : { 0x00, 0x37, 0x37 },
    2651                 : { 0x00, 0x38, 0x38 },
    2652                 : { 0x00, 0x39, 0x39 },
    2653                 : { 0x00, 0x3a, 0x3a },
    2654                 : { 0x00, 0x3b, 0x3b },
    2655                 : { 0x00, 0x3c, 0x3c },
    2656                 : { 0x00, 0x3d, 0x3d },
    2657                 : { 0x00, 0x3e, 0x3e },
    2658                 : { 0x00, 0x3f, 0x3f },
    2659                 : { 0x00, 0x40, 0x40 },
    2660                 : { 0x01, 0x61, 0x41 },
    2661                 : { 0x01, 0x62, 0x42 },
    2662                 : { 0x01, 0x63, 0x43 },
    2663                 : { 0x01, 0x64, 0x44 },
    2664                 : { 0x01, 0x65, 0x45 },
    2665                 : { 0x01, 0x66, 0x46 },
    2666                 : { 0x01, 0x67, 0x47 },
    2667                 : { 0x01, 0x68, 0x48 },
    2668                 : { 0x01, 0x69, 0x49 },
    2669                 : { 0x01, 0x6a, 0x4a },
    2670                 : { 0x01, 0x6b, 0x4b },
    2671                 : { 0x01, 0x6c, 0x4c },
    2672                 : { 0x01, 0x6d, 0x4d },
    2673                 : { 0x01, 0x6e, 0x4e },
    2674                 : { 0x01, 0x6f, 0x4f },
    2675                 : { 0x01, 0x70, 0x50 },
    2676                 : { 0x01, 0x71, 0x51 },
    2677                 : { 0x01, 0x72, 0x52 },
    2678                 : { 0x01, 0x73, 0x53 },
    2679                 : { 0x01, 0x74, 0x54 },
    2680                 : { 0x01, 0x75, 0x55 },
    2681                 : { 0x01, 0x76, 0x56 },
    2682                 : { 0x01, 0x77, 0x57 },
    2683                 : { 0x01, 0x78, 0x58 },
    2684                 : { 0x01, 0x79, 0x59 },
    2685                 : { 0x01, 0x7a, 0x5a },
    2686                 : { 0x00, 0x5b, 0x5b },
    2687                 : { 0x00, 0x5c, 0x5c },
    2688                 : { 0x00, 0x5d, 0x5d },
    2689                 : { 0x00, 0x5e, 0x5e },
    2690                 : { 0x00, 0x5f, 0x5f },
    2691                 : { 0x00, 0x60, 0x60 },
    2692                 : { 0x00, 0x61, 0x41 },
    2693                 : { 0x00, 0x62, 0x42 },
    2694                 : { 0x00, 0x63, 0x43 },
    2695                 : { 0x00, 0x64, 0x44 },
    2696                 : { 0x00, 0x65, 0x45 },
    2697                 : { 0x00, 0x66, 0x46 },
    2698                 : { 0x00, 0x67, 0x47 },
    2699                 : { 0x00, 0x68, 0x48 },
    2700                 : { 0x00, 0x69, 0x49 },
    2701                 : { 0x00, 0x6a, 0x4a },
    2702                 : { 0x00, 0x6b, 0x4b },
    2703                 : { 0x00, 0x6c, 0x4c },
    2704                 : { 0x00, 0x6d, 0x4d },
    2705                 : { 0x00, 0x6e, 0x4e },
    2706                 : { 0x00, 0x6f, 0x4f },
    2707                 : { 0x00, 0x70, 0x50 },
    2708                 : { 0x00, 0x71, 0x51 },
    2709                 : { 0x00, 0x72, 0x52 },
    2710                 : { 0x00, 0x73, 0x53 },
    2711                 : { 0x00, 0x74, 0x54 },
    2712                 : { 0x00, 0x75, 0x55 },
    2713                 : { 0x00, 0x76, 0x56 },
    2714                 : { 0x00, 0x77, 0x57 },
    2715                 : { 0x00, 0x78, 0x58 },
    2716                 : { 0x00, 0x79, 0x59 },
    2717                 : { 0x00, 0x7a, 0x5a },
    2718                 : { 0x00, 0x7b, 0x7b },
    2719                 : { 0x00, 0x7c, 0x7c },
    2720                 : { 0x00, 0x7d, 0x7d },
    2721                 : { 0x00, 0x7e, 0x7e },
    2722                 : { 0x00, 0x7f, 0x7f },
    2723                 : { 0x00, 0x80, 0x80 },
    2724                 : { 0x00, 0x81, 0x81 },
    2725                 : { 0x00, 0x82, 0x82 },
    2726                 : { 0x00, 0x83, 0x83 },
    2727                 : { 0x00, 0x84, 0x84 },
    2728                 : { 0x00, 0x85, 0x85 },
    2729                 : { 0x00, 0x86, 0x86 },
    2730                 : { 0x00, 0x87, 0x87 },
    2731                 : { 0x00, 0x88, 0x88 },
    2732                 : { 0x00, 0x89, 0x89 },
    2733                 : { 0x00, 0x8a, 0x8a },
    2734                 : { 0x00, 0x8b, 0x8b },
    2735                 : { 0x00, 0x8c, 0x8c },
    2736                 : { 0x00, 0x8d, 0x8d },
    2737                 : { 0x00, 0x8e, 0x8e },
    2738                 : { 0x00, 0x8f, 0x8f },
    2739                 : { 0x00, 0x90, 0x90 },
    2740                 : { 0x00, 0x91, 0x91 },
    2741                 : { 0x00, 0x92, 0x92 },
    2742                 : { 0x00, 0x93, 0x93 },
    2743                 : { 0x00, 0x94, 0x94 },
    2744                 : { 0x00, 0x95, 0x95 },
    2745                 : { 0x00, 0x96, 0x96 },
    2746                 : { 0x00, 0x97, 0x97 },
    2747                 : { 0x00, 0x98, 0x98 },
    2748                 : { 0x00, 0x99, 0x99 },
    2749                 : { 0x00, 0x9a, 0x9a },
    2750                 : { 0x00, 0x9b, 0x9b },
    2751                 : { 0x00, 0x9c, 0x9c },
    2752                 : { 0x00, 0x9d, 0x9d },
    2753                 : { 0x00, 0x9e, 0x9e },
    2754                 : { 0x00, 0x9f, 0x9f },
    2755                 : { 0x00, 0xa0, 0xa0 },
    2756                 : { 0x00, 0xa1, 0xa1 },
    2757                 : { 0x00, 0xa2, 0xa2 },
    2758                 : { 0x00, 0xa3, 0xa3 },
    2759                 : { 0x00, 0xa4, 0xa4 },
    2760                 : { 0x00, 0xa5, 0xa5 },
    2761                 : { 0x00, 0xa6, 0xa6 },
    2762                 : { 0x00, 0xa7, 0xa7 },
    2763                 : { 0x00, 0xa8, 0xa8 },
    2764                 : { 0x00, 0xa9, 0xa9 },
    2765                 : { 0x00, 0xaa, 0xaa },
    2766                 : { 0x00, 0xab, 0xab },
    2767                 : { 0x00, 0xac, 0xac },
    2768                 : { 0x00, 0xad, 0xad },
    2769                 : { 0x00, 0xae, 0xae },
    2770                 : { 0x00, 0xaf, 0xaf },
    2771                 : { 0x00, 0xb0, 0xb0 },
    2772                 : { 0x00, 0xb1, 0xb1 },
    2773                 : { 0x00, 0xb2, 0xb2 },
    2774                 : { 0x00, 0xb3, 0xb3 },
    2775                 : { 0x00, 0xb4, 0xb4 },
    2776                 : { 0x00, 0xb5, 0xb5 },
    2777                 : { 0x00, 0xb6, 0xb6 },
    2778                 : { 0x00, 0xb7, 0xb7 },
    2779                 : { 0x00, 0xb8, 0xb8 },
    2780                 : { 0x00, 0xb9, 0xb9 },
    2781                 : { 0x00, 0xba, 0xba },
    2782                 : { 0x00, 0xbb, 0xbb },
    2783                 : { 0x00, 0xbc, 0xbc },
    2784                 : { 0x00, 0xbd, 0xbd },
    2785                 : { 0x00, 0xbe, 0xbe },
    2786                 : { 0x00, 0xbf, 0xbf },
    2787                 : { 0x00, 0xc0, 0xc0 },
    2788                 : { 0x00, 0xc1, 0xc1 },
    2789                 : { 0x00, 0xc2, 0xc2 },
    2790                 : { 0x00, 0xc3, 0xc3 },
    2791                 : { 0x00, 0xc4, 0xc4 },
    2792                 : { 0x00, 0xc5, 0xc5 },
    2793                 : { 0x00, 0xc6, 0xc6 },
    2794                 : { 0x00, 0xc7, 0xc7 },
    2795                 : { 0x00, 0xc8, 0xc8 },
    2796                 : { 0x00, 0xc9, 0xc9 },
    2797                 : { 0x00, 0xca, 0xca },
    2798                 : { 0x00, 0xcb, 0xcb },
    2799                 : { 0x00, 0xcc, 0xcc },
    2800                 : { 0x00, 0xcd, 0xcd },
    2801                 : { 0x00, 0xce, 0xce },
    2802                 : { 0x00, 0xcf, 0xcf },
    2803                 : { 0x00, 0xd0, 0xd0 },
    2804                 : { 0x00, 0xd1, 0xd1 },
    2805                 : { 0x00, 0xd2, 0xd2 },
    2806                 : { 0x00, 0xd3, 0xd3 },
    2807                 : { 0x00, 0xd4, 0xd4 },
    2808                 : { 0x00, 0xd5, 0xd5 },
    2809                 : { 0x00, 0xd6, 0xd6 },
    2810                 : { 0x00, 0xd7, 0xd7 },
    2811                 : { 0x00, 0xd8, 0xd8 },
    2812                 : { 0x00, 0xd9, 0xd9 },
    2813                 : { 0x00, 0xda, 0xda },
    2814                 : { 0x00, 0xdb, 0xdb },
    2815                 : { 0x00, 0xdc, 0xdc },
    2816                 : { 0x00, 0xdd, 0xdd },
    2817                 : { 0x00, 0xde, 0xde },
    2818                 : { 0x00, 0xdf, 0xdf },
    2819                 : { 0x00, 0xe0, 0xe0 },
    2820                 : { 0x00, 0xe1, 0xe1 },
    2821                 : { 0x00, 0xe2, 0xe2 },
    2822                 : { 0x00, 0xe3, 0xe3 },
    2823                 : { 0x00, 0xe4, 0xe4 },
    2824                 : { 0x00, 0xe5, 0xe5 },
    2825                 : { 0x00, 0xe6, 0xe6 },
    2826                 : { 0x00, 0xe7, 0xe7 },
    2827                 : { 0x00, 0xe8, 0xe8 },
    2828                 : { 0x00, 0xe9, 0xe9 },
    2829                 : { 0x00, 0xea, 0xea },
    2830                 : { 0x00, 0xeb, 0xeb },
    2831                 : { 0x00, 0xec, 0xec },
    2832                 : { 0x00, 0xed, 0xed },
    2833                 : { 0x00, 0xee, 0xee },
    2834                 : { 0x00, 0xef, 0xef },
    2835                 : { 0x00, 0xf0, 0xf0 },
    2836                 : { 0x00, 0xf1, 0xf1 },
    2837                 : { 0x00, 0xf2, 0xf2 },
    2838                 : { 0x00, 0xf3, 0xf3 },
    2839                 : { 0x00, 0xf4, 0xf4 },
    2840                 : { 0x00, 0xf5, 0xf5 },
    2841                 : { 0x00, 0xf6, 0xf6 },
    2842                 : { 0x00, 0xf7, 0xf7 },
    2843                 : { 0x00, 0xf8, 0xf8 },
    2844                 : { 0x00, 0xf9, 0xf9 },
    2845                 : { 0x00, 0xfa, 0xfa },
    2846                 : { 0x00, 0xfb, 0xfb },
    2847                 : { 0x00, 0xfc, 0xfc },
    2848                 : { 0x00, 0xfd, 0xfd },
    2849                 : { 0x00, 0xfe, 0xfe },
    2850                 : { 0x00, 0xff, 0xff }
    2851                 : };
    2852                 : 
    2853                 : static struct cs_info iso9_tbl[] = {
    2854                 : { 0x00, 0x00, 0x00 },
    2855                 : { 0x00, 0x01, 0x01 },
    2856                 : { 0x00, 0x02, 0x02 },
    2857                 : { 0x00, 0x03, 0x03 },
    2858                 : { 0x00, 0x04, 0x04 },
    2859                 : { 0x00, 0x05, 0x05 },
    2860                 : { 0x00, 0x06, 0x06 },
    2861                 : { 0x00, 0x07, 0x07 },
    2862                 : { 0x00, 0x08, 0x08 },
    2863                 : { 0x00, 0x09, 0x09 },
    2864                 : { 0x00, 0x0a, 0x0a },
    2865                 : { 0x00, 0x0b, 0x0b },
    2866                 : { 0x00, 0x0c, 0x0c },
    2867                 : { 0x00, 0x0d, 0x0d },
    2868                 : { 0x00, 0x0e, 0x0e },
    2869                 : { 0x00, 0x0f, 0x0f },
    2870                 : { 0x00, 0x10, 0x10 },
    2871                 : { 0x00, 0x11, 0x11 },
    2872                 : { 0x00, 0x12, 0x12 },
    2873                 : { 0x00, 0x13, 0x13 },
    2874                 : { 0x00, 0x14, 0x14 },
    2875                 : { 0x00, 0x15, 0x15 },
    2876                 : { 0x00, 0x16, 0x16 },
    2877                 : { 0x00, 0x17, 0x17 },
    2878                 : { 0x00, 0x18, 0x18 },
    2879                 : { 0x00, 0x19, 0x19 },
    2880                 : { 0x00, 0x1a, 0x1a },
    2881                 : { 0x00, 0x1b, 0x1b },
    2882                 : { 0x00, 0x1c, 0x1c },
    2883                 : { 0x00, 0x1d, 0x1d },
    2884                 : { 0x00, 0x1e, 0x1e },
    2885                 : { 0x00, 0x1f, 0x1f },
    2886                 : { 0x00, 0x20, 0x20 },
    2887                 : { 0x00, 0x21, 0x21 },
    2888                 : { 0x00, 0x22, 0x22 },
    2889                 : { 0x00, 0x23, 0x23 },
    2890                 : { 0x00, 0x24, 0x24 },
    2891                 : { 0x00, 0x25, 0x25 },
    2892                 : { 0x00, 0x26, 0x26 },
    2893                 : { 0x00, 0x27, 0x27 },
    2894                 : { 0x00, 0x28, 0x28 },
    2895                 : { 0x00, 0x29, 0x29 },
    2896                 : { 0x00, 0x2a, 0x2a },
    2897                 : { 0x00, 0x2b, 0x2b },
    2898                 : { 0x00, 0x2c, 0x2c },
    2899                 : { 0x00, 0x2d, 0x2d },
    2900                 : { 0x00, 0x2e, 0x2e },
    2901                 : { 0x00, 0x2f, 0x2f },
    2902                 : { 0x00, 0x30, 0x30 },
    2903                 : { 0x00, 0x31, 0x31 },
    2904                 : { 0x00, 0x32, 0x32 },
    2905                 : { 0x00, 0x33, 0x33 },
    2906                 : { 0x00, 0x34, 0x34 },
    2907                 : { 0x00, 0x35, 0x35 },
    2908                 : { 0x00, 0x36, 0x36 },
    2909                 : { 0x00, 0x37, 0x37 },
    2910                 : { 0x00, 0x38, 0x38 },
    2911                 : { 0x00, 0x39, 0x39 },
    2912                 : { 0x00, 0x3a, 0x3a },
    2913                 : { 0x00, 0x3b, 0x3b },
    2914                 : { 0x00, 0x3c, 0x3c },
    2915                 : { 0x00, 0x3d, 0x3d },
    2916                 : { 0x00, 0x3e, 0x3e },
    2917                 : { 0x00, 0x3f, 0x3f },
    2918                 : { 0x00, 0x40, 0x40 },
    2919                 : { 0x01, 0x61, 0x41 },
    2920                 : { 0x01, 0x62, 0x42 },
    2921                 : { 0x01, 0x63, 0x43 },
    2922                 : { 0x01, 0x64, 0x44 },
    2923                 : { 0x01, 0x65, 0x45 },
    2924                 : { 0x01, 0x66, 0x46 },
    2925                 : { 0x01, 0x67, 0x47 },
    2926                 : { 0x01, 0x68, 0x48 },
    2927                 : { 0x01, 0xfd, 0x49 },
    2928                 : { 0x01, 0x6a, 0x4a },
    2929                 : { 0x01, 0x6b, 0x4b },
    2930                 : { 0x01, 0x6c, 0x4c },
    2931                 : { 0x01, 0x6d, 0x4d },
    2932                 : { 0x01, 0x6e, 0x4e },
    2933                 : { 0x01, 0x6f, 0x4f },
    2934                 : { 0x01, 0x70, 0x50 },
    2935                 : { 0x01, 0x71, 0x51 },
    2936                 : { 0x01, 0x72, 0x52 },
    2937                 : { 0x01, 0x73, 0x53 },
    2938                 : { 0x01, 0x74, 0x54 },
    2939                 : { 0x01, 0x75, 0x55 },
    2940                 : { 0x01, 0x76, 0x56 },
    2941                 : { 0x01, 0x77, 0x57 },
    2942                 : { 0x01, 0x78, 0x58 },
    2943                 : { 0x01, 0x79, 0x59 },
    2944                 : { 0x01, 0x7a, 0x5a },
    2945                 : { 0x00, 0x5b, 0x5b },
    2946                 : { 0x00, 0x5c, 0x5c },
    2947                 : { 0x00, 0x5d, 0x5d },
    2948                 : { 0x00, 0x5e, 0x5e },
    2949                 : { 0x00, 0x5f, 0x5f },
    2950                 : { 0x00, 0x60, 0x60 },
    2951                 : { 0x00, 0x61, 0x41 },
    2952                 : { 0x00, 0x62, 0x42 },
    2953                 : { 0x00, 0x63, 0x43 },
    2954                 : { 0x00, 0x64, 0x44 },
    2955                 : { 0x00, 0x65, 0x45 },
    2956                 : { 0x00, 0x66, 0x46 },
    2957                 : { 0x00, 0x67, 0x47 },
    2958                 : { 0x00, 0x68, 0x48 },
    2959                 : { 0x00, 0x69, 0xdd },
    2960                 : { 0x00, 0x6a, 0x4a },
    2961                 : { 0x00, 0x6b, 0x4b },
    2962                 : { 0x00, 0x6c, 0x4c },
    2963                 : { 0x00, 0x6d, 0x4d },
    2964                 : { 0x00, 0x6e, 0x4e },
    2965                 : { 0x00, 0x6f, 0x4f },
    2966                 : { 0x00, 0x70, 0x50 },
    2967                 : { 0x00, 0x71, 0x51 },
    2968                 : { 0x00, 0x72, 0x52 },
    2969                 : { 0x00, 0x73, 0x53 },
    2970                 : { 0x00, 0x74, 0x54 },
    2971                 : { 0x00, 0x75, 0x55 },
    2972                 : { 0x00, 0x76, 0x56 },
    2973                 : { 0x00, 0x77, 0x57 },
    2974                 : { 0x00, 0x78, 0x58 },
    2975                 : { 0x00, 0x79, 0x59 },
    2976                 : { 0x00, 0x7a, 0x5a },
    2977                 : { 0x00, 0x7b, 0x7b },
    2978                 : { 0x00, 0x7c, 0x7c },
    2979                 : { 0x00, 0x7d, 0x7d },
    2980                 : { 0x00, 0x7e, 0x7e },
    2981                 : { 0x00, 0x7f, 0x7f },
    2982                 : { 0x00, 0x80, 0x80 },
    2983                 : { 0x00, 0x81, 0x81 },
    2984                 : { 0x00, 0x82, 0x82 },
    2985                 : { 0x00, 0x83, 0x83 },
    2986                 : { 0x00, 0x84, 0x84 },
    2987                 : { 0x00, 0x85, 0x85 },
    2988                 : { 0x00, 0x86, 0x86 },
    2989                 : { 0x00, 0x87, 0x87 },
    2990                 : { 0x00, 0x88, 0x88 },
    2991                 : { 0x00, 0x89, 0x89 },
    2992                 : { 0x00, 0x8a, 0x8a },
    2993                 : { 0x00, 0x8b, 0x8b },
    2994                 : { 0x00, 0x8c, 0x8c },
    2995                 : { 0x00, 0x8d, 0x8d },
    2996                 : { 0x00, 0x8e, 0x8e },
    2997                 : { 0x00, 0x8f, 0x8f },
    2998                 : { 0x00, 0x90, 0x90 },
    2999                 : { 0x00, 0x91, 0x91 },
    3000                 : { 0x00, 0x92, 0x92 },
    3001                 : { 0x00, 0x93, 0x93 },
    3002                 : { 0x00, 0x94, 0x94 },
    3003                 : { 0x00, 0x95, 0x95 },
    3004                 : { 0x00, 0x96, 0x96 },
    3005                 : { 0x00, 0x97, 0x97 },
    3006                 : { 0x00, 0x98, 0x98 },
    3007                 : { 0x00, 0x99, 0x99 },
    3008                 : { 0x00, 0x9a, 0x9a },
    3009                 : { 0x00, 0x9b, 0x9b },
    3010                 : { 0x00, 0x9c, 0x9c },
    3011                 : { 0x00, 0x9d, 0x9d },
    3012                 : { 0x00, 0x9e, 0x9e },
    3013                 : { 0x00, 0x9f, 0x9f },
    3014                 : { 0x00, 0xa0, 0xa0 },
    3015                 : { 0x00, 0xa1, 0xa1 },
    3016                 : { 0x00, 0xa2, 0xa2 },
    3017                 : { 0x00, 0xa3, 0xa3 },
    3018                 : { 0x00, 0xa4, 0xa4 },
    3019                 : { 0x00, 0xa5, 0xa5 },
    3020                 : { 0x00, 0xa6, 0xa6 },
    3021                 : { 0x00, 0xa7, 0xa7 },
    3022                 : { 0x00, 0xa8, 0xa8 },
    3023                 : { 0x00, 0xa9, 0xa9 },
    3024                 : { 0x00, 0xaa, 0xaa },
    3025                 : { 0x00, 0xab, 0xab },
    3026                 : { 0x00, 0xac, 0xac },
    3027                 : { 0x00, 0xad, 0xad },
    3028                 : { 0x00, 0xae, 0xae },
    3029                 : { 0x00, 0xaf, 0xaf },
    3030                 : { 0x00, 0xb0, 0xb0 },
    3031                 : { 0x00, 0xb1, 0xb1 },
    3032                 : { 0x00, 0xb2, 0xb2 },
    3033                 : { 0x00, 0xb3, 0xb3 },
    3034                 : { 0x00, 0xb4, 0xb4 },
    3035                 : { 0x00, 0xb5, 0xb5 },
    3036                 : { 0x00, 0xb6, 0xb6 },
    3037                 : { 0x00, 0xb7, 0xb7 },
    3038                 : { 0x00, 0xb8, 0xb8 },
    3039                 : { 0x00, 0xb9, 0xb9 },
    3040                 : { 0x00, 0xba, 0xba },
    3041                 : { 0x00, 0xbb, 0xbb },
    3042                 : { 0x00, 0xbc, 0xbc },
    3043                 : { 0x00, 0xbd, 0xbd },
    3044                 : { 0x00, 0xbe, 0xbe },
    3045                 : { 0x00, 0xbf, 0xbf },
    3046                 : { 0x01, 0xe0, 0xc0 },
    3047                 : { 0x01, 0xe1, 0xc1 },
    3048                 : { 0x01, 0xe2, 0xc2 },
    3049                 : { 0x01, 0xe3, 0xc3 },
    3050                 : { 0x01, 0xe4, 0xc4 },
    3051                 : { 0x01, 0xe5, 0xc5 },
    3052                 : { 0x01, 0xe6, 0xc6 },
    3053                 : { 0x01, 0xe7, 0xc7 },
    3054                 : { 0x01, 0xe8, 0xc8 },
    3055                 : { 0x01, 0xe9, 0xc9 },
    3056                 : { 0x01, 0xea, 0xca },
    3057                 : { 0x01, 0xeb, 0xcb },
    3058                 : { 0x01, 0xec, 0xcc },
    3059                 : { 0x01, 0xed, 0xcd },
    3060                 : { 0x01, 0xee, 0xce },
    3061                 : { 0x01, 0xef, 0xcf },
    3062                 : { 0x01, 0xf0, 0xd0 },
    3063                 : { 0x01, 0xf1, 0xd1 },
    3064                 : { 0x01, 0xf2, 0xd2 },
    3065                 : { 0x01, 0xf3, 0xd3 },
    3066                 : { 0x01, 0xf4, 0xd4 },
    3067                 : { 0x01, 0xf5, 0xd5 },
    3068                 : { 0x01, 0xf6, 0xd6 },
    3069                 : { 0x00, 0xd7, 0xd7 },
    3070                 : { 0x01, 0xf8, 0xd8 },
    3071                 : { 0x01, 0xf9, 0xd9 },
    3072                 : { 0x01, 0xfa, 0xda },
    3073                 : { 0x01, 0xfb, 0xdb },
    3074                 : { 0x01, 0xfc, 0xdc },
    3075                 : { 0x01, 0x69, 0xdd },
    3076                 : { 0x01, 0xfe, 0xde },
    3077                 : { 0x00, 0xdf, 0xdf },
    3078                 : { 0x00, 0xe0, 0xc0 },
    3079                 : { 0x00, 0xe1, 0xc1 },
    3080                 : { 0x00, 0xe2, 0xc2 },
    3081                 : { 0x00, 0xe3, 0xc3 },
    3082                 : { 0x00, 0xe4, 0xc4 },
    3083                 : { 0x00, 0xe5, 0xc5 },
    3084                 : { 0x00, 0xe6, 0xc6 },
    3085                 : { 0x00, 0xe7, 0xc7 },
    3086                 : { 0x00, 0xe8, 0xc8 },
    3087                 : { 0x00, 0xe9, 0xc9 },
    3088                 : { 0x00, 0xea, 0xca },
    3089                 : { 0x00, 0xeb, 0xcb },
    3090                 : { 0x00, 0xec, 0xcc },
    3091                 : { 0x00, 0xed, 0xcd },
    3092                 : { 0x00, 0xee, 0xce },
    3093                 : { 0x00, 0xef, 0xcf },
    3094                 : { 0x00, 0xf0, 0xd0 },
    3095                 : { 0x00, 0xf1, 0xd1 },
    3096                 : { 0x00, 0xf2, 0xd2 },
    3097                 : { 0x00, 0xf3, 0xd3 },
    3098                 : { 0x00, 0xf4, 0xd4 },
    3099                 : { 0x00, 0xf5, 0xd5 },
    3100                 : { 0x00, 0xf6, 0xd6 },
    3101                 : { 0x00, 0xf7, 0xf7 },
    3102                 : { 0x00, 0xf8, 0xd8 },
    3103                 : { 0x00, 0xf9, 0xd9 },
    3104                 : { 0x00, 0xfa, 0xda },
    3105                 : { 0x00, 0xfb, 0xdb },
    3106                 : { 0x00, 0xfc, 0xdc },
    3107                 : { 0x00, 0xfd, 0x49 },
    3108                 : { 0x00, 0xfe, 0xde },
    3109                 : { 0x00, 0xff, 0xff }
    3110                 : };
    3111                 : 
    3112                 : static struct cs_info iso10_tbl[] = {
    3113                 : { 0x00, 0x00, 0x00 },
    3114                 : { 0x00, 0x01, 0x01 },
    3115                 : { 0x00, 0x02, 0x02 },
    3116                 : { 0x00, 0x03, 0x03 },
    3117                 : { 0x00, 0x04, 0x04 },
    3118                 : { 0x00, 0x05, 0x05 },
    3119                 : { 0x00, 0x06, 0x06 },
    3120                 : { 0x00, 0x07, 0x07 },
    3121                 : { 0x00, 0x08, 0x08 },
    3122                 : { 0x00, 0x09, 0x09 },
    3123                 : { 0x00, 0x0a, 0x0a },
    3124                 : { 0x00, 0x0b, 0x0b },
    3125                 : { 0x00, 0x0c, 0x0c },
    3126                 : { 0x00, 0x0d, 0x0d },
    3127                 : { 0x00, 0x0e, 0x0e },
    3128                 : { 0x00, 0x0f, 0x0f },
    3129                 : { 0x00, 0x10, 0x10 },
    3130                 : { 0x00, 0x11, 0x11 },
    3131                 : { 0x00, 0x12, 0x12 },
    3132                 : { 0x00, 0x13, 0x13 },
    3133                 : { 0x00, 0x14, 0x14 },
    3134                 : { 0x00, 0x15, 0x15 },
    3135                 : { 0x00, 0x16, 0x16 },
    3136                 : { 0x00, 0x17, 0x17 },
    3137                 : { 0x00, 0x18, 0x18 },
    3138                 : { 0x00, 0x19, 0x19 },
    3139                 : { 0x00, 0x1a, 0x1a },
    3140                 : { 0x00, 0x1b, 0x1b },
    3141                 : { 0x00, 0x1c, 0x1c },
    3142                 : { 0x00, 0x1d, 0x1d },
    3143                 : { 0x00, 0x1e, 0x1e },
    3144                 : { 0x00, 0x1f, 0x1f },
    3145                 : { 0x00, 0x20, 0x20 },
    3146                 : { 0x00, 0x21, 0x21 },
    3147                 : { 0x00, 0x22, 0x22 },
    3148                 : { 0x00, 0x23, 0x23 },
    3149                 : { 0x00, 0x24, 0x24 },
    3150                 : { 0x00, 0x25, 0x25 },
    3151                 : { 0x00, 0x26, 0x26 },
    3152                 : { 0x00, 0x27, 0x27 },
    3153                 : { 0x00, 0x28, 0x28 },
    3154                 : { 0x00, 0x29, 0x29 },
    3155                 : { 0x00, 0x2a, 0x2a },
    3156                 : { 0x00, 0x2b, 0x2b },
    3157                 : { 0x00, 0x2c, 0x2c },
    3158                 : { 0x00, 0x2d, 0x2d },
    3159                 : { 0x00, 0x2e, 0x2e },
    3160                 : { 0x00, 0x2f, 0x2f },
    3161                 : { 0x00, 0x30, 0x30 },
    3162                 : { 0x00, 0x31, 0x31 },
    3163                 : { 0x00, 0x32, 0x32 },
    3164                 : { 0x00, 0x33, 0x33 },
    3165                 : { 0x00, 0x34, 0x34 },
    3166                 : { 0x00, 0x35, 0x35 },
    3167                 : { 0x00, 0x36, 0x36 },
    3168                 : { 0x00, 0x37, 0x37 },
    3169                 : { 0x00, 0x38, 0x38 },
    3170                 : { 0x00, 0x39, 0x39 },
    3171                 : { 0x00, 0x3a, 0x3a },
    3172                 : { 0x00, 0x3b, 0x3b },
    3173                 : { 0x00, 0x3c, 0x3c },
    3174                 : { 0x00, 0x3d, 0x3d },
    3175                 : { 0x00, 0x3e, 0x3e },
    3176                 : { 0x00, 0x3f, 0x3f },
    3177                 : { 0x00, 0x40, 0x40 },
    3178                 : { 0x01, 0x61, 0x41 },
    3179                 : { 0x01, 0x62, 0x42 },
    3180                 : { 0x01, 0x63, 0x43 },
    3181                 : { 0x01, 0x64, 0x44 },
    3182                 : { 0x01, 0x65, 0x45 },
    3183                 : { 0x01, 0x66, 0x46 },
    3184                 : { 0x01, 0x67, 0x47 },
    3185                 : { 0x01, 0x68, 0x48 },
    3186                 : { 0x01, 0x69, 0x49 },
    3187                 : { 0x01, 0x6a, 0x4a },
    3188                 : { 0x01, 0x6b, 0x4b },
    3189                 : { 0x01, 0x6c, 0x4c },
    3190                 : { 0x01, 0x6d, 0x4d },
    3191                 : { 0x01, 0x6e, 0x4e },
    3192                 : { 0x01, 0x6f, 0x4f },
    3193                 : { 0x01, 0x70, 0x50 },
    3194                 : { 0x01, 0x71, 0x51 },
    3195                 : { 0x01, 0x72, 0x52 },
    3196                 : { 0x01, 0x73, 0x53 },
    3197                 : { 0x01, 0x74, 0x54 },
    3198                 : { 0x01, 0x75, 0x55 },
    3199                 : { 0x01, 0x76, 0x56 },
    3200                 : { 0x01, 0x77, 0x57 },
    3201                 : { 0x01, 0x78, 0x58 },
    3202                 : { 0x01, 0x79, 0x59 },
    3203                 : { 0x01, 0x7a, 0x5a },
    3204                 : { 0x00, 0x5b, 0x5b },
    3205                 : { 0x00, 0x5c, 0x5c },
    3206                 : { 0x00, 0x5d, 0x5d },
    3207                 : { 0x00, 0x5e, 0x5e },
    3208                 : { 0x00, 0x5f, 0x5f },
    3209                 : { 0x00, 0x60, 0x60 },
    3210                 : { 0x00, 0x61, 0x41 },
    3211                 : { 0x00, 0x62, 0x42 },
    3212                 : { 0x00, 0x63, 0x43 },
    3213                 : { 0x00, 0x64, 0x44 },
    3214                 : { 0x00, 0x65, 0x45 },
    3215                 : { 0x00, 0x66, 0x46 },
    3216                 : { 0x00, 0x67, 0x47 },
    3217                 : { 0x00, 0x68, 0x48 },
    3218                 : { 0x00, 0x69, 0x49 },
    3219                 : { 0x00, 0x6a, 0x4a },
    3220                 : { 0x00, 0x6b, 0x4b },
    3221                 : { 0x00, 0x6c, 0x4c },
    3222                 : { 0x00, 0x6d, 0x4d },
    3223                 : { 0x00, 0x6e, 0x4e },
    3224                 : { 0x00, 0x6f, 0x4f },
    3225                 : { 0x00, 0x70, 0x50 },
    3226                 : { 0x00, 0x71, 0x51 },
    3227                 : { 0x00, 0x72, 0x52 },
    3228                 : { 0x00, 0x73, 0x53 },
    3229                 : { 0x00, 0x74, 0x54 },
    3230                 : { 0x00, 0x75, 0x55 },
    3231                 : { 0x00, 0x76, 0x56 },
    3232                 : { 0x00, 0x77, 0x57 },
    3233                 : { 0x00, 0x78, 0x58 },
    3234                 : { 0x00, 0x79, 0x59 },
    3235                 : { 0x00, 0x7a, 0x5a },
    3236                 : { 0x00, 0x7b, 0x7b },
    3237                 : { 0x00, 0x7c, 0x7c },
    3238                 : { 0x00, 0x7d, 0x7d },
    3239                 : { 0x00, 0x7e, 0x7e },
    3240                 : { 0x00, 0x7f, 0x7f },
    3241                 : { 0x00, 0x80, 0x80 },
    3242                 : { 0x00, 0x81, 0x81 },
    3243                 : { 0x00, 0x82, 0x82 },
    3244                 : { 0x00, 0x83, 0x83 },
    3245                 : { 0x00, 0x84, 0x84 },
    3246                 : { 0x00, 0x85, 0x85 },
    3247                 : { 0x00, 0x86, 0x86 },
    3248                 : { 0x00, 0x87, 0x87 },
    3249                 : { 0x00, 0x88, 0x88 },
    3250                 : { 0x00, 0x89, 0x89 },
    3251                 : { 0x00, 0x8a, 0x8a },
    3252                 : { 0x00, 0x8b, 0x8b },
    3253                 : { 0x00, 0x8c, 0x8c },
    3254                 : { 0x00, 0x8d, 0x8d },
    3255                 : { 0x00, 0x8e, 0x8e },
    3256                 : { 0x00, 0x8f, 0x8f },
    3257                 : { 0x00, 0x90, 0x90 },
    3258                 : { 0x00, 0x91, 0x91 },
    3259                 : { 0x00, 0x92, 0x92 },
    3260                 : { 0x00, 0x93, 0x93 },
    3261                 : { 0x00, 0x94, 0x94 },
    3262                 : { 0x00, 0x95, 0x95 },
    3263                 : { 0x00, 0x96, 0x96 },
    3264                 : { 0x00, 0x97, 0x97 },
    3265                 : { 0x00, 0x98, 0x98 },
    3266                 : { 0x00, 0x99, 0x99 },
    3267                 : { 0x00, 0x9a, 0x9a },
    3268                 : { 0x00, 0x9b, 0x9b },
    3269                 : { 0x00, 0x9c, 0x9c },
    3270                 : { 0x00, 0x9d, 0x9d },
    3271                 : { 0x00, 0x9e, 0x9e },
    3272                 : { 0x00, 0x9f, 0x9f },
    3273                 : { 0x00, 0xa0, 0xa0 },
    3274                 : { 0x00, 0xa1, 0xa1 },
    3275                 : { 0x00, 0xa2, 0xa2 },
    3276                 : { 0x00, 0xa3, 0xa3 },
    3277                 : { 0x00, 0xa4, 0xa4 },
    3278                 : { 0x00, 0xa5, 0xa5 },
    3279                 : { 0x00, 0xa6, 0xa6 },
    3280                 : { 0x00, 0xa7, 0xa7 },
    3281                 : { 0x00, 0xa8, 0xa8 },
    3282                 : { 0x00, 0xa9, 0xa9 },
    3283                 : { 0x00, 0xaa, 0xaa },
    3284                 : { 0x00, 0xab, 0xab },
    3285                 : { 0x00, 0xac, 0xac },
    3286                 : { 0x00, 0xad, 0xad },
    3287                 : { 0x00, 0xae, 0xae },
    3288                 : { 0x00, 0xaf, 0xaf },
    3289                 : { 0x00, 0xb0, 0xb0 },
    3290                 : { 0x00, 0xb1, 0xb1 },
    3291                 : { 0x00, 0xb2, 0xb2 },
    3292                 : { 0x00, 0xb3, 0xb3 },
    3293                 : { 0x00, 0xb4, 0xb4 },
    3294                 : { 0x00, 0xb5, 0xb5 },
    3295                 : { 0x00, 0xb6, 0xb6 },
    3296                 : { 0x00, 0xb7, 0xb7 },
    3297                 : { 0x00, 0xb8, 0xb8 },
    3298                 : { 0x00, 0xb9, 0xb9 },
    3299                 : { 0x00, 0xba, 0xba },
    3300                 : { 0x00, 0xbb, 0xbb },
    3301                 : { 0x00, 0xbc, 0xbc },
    3302                 : { 0x00, 0xbd, 0xbd },
    3303                 : { 0x00, 0xbe, 0xbe },
    3304                 : { 0x00, 0xbf, 0xbf },
    3305                 : { 0x00, 0xc0, 0xc0 },
    3306                 : { 0x00, 0xc1, 0xc1 },
    3307                 : { 0x00, 0xc2, 0xc2 },
    3308                 : { 0x00, 0xc3, 0xc3 },
    3309                 : { 0x00, 0xc4, 0xc4 },
    3310                 : { 0x00, 0xc5, 0xc5 },
    3311                 : { 0x00, 0xc6, 0xc6 },
    3312                 : { 0x00, 0xc7, 0xc7 },
    3313                 : { 0x00, 0xc8, 0xc8 },
    3314                 : { 0x00, 0xc9, 0xc9 },
    3315                 : { 0x00, 0xca, 0xca },
    3316                 : { 0x00, 0xcb, 0xcb },
    3317                 : { 0x00, 0xcc, 0xcc },
    3318                 : { 0x00, 0xcd, 0xcd },
    3319                 : { 0x00, 0xce, 0xce },
    3320                 : { 0x00, 0xcf, 0xcf },
    3321                 : { 0x00, 0xd0, 0xd0 },
    3322                 : { 0x00, 0xd1, 0xd1 },
    3323                 : { 0x00, 0xd2, 0xd2 },
    3324                 : { 0x00, 0xd3, 0xd3 },
    3325                 : { 0x00, 0xd4, 0xd4 },
    3326                 : { 0x00, 0xd5, 0xd5 },
    3327                 : { 0x00, 0xd6, 0xd6 },
    3328                 : { 0x00, 0xd7, 0xd7 },
    3329                 : { 0x00, 0xd8, 0xd8 },
    3330                 : { 0x00, 0xd9, 0xd9 },
    3331                 : { 0x00, 0xda, 0xda },
    3332                 : { 0x00, 0xdb, 0xdb },
    3333                 : { 0x00, 0xdc, 0xdc },
    3334                 : { 0x00, 0xdd, 0xdd },
    3335                 : { 0x00, 0xde, 0xde },
    3336                 : { 0x00, 0xdf, 0xdf },
    3337                 : { 0x00, 0xe0, 0xe0 },
    3338                 : { 0x00, 0xe1, 0xe1 },
    3339                 : { 0x00, 0xe2, 0xe2 },
    3340                 : { 0x00, 0xe3, 0xe3 },
    3341                 : { 0x00, 0xe4, 0xe4 },
    3342                 : { 0x00, 0xe5, 0xe5 },
    3343                 : { 0x00, 0xe6, 0xe6 },
    3344                 : { 0x00, 0xe7, 0xe7 },
    3345                 : { 0x00, 0xe8, 0xe8 },
    3346                 : { 0x00, 0xe9, 0xe9 },
    3347                 : { 0x00, 0xea, 0xea },
    3348                 : { 0x00, 0xeb, 0xeb },
    3349                 : { 0x00, 0xec, 0xec },
    3350                 : { 0x00, 0xed, 0xed },
    3351                 : { 0x00, 0xee, 0xee },
    3352                 : { 0x00, 0xef, 0xef },
    3353                 : { 0x00, 0xf0, 0xf0 },
    3354                 : { 0x00, 0xf1, 0xf1 },
    3355                 : { 0x00, 0xf2, 0xf2 },
    3356                 : { 0x00, 0xf3, 0xf3 },
    3357                 : { 0x00, 0xf4, 0xf4 },
    3358                 : { 0x00, 0xf5, 0xf5 },
    3359                 : { 0x00, 0xf6, 0xf6 },
    3360                 : { 0x00, 0xf7, 0xf7 },
    3361                 : { 0x00, 0xf8, 0xf8 },
    3362                 : { 0x00, 0xf9, 0xf9 },
    3363                 : { 0x00, 0xfa, 0xfa },
    3364                 : { 0x00, 0xfb, 0xfb },
    3365                 : { 0x00, 0xfc, 0xfc },
    3366                 : { 0x00, 0xfd, 0xfd },
    3367                 : { 0x00, 0xfe, 0xfe },
    3368                 : { 0x00, 0xff, 0xff }
    3369                 : };
    3370                 : 
    3371                 : static struct cs_info koi8r_tbl[] = {
    3372                 : { 0x00, 0x00, 0x00 },
    3373                 : { 0x00, 0x01, 0x01 },
    3374                 : { 0x00, 0x02, 0x02 },
    3375                 : { 0x00, 0x03, 0x03 },
    3376                 : { 0x00, 0x04, 0x04 },
    3377                 : { 0x00, 0x05, 0x05 },
    3378                 : { 0x00, 0x06, 0x06 },
    3379                 : { 0x00, 0x07, 0x07 },
    3380                 : { 0x00, 0x08, 0x08 },
    3381                 : { 0x00, 0x09, 0x09 },
    3382                 : { 0x00, 0x0a, 0x0a },
    3383                 : { 0x00, 0x0b, 0x0b },
    3384                 : { 0x00, 0x0c, 0x0c },
    3385                 : { 0x00, 0x0d, 0x0d },
    3386                 : { 0x00, 0x0e, 0x0e },
    3387                 : { 0x00, 0x0f, 0x0f },
    3388                 : { 0x00, 0x10, 0x10 },
    3389                 : { 0x00, 0x11, 0x11 },
    3390                 : { 0x00, 0x12, 0x12 },
    3391                 : { 0x00, 0x13, 0x13 },
    3392                 : { 0x00, 0x14, 0x14 },
    3393                 : { 0x00, 0x15, 0x15 },
    3394                 : { 0x00, 0x16, 0x16 },
    3395                 : { 0x00, 0x17, 0x17 },
    3396                 : { 0x00, 0x18, 0x18 },
    3397                 : { 0x00, 0x19, 0x19 },
    3398                 : { 0x00, 0x1a, 0x1a },
    3399                 : { 0x00, 0x1b, 0x1b },
    3400                 : { 0x00, 0x1c, 0x1c },
    3401                 : { 0x00, 0x1d, 0x1d },
    3402                 : { 0x00, 0x1e, 0x1e },
    3403                 : { 0x00, 0x1f, 0x1f },
    3404                 : { 0x00, 0x20, 0x20 },
    3405                 : { 0x00, 0x21, 0x21 },
    3406                 : { 0x00, 0x22, 0x22 },
    3407                 : { 0x00, 0x23, 0x23 },
    3408                 : { 0x00, 0x24, 0x24 },
    3409                 : { 0x00, 0x25, 0x25 },
    3410                 : { 0x00, 0x26, 0x26 },
    3411                 : { 0x00, 0x27, 0x27 },
    3412                 : { 0x00, 0x28, 0x28 },
    3413                 : { 0x00, 0x29, 0x29 },
    3414                 : { 0x00, 0x2a, 0x2a },
    3415                 : { 0x00, 0x2b, 0x2b },
    3416                 : { 0x00, 0x2c, 0x2c },
    3417                 : { 0x00, 0x2d, 0x2d },
    3418                 : { 0x00, 0x2e, 0x2e },
    3419                 : { 0x00, 0x2f, 0x2f },
    3420                 : { 0x00, 0x30, 0x30 },
    3421                 : { 0x00, 0x31, 0x31 },
    3422                 : { 0x00, 0x32, 0x32 },
    3423                 : { 0x00, 0x33, 0x33 },
    3424                 : { 0x00, 0x34, 0x34 },
    3425                 : { 0x00, 0x35, 0x35 },
    3426                 : { 0x00, 0x36, 0x36 },
    3427                 : { 0x00, 0x37, 0x37 },
    3428                 : { 0x00, 0x38, 0x38 },
    3429                 : { 0x00, 0x39, 0x39 },
    3430                 : { 0x00, 0x3a, 0x3a },
    3431                 : { 0x00, 0x3b, 0x3b },
    3432                 : { 0x00, 0x3c, 0x3c },
    3433                 : { 0x00, 0x3d, 0x3d },
    3434                 : { 0x00, 0x3e, 0x3e },
    3435                 : { 0x00, 0x3f, 0x3f },
    3436                 : { 0x00, 0x40, 0x40 },
    3437                 : { 0x01, 0x61, 0x41 },
    3438                 : { 0x01, 0x62, 0x42 },
    3439                 : { 0x01, 0x63, 0x43 },
    3440                 : { 0x01, 0x64, 0x44 },
    3441                 : { 0x01, 0x65, 0x45 },
    3442                 : { 0x01, 0x66, 0x46 },
    3443                 : { 0x01, 0x67, 0x47 },
    3444                 : { 0x01, 0x68, 0x48 },
    3445                 : { 0x01, 0x69, 0x49 },
    3446                 : { 0x01, 0x6a, 0x4a },
    3447                 : { 0x01, 0x6b, 0x4b },
    3448                 : { 0x01, 0x6c, 0x4c },
    3449                 : { 0x01, 0x6d, 0x4d },
    3450                 : { 0x01, 0x6e, 0x4e },
    3451                 : { 0x01, 0x6f, 0x4f },
    3452                 : { 0x01, 0x70, 0x50 },
    3453                 : { 0x01, 0x71, 0x51 },
    3454                 : { 0x01, 0x72, 0x52 },
    3455                 : { 0x01, 0x73, 0x53 },
    3456                 : { 0x01, 0x74, 0x54 },
    3457                 : { 0x01, 0x75, 0x55 },
    3458                 : { 0x01, 0x76, 0x56 },
    3459                 : { 0x01, 0x77, 0x57 },
    3460                 : { 0x01, 0x78, 0x58 },
    3461                 : { 0x01, 0x79, 0x59 },
    3462                 : { 0x01, 0x7a, 0x5a },
    3463                 : { 0x00, 0x5b, 0x5b },
    3464                 : { 0x00, 0x5c, 0x5c },
    3465                 : { 0x00, 0x5d, 0x5d },
    3466                 : { 0x00, 0x5e, 0x5e },
    3467                 : { 0x00, 0x5f, 0x5f },
    3468                 : { 0x00, 0x60, 0x60 },
    3469                 : { 0x00, 0x61, 0x41 },
    3470                 : { 0x00, 0x62, 0x42 },
    3471                 : { 0x00, 0x63, 0x43 },
    3472                 : { 0x00, 0x64, 0x44 },
    3473                 : { 0x00, 0x65, 0x45 },
    3474                 : { 0x00, 0x66, 0x46 },
    3475                 : { 0x00, 0x67, 0x47 },
    3476                 : { 0x00, 0x68, 0x48 },
    3477                 : { 0x00, 0x69, 0x49 },
    3478                 : { 0x00, 0x6a, 0x4a },
    3479                 : { 0x00, 0x6b, 0x4b },
    3480                 : { 0x00, 0x6c, 0x4c },
    3481                 : { 0x00, 0x6d, 0x4d },
    3482                 : { 0x00, 0x6e, 0x4e },
    3483                 : { 0x00, 0x6f, 0x4f },
    3484                 : { 0x00, 0x70, 0x50 },
    3485                 : { 0x00, 0x71, 0x51 },
    3486                 : { 0x00, 0x72, 0x52 },
    3487                 : { 0x00, 0x73, 0x53 },
    3488                 : { 0x00, 0x74, 0x54 },
    3489                 : { 0x00, 0x75, 0x55 },
    3490                 : { 0x00, 0x76, 0x56 },
    3491                 : { 0x00, 0x77, 0x57 },
    3492                 : { 0x00, 0x78, 0x58 },
    3493                 : { 0x00, 0x79, 0x59 },
    3494                 : { 0x00, 0x7a, 0x5a },
    3495                 : { 0x00, 0x7b, 0x7b },
    3496                 : { 0x00, 0x7c, 0x7c },
    3497                 : { 0x00, 0x7d, 0x7d },
    3498                 : { 0x00, 0x7e, 0x7e },
    3499                 : { 0x00, 0x7f, 0x7f },
    3500                 : { 0x00, 0x80, 0x80 },
    3501                 : { 0x00, 0x81, 0x81 },
    3502                 : { 0x00, 0x82, 0x82 },
    3503                 : { 0x00, 0x83, 0x83 },
    3504                 : { 0x00, 0x84, 0x84 },
    3505                 : { 0x00, 0x85, 0x85 },
    3506                 : { 0x00, 0x86, 0x86 },
    3507                 : { 0x00, 0x87, 0x87 },
    3508                 : { 0x00, 0x88, 0x88 },
    3509                 : { 0x00, 0x89, 0x89 },
    3510                 : { 0x00, 0x8a, 0x8a },
    3511                 : { 0x00, 0x8b, 0x8b },
    3512                 : { 0x00, 0x8c, 0x8c },
    3513                 : { 0x00, 0x8d, 0x8d },
    3514                 : { 0x00, 0x8e, 0x8e },
    3515                 : { 0x00, 0x8f, 0x8f },
    3516                 : { 0x00, 0x90, 0x90 },
    3517                 : { 0x00, 0x91, 0x91 },
    3518                 : { 0x00, 0x92, 0x92 },
    3519                 : { 0x00, 0x93, 0x93 },
    3520                 : { 0x00, 0x94, 0x94 },
    3521                 : { 0x00, 0x95, 0x95 },
    3522                 : { 0x00, 0x96, 0x96 },
    3523                 : { 0x00, 0x97, 0x97 },
    3524                 : { 0x00, 0x98, 0x98 },
    3525                 : { 0x00, 0x99, 0x99 },
    3526                 : { 0x00, 0x9a, 0x9a },
    3527                 : { 0x00, 0x9b, 0x9b },
    3528                 : { 0x00, 0x9c, 0x9c },
    3529                 : { 0x00, 0x9d, 0x9d },
    3530                 : { 0x00, 0x9e, 0x9e },
    3531                 : { 0x00, 0x9f, 0x9f },
    3532                 : { 0x00, 0xa0, 0xa0 },
    3533                 : { 0x00, 0xa1, 0xa1 },
    3534                 : { 0x00, 0xa2, 0xa2 },
    3535                 : { 0x00, 0xa3, 0xb3 },
    3536                 : { 0x00, 0xa4, 0xa4 },
    3537                 : { 0x00, 0xa5, 0xa5 },
    3538                 : { 0x00, 0xa6, 0xa6 },
    3539                 : { 0x00, 0xa7, 0xa7 },
    3540                 : { 0x00, 0xa8, 0xa8 },
    3541                 : { 0x00, 0xa9, 0xa9 },
    3542                 : { 0x00, 0xaa, 0xaa },
    3543                 : { 0x00, 0xab, 0xab },
    3544                 : { 0x00, 0xac, 0xac },
    3545                 : { 0x00, 0xad, 0xad },
    3546                 : { 0x00, 0xae, 0xae },
    3547                 : { 0x00, 0xaf, 0xaf },
    3548                 : { 0x00, 0xb0, 0xb0 },
    3549                 : { 0x00, 0xb1, 0xb1 },
    3550                 : { 0x00, 0xb2, 0xb2 },
    3551                 : { 0x01, 0xa3, 0xb3 },
    3552                 : { 0x00, 0xb4, 0xb4 },
    3553                 : { 0x00, 0xb5, 0xb5 },
    3554                 : { 0x00, 0xb6, 0xb6 },
    3555                 : { 0x00, 0xb7, 0xb7 },
    3556                 : { 0x00, 0xb8, 0xb8 },
    3557                 : { 0x00, 0xb9, 0xb9 },
    3558                 : { 0x00, 0xba, 0xba },
    3559                 : { 0x00, 0xbb, 0xbb },
    3560                 : { 0x00, 0xbc, 0xbc },
    3561                 : { 0x00, 0xbd, 0xbd },
    3562                 : { 0x00, 0xbe, 0xbe },
    3563                 : { 0x00, 0xbf, 0xbf },
    3564                 : { 0x00, 0xc0, 0xe0 },
    3565                 : { 0x00, 0xc1, 0xe1 },
    3566                 : { 0x00, 0xc2, 0xe2 },
    3567                 : { 0x00, 0xc3, 0xe3 },
    3568                 : { 0x00, 0xc4, 0xe4 },
    3569                 : { 0x00, 0xc5, 0xe5 },
    3570                 : { 0x00, 0xc6, 0xe6 },
    3571                 : { 0x00, 0xc7, 0xe7 },
    3572                 : { 0x00, 0xc8, 0xe8 },
    3573                 : { 0x00, 0xc9, 0xe9 },
    3574                 : { 0x00, 0xca, 0xea },
    3575                 : { 0x00, 0xcb, 0xeb },
    3576                 : { 0x00, 0xcc, 0xec },
    3577                 : { 0x00, 0xcd, 0xed },
    3578                 : { 0x00, 0xce, 0xee },
    3579                 : { 0x00, 0xcf, 0xef },
    3580                 : { 0x00, 0xd0, 0xf0 },
    3581                 : { 0x00, 0xd1, 0xf1 },
    3582                 : { 0x00, 0xd2, 0xf2 },
    3583                 : { 0x00, 0xd3, 0xf3 },
    3584                 : { 0x00, 0xd4, 0xf4 },
    3585                 : { 0x00, 0xd5, 0xf5 },
    3586                 : { 0x00, 0xd6, 0xf6 },
    3587                 : { 0x00, 0xd7, 0xf7 },
    3588                 : { 0x00, 0xd8, 0xf8 },
    3589                 : { 0x00, 0xd9, 0xf9 },
    3590                 : { 0x00, 0xda, 0xfa },
    3591                 : { 0x00, 0xdb, 0xfb },
    3592                 : { 0x00, 0xdc, 0xfc },
    3593                 : { 0x00, 0xdd, 0xfd },
    3594                 : { 0x00, 0xde, 0xfe },
    3595                 : { 0x00, 0xdf, 0xff },
    3596                 : { 0x01, 0xc0, 0xe0 },
    3597                 : { 0x01, 0xc1, 0xe1 },
    3598                 : { 0x01, 0xc2, 0xe2 },
    3599                 : { 0x01, 0xc3, 0xe3 },
    3600                 : { 0x01, 0xc4, 0xe4 },
    3601                 : { 0x01, 0xc5, 0xe5 },
    3602                 : { 0x01, 0xc6, 0xe6 },
    3603                 : { 0x01, 0xc7, 0xe7 },
    3604                 : { 0x01, 0xc8, 0xe8 },
    3605                 : { 0x01, 0xc9, 0xe9 },
    3606                 : { 0x01, 0xca, 0xea },
    3607                 : { 0x01, 0xcb, 0xeb },
    3608                 : { 0x01, 0xcc, 0xec },
    3609                 : { 0x01, 0xcd, 0xed },
    3610                 : { 0x01, 0xce, 0xee },
    3611                 : { 0x01, 0xcf, 0xef },
    3612                 : { 0x01, 0xd0, 0xf0 },
    3613                 : { 0x01, 0xd1, 0xf1 },
    3614                 : { 0x01, 0xd2, 0xf2 },
    3615                 : { 0x01, 0xd3, 0xf3 },
    3616                 : { 0x01, 0xd4, 0xf4 },
    3617                 : { 0x01, 0xd5, 0xf5 },
    3618                 : { 0x01, 0xd6, 0xf6 },
    3619                 : { 0x01, 0xd7, 0xf7 },
    3620                 : { 0x01, 0xd8, 0xf8 },
    3621                 : { 0x01, 0xd9, 0xf9 },
    3622                 : { 0x01, 0xda, 0xfa },
    3623                 : { 0x01, 0xdb, 0xfb },
    3624                 : { 0x01, 0xdc, 0xfc },
    3625                 : { 0x01, 0xdd, 0xfd },
    3626                 : { 0x01, 0xde, 0xfe },
    3627                 : { 0x01, 0xdf, 0xff }
    3628                 : };
    3629                 : 
    3630                 : static struct cs_info koi8u_tbl[] = {
    3631                 : { 0x00, 0x00, 0x00 },
    3632                 : { 0x00, 0x01, 0x01 },
    3633                 : { 0x00, 0x02, 0x02 },
    3634                 : { 0x00, 0x03, 0x03 },
    3635                 : { 0x00, 0x04, 0x04 },
    3636                 : { 0x00, 0x05, 0x05 },
    3637                 : { 0x00, 0x06, 0x06 },
    3638                 : { 0x00, 0x07, 0x07 },
    3639                 : { 0x00, 0x08, 0x08 },
    3640                 : { 0x00, 0x09, 0x09 },
    3641                 : { 0x00, 0x0a, 0x0a },
    3642                 : { 0x00, 0x0b, 0x0b },
    3643                 : { 0x00, 0x0c, 0x0c },
    3644                 : { 0x00, 0x0d, 0x0d },
    3645                 : { 0x00, 0x0e, 0x0e },
    3646                 : { 0x00, 0x0f, 0x0f },
    3647                 : { 0x00, 0x10, 0x10 },
    3648                 : { 0x00, 0x11, 0x11 },
    3649                 : { 0x00, 0x12, 0x12 },
    3650                 : { 0x00, 0x13, 0x13 },
    3651                 : { 0x00, 0x14, 0x14 },
    3652                 : { 0x00, 0x15, 0x15 },
    3653                 : { 0x00, 0x16, 0x16 },
    3654                 : { 0x00, 0x17, 0x17 },
    3655                 : { 0x00, 0x18, 0x18 },
    3656                 : { 0x00, 0x19, 0x19 },
    3657                 : { 0x00, 0x1a, 0x1a },
    3658                 : { 0x00, 0x1b, 0x1b },
    3659                 : { 0x00, 0x1c, 0x1c },
    3660                 : { 0x00, 0x1d, 0x1d },
    3661                 : { 0x00, 0x1e, 0x1e },
    3662                 : { 0x00, 0x1f, 0x1f },
    3663                 : { 0x00, 0x20, 0x20 },
    3664                 : { 0x00, 0x21, 0x21 },
    3665                 : { 0x00, 0x22, 0x22 },
    3666                 : { 0x00, 0x23, 0x23 },
    3667                 : { 0x00, 0x24, 0x24 },
    3668                 : { 0x00, 0x25, 0x25 },
    3669                 : { 0x00, 0x26, 0x26 },
    3670                 : { 0x00, 0x27, 0x27 },
    3671                 : { 0x00, 0x28, 0x28 },
    3672                 : { 0x00, 0x29, 0x29 },
    3673                 : { 0x00, 0x2a, 0x2a },
    3674                 : { 0x00, 0x2b, 0x2b },
    3675                 : { 0x00, 0x2c, 0x2c },
    3676                 : { 0x00, 0x2d, 0x2d },
    3677                 : { 0x00, 0x2e, 0x2e },
    3678                 : { 0x00, 0x2f, 0x2f },
    3679                 : { 0x00, 0x30, 0x30 },
    3680                 : { 0x00, 0x31, 0x31 },
    3681                 : { 0x00, 0x32, 0x32 },
    3682                 : { 0x00, 0x33, 0x33 },
    3683                 : { 0x00, 0x34, 0x34 },
    3684                 : { 0x00, 0x35, 0x35 },
    3685                 : { 0x00, 0x36, 0x36 },
    3686                 : { 0x00, 0x37, 0x37 },
    3687                 : { 0x00, 0x38, 0x38 },
    3688                 : { 0x00, 0x39, 0x39 },
    3689                 : { 0x00, 0x3a, 0x3a },
    3690                 : { 0x00, 0x3b, 0x3b },
    3691                 : { 0x00, 0x3c, 0x3c },
    3692                 : { 0x00, 0x3d, 0x3d },
    3693                 : { 0x00, 0x3e, 0x3e },
    3694                 : { 0x00, 0x3f, 0x3f },
    3695                 : { 0x00, 0x40, 0x40 },
    3696                 : { 0x01, 0x61, 0x41 },
    3697                 : { 0x01, 0x62, 0x42 },
    3698                 : { 0x01, 0x63, 0x43 },
    3699                 : { 0x01, 0x64, 0x44 },
    3700                 : { 0x01, 0x65, 0x45 },
    3701                 : { 0x01, 0x66, 0x46 },
    3702                 : { 0x01, 0x67, 0x47 },
    3703                 : { 0x01, 0x68, 0x48 },
    3704                 : { 0x01, 0x69, 0x49 },
    3705                 : { 0x01, 0x6a, 0x4a },
    3706                 : { 0x01, 0x6b, 0x4b },
    3707                 : { 0x01, 0x6c, 0x4c },
    3708                 : { 0x01, 0x6d, 0x4d },
    3709                 : { 0x01, 0x6e, 0x4e },
    3710                 : { 0x01, 0x6f, 0x4f },
    3711                 : { 0x01, 0x70, 0x50 },
    3712                 : { 0x01, 0x71, 0x51 },
    3713                 : { 0x01, 0x72, 0x52 },
    3714                 : { 0x01, 0x73, 0x53 },
    3715                 : { 0x01, 0x74, 0x54 },
    3716                 : { 0x01, 0x75, 0x55 },
    3717                 : { 0x01, 0x76, 0x56 },
    3718                 : { 0x01, 0x77, 0x57 },
    3719                 : { 0x01, 0x78, 0x58 },
    3720                 : { 0x01, 0x79, 0x59 },
    3721                 : { 0x01, 0x7a, 0x5a },
    3722                 : { 0x00, 0x5b, 0x5b },
    3723                 : { 0x00, 0x5c, 0x5c },
    3724                 : { 0x00, 0x5d, 0x5d },
    3725                 : { 0x00, 0x5e, 0x5e },
    3726                 : { 0x00, 0x5f, 0x5f },
    3727                 : { 0x00, 0x60, 0x60 },
    3728                 : { 0x00, 0x61, 0x41 },
    3729                 : { 0x00, 0x62, 0x42 },
    3730                 : { 0x00, 0x63, 0x43 },
    3731                 : { 0x00, 0x64, 0x44 },
    3732                 : { 0x00, 0x65, 0x45 },
    3733                 : { 0x00, 0x66, 0x46 },
    3734                 : { 0x00, 0x67, 0x47 },
    3735                 : { 0x00, 0x68, 0x48 },
    3736                 : { 0x00, 0x69, 0x49 },
    3737                 : { 0x00, 0x6a, 0x4a },
    3738                 : { 0x00, 0x6b, 0x4b },
    3739                 : { 0x00, 0x6c, 0x4c },
    3740                 : { 0x00, 0x6d, 0x4d },
    3741                 : { 0x00, 0x6e, 0x4e },
    3742                 : { 0x00, 0x6f, 0x4f },
    3743                 : { 0x00, 0x70, 0x50 },
    3744                 : { 0x00, 0x71, 0x51 },
    3745                 : { 0x00, 0x72, 0x52 },
    3746                 : { 0x00, 0x73, 0x53 },
    3747                 : { 0x00, 0x74, 0x54 },
    3748                 : { 0x00, 0x75, 0x55 },
    3749                 : { 0x00, 0x76, 0x56 },
    3750                 : { 0x00, 0x77, 0x57 },
    3751                 : { 0x00, 0x78, 0x58 },
    3752                 : { 0x00, 0x79, 0x59 },
    3753                 : { 0x00, 0x7a, 0x5a },
    3754                 : { 0x00, 0x7b, 0x7b },
    3755                 : { 0x00, 0x7c, 0x7c },
    3756                 : { 0x00, 0x7d, 0x7d },
    3757                 : { 0x00, 0x7e, 0x7e },
    3758                 : { 0x00, 0x7f, 0x7f },
    3759                 : { 0x00, 0x80, 0x80 },
    3760                 : { 0x00, 0x81, 0x81 },
    3761                 : { 0x00, 0x82, 0x82 },
    3762                 : { 0x00, 0x83, 0x83 },
    3763                 : { 0x00, 0x84, 0x84 },
    3764                 : { 0x00, 0x85, 0x85 },
    3765                 : { 0x00, 0x86, 0x86 },
    3766                 : { 0x00, 0x87, 0x87 },
    3767                 : { 0x00, 0x88, 0x88 },
    3768                 : { 0x00, 0x89, 0x89 },
    3769                 : { 0x00, 0x8a, 0x8a },
    3770                 : { 0x00, 0x8b, 0x8b },
    3771                 : { 0x00, 0x8c, 0x8c },
    3772                 : { 0x00, 0x8d, 0x8d },
    3773                 : { 0x00, 0x8e, 0x8e },
    3774                 : { 0x00, 0x8f, 0x8f },
    3775                 : { 0x00, 0x90, 0x90 },
    3776                 : { 0x00, 0x91, 0x91 },
    3777                 : { 0x00, 0x92, 0x92 },
    3778                 : { 0x00, 0x93, 0x93 },
    3779                 : { 0x00, 0x94, 0x94 },
    3780                 : { 0x00, 0x95, 0x95 },
    3781                 : { 0x00, 0x96, 0x96 },
    3782                 : { 0x00, 0x97, 0x97 },
    3783                 : { 0x00, 0x98, 0x98 },
    3784                 : { 0x00, 0x99, 0x99 },
    3785                 : { 0x00, 0x9a, 0x9a },
    3786                 : { 0x00, 0x9b, 0x9b },
    3787                 : { 0x00, 0x9c, 0x9c },
    3788                 : { 0x00, 0x9d, 0x9d },
    3789                 : { 0x00, 0x9e, 0x9e },
    3790                 : { 0x00, 0x9f, 0x9f },
    3791                 : { 0x00, 0xa0, 0xa0 },
    3792                 : { 0x00, 0xa1, 0xa1 },
    3793                 : { 0x00, 0xa2, 0xa2 },
    3794                 : { 0x00, 0xa3, 0xb3 },
    3795                 : { 0x00, 0xa4, 0xb4 }, /* ie */
    3796                 : { 0x00, 0xa5, 0xa5 },
    3797                 : { 0x00, 0xa6, 0xb6 }, /* i */
    3798                 : { 0x00, 0xa7, 0xb7 }, /* ii */
    3799                 : { 0x00, 0xa8, 0xa8 },
    3800                 : { 0x00, 0xa9, 0xa9 },
    3801                 : { 0x00, 0xaa, 0xaa },
    3802                 : { 0x00, 0xab, 0xab },
    3803                 : { 0x00, 0xac, 0xac },
    3804                 : { 0x00, 0xad, 0xbd }, /* g'' */
    3805                 : { 0x00, 0xae, 0xae },
    3806                 : { 0x00, 0xaf, 0xaf },
    3807                 : { 0x00, 0xb0, 0xb0 },
    3808                 : { 0x00, 0xb1, 0xb1 },
    3809                 : { 0x00, 0xb2, 0xb2 },
    3810                 : { 0x01, 0xa3, 0xb3 },
    3811                 : { 0x00, 0xb4, 0xb4 }, /* IE */
    3812                 : { 0x00, 0xb5, 0xb5 },
    3813                 : { 0x00, 0xb6, 0xb6 }, /* I */
    3814                 : { 0x00, 0xb7, 0xb7 }, /* II */
    3815                 : { 0x00, 0xb8, 0xb8 },
    3816                 : { 0x00, 0xb9, 0xb9 },
    3817                 : { 0x00, 0xba, 0xba },
    3818                 : { 0x00, 0xbb, 0xbb },
    3819                 : { 0x00, 0xbc, 0xbc },
    3820                 : { 0x00, 0xbd, 0xbd },
    3821                 : { 0x00, 0xbe, 0xbe },
    3822                 : { 0x00, 0xbf, 0xbf },
    3823                 : { 0x00, 0xc0, 0xe0 },
    3824                 : { 0x00, 0xc1, 0xe1 },
    3825                 : { 0x00, 0xc2, 0xe2 },
    3826                 : { 0x00, 0xc3, 0xe3 },
    3827                 : { 0x00, 0xc4, 0xe4 },
    3828                 : { 0x00, 0xc5, 0xe5 },
    3829                 : { 0x00, 0xc6, 0xe6 },
    3830                 : { 0x00, 0xc7, 0xe7 },
    3831                 : { 0x00, 0xc8, 0xe8 },
    3832                 : { 0x00, 0xc9, 0xe9 },
    3833                 : { 0x00, 0xca, 0xea },
    3834                 : { 0x00, 0xcb, 0xeb },
    3835                 : { 0x00, 0xcc, 0xec },
    3836                 : { 0x00, 0xcd, 0xed },
    3837                 : { 0x00, 0xce, 0xee },
    3838                 : { 0x00, 0xcf, 0xef },
    3839                 : { 0x00, 0xd0, 0xf0 },
    3840                 : { 0x00, 0xd1, 0xf1 },
    3841                 : { 0x00, 0xd2, 0xf2 },
    3842                 : { 0x00, 0xd3, 0xf3 },
    3843                 : { 0x00, 0xd4, 0xf4 },
    3844                 : { 0x00, 0xd5, 0xf5 },
    3845                 : { 0x00, 0xd6, 0xf6 },
    3846                 : { 0x00, 0xd7, 0xf7 },
    3847                 : { 0x00, 0xd8, 0xf8 },
    3848                 : { 0x00, 0xd9, 0xf9 },
    3849                 : { 0x00, 0xda, 0xfa },
    3850                 : { 0x00, 0xdb, 0xfb },
    3851                 : { 0x00, 0xdc, 0xfc },
    3852                 : { 0x00, 0xdd, 0xfd },
    3853                 : { 0x00, 0xde, 0xfe },
    3854                 : { 0x00, 0xdf, 0xff },
    3855                 : { 0x01, 0xc0, 0xe0 },
    3856                 : { 0x01, 0xc1, 0xe1 },
    3857                 : { 0x01, 0xc2, 0xe2 },
    3858                 : { 0x01, 0xc3, 0xe3 },
    3859                 : { 0x01, 0xc4, 0xe4 },
    3860                 : { 0x01, 0xc5, 0xe5 },
    3861                 : { 0x01, 0xc6, 0xe6 },
    3862                 : { 0x01, 0xc7, 0xe7 },
    3863                 : { 0x01, 0xc8, 0xe8 },
    3864                 : { 0x01, 0xc9, 0xe9 },
    3865                 : { 0x01, 0xca, 0xea },
    3866                 : { 0x01, 0xcb, 0xeb },
    3867                 : { 0x01, 0xcc, 0xec },
    3868                 : { 0x01, 0xcd, 0xed },
    3869                 : { 0x01, 0xce, 0xee },
    3870                 : { 0x01, 0xcf, 0xef },
    3871                 : { 0x01, 0xd0, 0xf0 },
    3872                 : { 0x01, 0xd1, 0xf1 },
    3873                 : { 0x01, 0xd2, 0xf2 },
    3874                 : { 0x01, 0xd3, 0xf3 },
    3875                 : { 0x01, 0xd4, 0xf4 },
    3876                 : { 0x01, 0xd5, 0xf5 },
    3877                 : { 0x01, 0xd6, 0xf6 },
    3878                 : { 0x01, 0xd7, 0xf7 },
    3879                 : { 0x01, 0xd8, 0xf8 },
    3880                 : { 0x01, 0xd9, 0xf9 },
    3881                 : { 0x01, 0xda, 0xfa },
    3882                 : { 0x01, 0xdb, 0xfb },
    3883                 : { 0x01, 0xdc, 0xfc },
    3884                 : { 0x01, 0xdd, 0xfd },
    3885                 : { 0x01, 0xde, 0xfe },
    3886                 : { 0x01, 0xdf, 0xff }
    3887                 : };
    3888                 : 
    3889                 : static struct cs_info cp1251_tbl[] = {
    3890                 : { 0x00, 0x00, 0x00 },
    3891                 : { 0x00, 0x01, 0x01 },
    3892                 : { 0x00, 0x02, 0x02 },
    3893                 : { 0x00, 0x03, 0x03 },
    3894                 : { 0x00, 0x04, 0x04 },
    3895                 : { 0x00, 0x05, 0x05 },
    3896                 : { 0x00, 0x06, 0x06 },
    3897                 : { 0x00, 0x07, 0x07 },
    3898                 : { 0x00, 0x08, 0x08 },
    3899                 : { 0x00, 0x09, 0x09 },
    3900                 : { 0x00, 0x0a, 0x0a },
    3901                 : { 0x00, 0x0b, 0x0b },
    3902                 : { 0x00, 0x0c, 0x0c },
    3903                 : { 0x00, 0x0d, 0x0d },
    3904                 : { 0x00, 0x0e, 0x0e },
    3905                 : { 0x00, 0x0f, 0x0f },
    3906                 : { 0x00, 0x10, 0x10 },
    3907                 : { 0x00, 0x11, 0x11 },
    3908                 : { 0x00, 0x12, 0x12 },
    3909                 : { 0x00, 0x13, 0x13 },
    3910                 : { 0x00, 0x14, 0x14 },
    3911                 : { 0x00, 0x15, 0x15 },
    3912                 : { 0x00, 0x16, 0x16 },
    3913                 : { 0x00, 0x17, 0x17 },
    3914                 : { 0x00, 0x18, 0x18 },
    3915                 : { 0x00, 0x19, 0x19 },
    3916                 : { 0x00, 0x1a, 0x1a },
    3917                 : { 0x00, 0x1b, 0x1b },
    3918                 : { 0x00, 0x1c, 0x1c },
    3919                 : { 0x00, 0x1d, 0x1d },
    3920                 : { 0x00, 0x1e, 0x1e },
    3921                 : { 0x00, 0x1f, 0x1f },
    3922                 : { 0x00, 0x20, 0x20 },
    3923                 : { 0x00, 0x21, 0x21 },
    3924                 : { 0x00, 0x22, 0x22 },
    3925                 : { 0x00, 0x23, 0x23 },
    3926                 : { 0x00, 0x24, 0x24 },
    3927                 : { 0x00, 0x25, 0x25 },
    3928                 : { 0x00, 0x26, 0x26 },
    3929                 : { 0x00, 0x27, 0x27 },
    3930                 : { 0x00, 0x28, 0x28 },
    3931                 : { 0x00, 0x29, 0x29 },
    3932                 : { 0x00, 0x2a, 0x2a },
    3933                 : { 0x00, 0x2b, 0x2b },
    3934                 : { 0x00, 0x2c, 0x2c },
    3935                 : { 0x00, 0x2d, 0x2d },
    3936                 : { 0x00, 0x2e, 0x2e },
    3937                 : { 0x00, 0x2f, 0x2f },
    3938                 : { 0x00, 0x30, 0x30 },
    3939                 : { 0x00, 0x31, 0x31 },
    3940                 : { 0x00, 0x32, 0x32 },
    3941                 : { 0x00, 0x33, 0x33 },
    3942                 : { 0x00, 0x34, 0x34 },
    3943                 : { 0x00, 0x35, 0x35 },
    3944                 : { 0x00, 0x36, 0x36 },
    3945                 : { 0x00, 0x37, 0x37 },
    3946                 : { 0x00, 0x38, 0x38 },
    3947                 : { 0x00, 0x39, 0x39 },
    3948                 : { 0x00, 0x3a, 0x3a },
    3949                 : { 0x00, 0x3b, 0x3b },
    3950                 : { 0x00, 0x3c, 0x3c },
    3951                 : { 0x00, 0x3d, 0x3d },
    3952                 : { 0x00, 0x3e, 0x3e },
    3953                 : { 0x00, 0x3f, 0x3f },
    3954                 : { 0x00, 0x40, 0x40 },
    3955                 : { 0x01, 0x61, 0x41 },
    3956                 : { 0x01, 0x62, 0x42 },
    3957                 : { 0x01, 0x63, 0x43 },
    3958                 : { 0x01, 0x64, 0x44 },
    3959                 : { 0x01, 0x65, 0x45 },
    3960                 : { 0x01, 0x66, 0x46 },
    3961                 : { 0x01, 0x67, 0x47 },
    3962                 : { 0x01, 0x68, 0x48 },
    3963                 : { 0x01, 0x69, 0x49 },
    3964                 : { 0x01, 0x6a, 0x4a },
    3965                 : { 0x01, 0x6b, 0x4b },
    3966                 : { 0x01, 0x6c, 0x4c },
    3967                 : { 0x01, 0x6d, 0x4d },
    3968                 : { 0x01, 0x6e, 0x4e },
    3969                 : { 0x01, 0x6f, 0x4f },
    3970                 : { 0x01, 0x70, 0x50 },
    3971                 : { 0x01, 0x71, 0x51 },
    3972                 : { 0x01, 0x72, 0x52 },
    3973                 : { 0x01, 0x73, 0x53 },
    3974                 : { 0x01, 0x74, 0x54 },
    3975                 : { 0x01, 0x75, 0x55 },
    3976                 : { 0x01, 0x76, 0x56 },
    3977                 : { 0x01, 0x77, 0x57 },
    3978                 : { 0x01, 0x78, 0x58 },
    3979                 : { 0x01, 0x79, 0x59 },
    3980                 : { 0x01, 0x7a, 0x5a },
    3981                 : { 0x00, 0x5b, 0x5b },
    3982                 : { 0x00, 0x5c, 0x5c },
    3983                 : { 0x00, 0x5d, 0x5d },
    3984                 : { 0x00, 0x5e, 0x5e },
    3985                 : { 0x00, 0x5f, 0x5f },
    3986                 : { 0x00, 0x60, 0x60 },
    3987                 : { 0x00, 0x61, 0x41 },
    3988                 : { 0x00, 0x62, 0x42 },
    3989                 : { 0x00, 0x63, 0x43 },
    3990                 : { 0x00, 0x64, 0x44 },
    3991                 : { 0x00, 0x65, 0x45 },
    3992                 : { 0x00, 0x66, 0x46 },
    3993                 : { 0x00, 0x67, 0x47 },
    3994                 : { 0x00, 0x68, 0x48 },
    3995                 : { 0x00, 0x69, 0x49 },
    3996                 : { 0x00, 0x6a, 0x4a },
    3997                 : { 0x00, 0x6b, 0x4b },
    3998                 : { 0x00, 0x6c, 0x4c },
    3999                 : { 0x00, 0x6d, 0x4d },
    4000                 : { 0x00, 0x6e, 0x4e },
    4001                 : { 0x00, 0x6f, 0x4f },
    4002                 : { 0x00, 0x70, 0x50 },
    4003                 : { 0x00, 0x71, 0x51 },
    4004                 : { 0x00, 0x72, 0x52 },
    4005                 : { 0x00, 0x73, 0x53 },
    4006                 : { 0x00, 0x74, 0x54 },
    4007                 : { 0x00, 0x75, 0x55 },
    4008                 : { 0x00, 0x76, 0x56 },
    4009                 : { 0x00, 0x77, 0x57 },
    4010                 : { 0x00, 0x78, 0x58 },
    4011                 : { 0x00, 0x79, 0x59 },
    4012                 : { 0x00, 0x7a, 0x5a },
    4013                 : { 0x00, 0x7b, 0x7b },
    4014                 : { 0x00, 0x7c, 0x7c },
    4015                 : { 0x00, 0x7d, 0x7d },
    4016                 : { 0x00, 0x7e, 0x7e },
    4017                 : { 0x00, 0x7f, 0x7f },
    4018                 : { 0x01, 0x90, 0x80 },
    4019                 : { 0x01, 0x83, 0x81 },
    4020                 : { 0x00, 0x82, 0x82 },
    4021                 : { 0x00, 0x83, 0x81 },
    4022                 : { 0x00, 0x84, 0x84 },
    4023                 : { 0x00, 0x85, 0x85 },
    4024                 : { 0x00, 0x86, 0x86 },
    4025                 : { 0x00, 0x87, 0x87 },
    4026                 : { 0x00, 0x88, 0x88 },
    4027                 : { 0x00, 0x89, 0x89 },
    4028                 : { 0x01, 0x9a, 0x8a },
    4029                 : { 0x00, 0x8b, 0x8b },
    4030                 : { 0x01, 0x9c, 0x8c },
    4031                 : { 0x01, 0x9d, 0x8d },
    4032                 : { 0x01, 0x9e, 0x8e },
    4033                 : { 0x01, 0x9f, 0x8f },
    4034                 : { 0x00, 0x90, 0x80 },
    4035                 : { 0x00, 0x91, 0x91 },
    4036                 : { 0x00, 0x92, 0x92 },
    4037                 : { 0x00, 0x93, 0x93 },
    4038                 : { 0x00, 0x94, 0x94 },
    4039                 : { 0x00, 0x95, 0x95 },
    4040                 : { 0x00, 0x96, 0x96 },
    4041                 : { 0x00, 0x97, 0x97 },
    4042                 : { 0x00, 0x98, 0x98 },
    4043                 : { 0x00, 0x99, 0x99 },
    4044                 : { 0x00, 0x9a, 0x8a },
    4045                 : { 0x00, 0x9b, 0x9b },
    4046                 : { 0x00, 0x9c, 0x8c },
    4047                 : { 0x00, 0x9d, 0x8d },
    4048                 : { 0x00, 0x9e, 0x8e },
    4049                 : { 0x00, 0x9f, 0x8f },
    4050                 : { 0x00, 0xa0, 0xa0 },
    4051                 : { 0x01, 0xa2, 0xa1 },
    4052                 : { 0x00, 0xa2, 0xa1 },
    4053                 : { 0x01, 0xbc, 0xa3 },
    4054                 : { 0x00, 0xa4, 0xa4 },
    4055                 : { 0x01, 0xb4, 0xa5 },
    4056                 : { 0x00, 0xa6, 0xa6 },
    4057                 : { 0x00, 0xa7, 0xa7 },
    4058                 : { 0x01, 0xb8, 0xa8 },
    4059                 : { 0x00, 0xa9, 0xa9 },
    4060                 : { 0x01, 0xba, 0xaa },
    4061                 : { 0x00, 0xab, 0xab },
    4062                 : { 0x00, 0xac, 0xac },
    4063                 : { 0x00, 0xad, 0xad },
    4064                 : { 0x00, 0xae, 0xae },
    4065                 : { 0x01, 0xbf, 0xaf },
    4066                 : { 0x00, 0xb0, 0xb0 },
    4067                 : { 0x00, 0xb1, 0xb1 },
    4068                 : { 0x01, 0xb3, 0xb2 },
    4069                 : { 0x00, 0xb3, 0xb2 },
    4070                 : { 0x00, 0xb4, 0xa5 },
    4071                 : { 0x00, 0xb5, 0xb5 },
    4072                 : { 0x00, 0xb6, 0xb6 },
    4073                 : { 0x00, 0xb7, 0xb7 },
    4074                 : { 0x00, 0xb8, 0xa8 },
    4075                 : { 0x00, 0xb9, 0xb9 },
    4076                 : { 0x00, 0xba, 0xaa },
    4077                 : { 0x00, 0xbb, 0xbb },
    4078                 : { 0x00, 0xbc, 0xa3 },
    4079                 : { 0x01, 0xbe, 0xbd },
    4080                 : { 0x00, 0xbe, 0xbd },
    4081                 : { 0x00, 0xbf, 0xaf },
    4082                 : { 0x01, 0xe0, 0xc0 },
    4083                 : { 0x01, 0xe1, 0xc1 },
    4084                 : { 0x01, 0xe2, 0xc2 },
    4085                 : { 0x01, 0xe3, 0xc3 },
    4086                 : { 0x01, 0xe4, 0xc4 },
    4087                 : { 0x01, 0xe5, 0xc5 },
    4088                 : { 0x01, 0xe6, 0xc6 },
    4089                 : { 0x01, 0xe7, 0xc7 },
    4090                 : { 0x01, 0xe8, 0xc8 },
    4091                 : { 0x01, 0xe9, 0xc9 },
    4092                 : { 0x01, 0xea, 0xca },
    4093                 : { 0x01, 0xeb, 0xcb },
    4094                 : { 0x01, 0xec, 0xcc },
    4095                 : { 0x01, 0xed, 0xcd },
    4096                 : { 0x01, 0xee, 0xce },
    4097                 : { 0x01, 0xef, 0xcf },
    4098                 : { 0x01, 0xf0, 0xd0 },
    4099                 : { 0x01, 0xf1, 0xd1 },
    4100                 : { 0x01, 0xf2, 0xd2 },
    4101                 : { 0x01, 0xf3, 0xd3 },
    4102                 : { 0x01, 0xf4, 0xd4 },
    4103                 : { 0x01, 0xf5, 0xd5 },
    4104                 : { 0x01, 0xf6, 0xd6 },
    4105                 : { 0x01, 0xf7, 0xd7 },
    4106                 : { 0x01, 0xf8, 0xd8 },
    4107                 : { 0x01, 0xf9, 0xd9 },
    4108                 : { 0x01, 0xfa, 0xda },
    4109                 : { 0x01, 0xfb, 0xdb },
    4110                 : { 0x01, 0xfc, 0xdc },
    4111                 : { 0x01, 0xfd, 0xdd },
    4112                 : { 0x01, 0xfe, 0xde },
    4113                 : { 0x01, 0xff, 0xdf },
    4114                 : { 0x00, 0xe0, 0xc0 },
    4115                 : { 0x00, 0xe1, 0xc1 },
    4116                 : { 0x00, 0xe2, 0xc2 },
    4117                 : { 0x00, 0xe3, 0xc3 },
    4118                 : { 0x00, 0xe4, 0xc4 },
    4119                 : { 0x00, 0xe5, 0xc5 },
    4120                 : { 0x00, 0xe6, 0xc6 },
    4121                 : { 0x00, 0xe7, 0xc7 },
    4122                 : { 0x00, 0xe8, 0xc8 },
    4123                 : { 0x00, 0xe9, 0xc9 },
    4124                 : { 0x00, 0xea, 0xca },
    4125                 : { 0x00, 0xeb, 0xcb },
    4126                 : { 0x00, 0xec, 0xcc },
    4127                 : { 0x00, 0xed, 0xcd },
    4128                 : { 0x00, 0xee, 0xce },
    4129                 : { 0x00, 0xef, 0xcf },
    4130                 : { 0x00, 0xf0, 0xd0 },
    4131                 : { 0x00, 0xf1, 0xd1 },
    4132                 : { 0x00, 0xf2, 0xd2 },
    4133                 : { 0x00, 0xf3, 0xd3 },
    4134                 : { 0x00, 0xf4, 0xd4 },
    4135                 : { 0x00, 0xf5, 0xd5 },
    4136                 : { 0x00, 0xf6, 0xd6 },
    4137                 : { 0x00, 0xf7, 0xd7 },
    4138                 : { 0x00, 0xf8, 0xd8 },
    4139                 : { 0x00, 0xf9, 0xd9 },
    4140                 : { 0x00, 0xfa, 0xda },
    4141                 : { 0x00, 0xfb, 0xdb },
    4142                 : { 0x00, 0xfc, 0xdc },
    4143                 : { 0x00, 0xfd, 0xdd },
    4144                 : { 0x00, 0xfe, 0xde },
    4145                 : { 0x00, 0xff, 0xdf }
    4146                 : };
    4147                 : 
    4148                 : static struct cs_info iso13_tbl[] = {
    4149                 : { 0x00, 0x00, 0x00 },
    4150                 : { 0x00, 0x01, 0x01 },
    4151                 : { 0x00, 0x02, 0x02 },
    4152                 : { 0x00, 0x03, 0x03 },
    4153                 : { 0x00, 0x04, 0x04 },
    4154                 : { 0x00, 0x05, 0x05 },
    4155                 : { 0x00, 0x06, 0x06 },
    4156                 : { 0x00, 0x07, 0x07 },
    4157                 : { 0x00, 0x08, 0x08 },
    4158                 : { 0x00, 0x09, 0x09 },
    4159                 : { 0x00, 0x0A, 0x0A },
    4160                 : { 0x00, 0x0B, 0x0B },
    4161                 : { 0x00, 0x0C, 0x0C },
    4162                 : { 0x00, 0x0D, 0x0D },
    4163                 : { 0x00, 0x0E, 0x0E },
    4164                 : { 0x00, 0x0F, 0x0F },
    4165                 : { 0x00, 0x10, 0x10 },
    4166                 : { 0x00, 0x11, 0x11 },
    4167                 : { 0x00, 0x12, 0x12 },
    4168                 : { 0x00, 0x13, 0x13 },
    4169                 : { 0x00, 0x14, 0x14 },
    4170                 : { 0x00, 0x15, 0x15 },
    4171                 : { 0x00, 0x16, 0x16 },
    4172                 : { 0x00, 0x17, 0x17 },
    4173                 : { 0x00, 0x18, 0x18 },
    4174                 : { 0x00, 0x19, 0x19 },
    4175                 : { 0x00, 0x1A, 0x1A },
    4176                 : { 0x00, 0x1B, 0x1B },
    4177                 : { 0x00, 0x1C, 0x1C },
    4178                 : { 0x00, 0x1D, 0x1D },
    4179                 : { 0x00, 0x1E, 0x1E },
    4180                 : { 0x00, 0x1F, 0x1F },
    4181                 : { 0x00, 0x20, 0x20 },
    4182                 : { 0x00, 0x21, 0x21 },
    4183                 : { 0x00, 0x22, 0x22 },
    4184                 : { 0x00, 0x23, 0x23 },
    4185                 : { 0x00, 0x24, 0x24 },
    4186                 : { 0x00, 0x25, 0x25 },
    4187                 : { 0x00, 0x26, 0x26 },
    4188                 : { 0x00, 0x27, 0x27 },
    4189                 : { 0x00, 0x28, 0x28 },
    4190                 : { 0x00, 0x29, 0x29 },
    4191                 : { 0x00, 0x2A, 0x2A },
    4192                 : { 0x00, 0x2B, 0x2B },
    4193                 : { 0x00, 0x2C, 0x2C },
    4194                 : { 0x00, 0x2D, 0x2D },
    4195                 : { 0x00, 0x2E, 0x2E },
    4196                 : { 0x00, 0x2F, 0x2F },
    4197                 : { 0x00, 0x30, 0x30 },
    4198                 : { 0x00, 0x31, 0x31 },
    4199                 : { 0x00, 0x32, 0x32 },
    4200                 : { 0x00, 0x33, 0x33 },
    4201                 : { 0x00, 0x34, 0x34 },
    4202                 : { 0x00, 0x35, 0x35 },
    4203                 : { 0x00, 0x36, 0x36 },
    4204                 : { 0x00, 0x37, 0x37 },
    4205                 : { 0x00, 0x38, 0x38 },
    4206                 : { 0x00, 0x39, 0x39 },
    4207                 : { 0x00, 0x3A, 0x3A },
    4208                 : { 0x00, 0x3B, 0x3B },
    4209                 : { 0x00, 0x3C, 0x3C },
    4210                 : { 0x00, 0x3D, 0x3D },
    4211                 : { 0x00, 0x3E, 0x3E },
    4212                 : { 0x00, 0x3F, 0x3F },
    4213                 : { 0x00, 0x40, 0x40 },
    4214                 : { 0x01, 0x61, 0x41 },
    4215                 : { 0x01, 0x62, 0x42 },
    4216                 : { 0x01, 0x63, 0x43 },
    4217                 : { 0x01, 0x64, 0x44 },
    4218                 : { 0x01, 0x65, 0x45 },
    4219                 : { 0x01, 0x66, 0x46 },
    4220                 : { 0x01, 0x67, 0x47 },
    4221                 : { 0x01, 0x68, 0x48 },
    4222                 : { 0x01, 0x69, 0x49 },
    4223                 : { 0x01, 0x6A, 0x4A },
    4224                 : { 0x01, 0x6B, 0x4B },
    4225                 : { 0x01, 0x6C, 0x4C },
    4226                 : { 0x01, 0x6D, 0x4D },
    4227                 : { 0x01, 0x6E, 0x4E },
    4228                 : { 0x01, 0x6F, 0x4F },
    4229                 : { 0x01, 0x70, 0x50 },
    4230                 : { 0x01, 0x71, 0x51 },
    4231                 : { 0x01, 0x72, 0x52 },
    4232                 : { 0x01, 0x73, 0x53 },
    4233                 : { 0x01, 0x74, 0x54 },
    4234                 : { 0x01, 0x75, 0x55 },
    4235                 : { 0x01, 0x76, 0x56 },
    4236                 : { 0x01, 0x77, 0x57 },
    4237                 : { 0x01, 0x78, 0x58 },
    4238                 : { 0x01, 0x79, 0x59 },
    4239                 : { 0x01, 0x7A, 0x5A },
    4240                 : { 0x00, 0x5B, 0x5B },
    4241                 : { 0x00, 0x5C, 0x5C },
    4242                 : { 0x00, 0x5D, 0x5D },
    4243                 : { 0x00, 0x5E, 0x5E },
    4244                 : { 0x00, 0x5F, 0x5F },
    4245                 : { 0x00, 0x60, 0x60 },
    4246                 : { 0x00, 0x61, 0x41 },
    4247                 : { 0x00, 0x62, 0x42 },
    4248                 : { 0x00, 0x63, 0x43 },
    4249                 : { 0x00, 0x64, 0x44 },
    4250                 : { 0x00, 0x65, 0x45 },
    4251                 : { 0x00, 0x66, 0x46 },
    4252                 : { 0x00, 0x67, 0x47 },
    4253                 : { 0x00, 0x68, 0x48 },
    4254                 : { 0x00, 0x69, 0x49 },
    4255                 : { 0x00, 0x6A, 0x4A },
    4256                 : { 0x00, 0x6B, 0x4B },
    4257                 : { 0x00, 0x6C, 0x4C },
    4258                 : { 0x00, 0x6D, 0x4D },
    4259                 : { 0x00, 0x6E, 0x4E },
    4260                 : { 0x00, 0x6F, 0x4F },
    4261                 : { 0x00, 0x70, 0x50 },
    4262                 : { 0x00, 0x71, 0x51 },
    4263                 : { 0x00, 0x72, 0x52 },
    4264                 : { 0x00, 0x73, 0x53 },
    4265                 : { 0x00, 0x74, 0x54 },
    4266                 : { 0x00, 0x75, 0x55 },
    4267                 : { 0x00, 0x76, 0x56 },
    4268                 : { 0x00, 0x77, 0x57 },
    4269                 : { 0x00, 0x78, 0x58 },
    4270                 : { 0x00, 0x79, 0x59 },
    4271                 : { 0x00, 0x7A, 0x5A },
    4272                 : { 0x00, 0x7B, 0x7B },
    4273                 : { 0x00, 0x7C, 0x7C },
    4274                 : { 0x00, 0x7D, 0x7D },
    4275                 : { 0x00, 0x7E, 0x7E },
    4276                 : { 0x00, 0x7F, 0x7F },
    4277                 : { 0x00, 0x80, 0x80 },
    4278                 : { 0x00, 0x81, 0x81 },
    4279                 : { 0x00, 0x82, 0x82 },
    4280                 : { 0x00, 0x83, 0x83 },
    4281                 : { 0x00, 0x84, 0x84 },
    4282                 : { 0x00, 0x85, 0x85 },
    4283                 : { 0x00, 0x86, 0x86 },
    4284                 : { 0x00, 0x87, 0x87 },
    4285                 : { 0x00, 0x88, 0x88 },
    4286                 : { 0x00, 0x89, 0x89 },
    4287                 : { 0x00, 0x8A, 0x8A },
    4288                 : { 0x00, 0x8B, 0x8B },
    4289                 : { 0x00, 0x8C, 0x8C },
    4290                 : { 0x00, 0x8D, 0x8D },
    4291                 : { 0x00, 0x8E, 0x8E },
    4292                 : { 0x00, 0x8F, 0x8F },
    4293                 : { 0x00, 0x90, 0x90 },
    4294                 : { 0x00, 0x91, 0x91 },
    4295                 : { 0x00, 0x92, 0x92 },
    4296                 : { 0x00, 0x93, 0x93 },
    4297                 : { 0x00, 0x94, 0x94 },
    4298                 : { 0x00, 0x95, 0x95 },
    4299                 : { 0x00, 0x96, 0x96 },
    4300                 : { 0x00, 0x97, 0x97 },
    4301                 : { 0x00, 0x98, 0x98 },
    4302                 : { 0x00, 0x99, 0x99 },
    4303                 : { 0x00, 0x9A, 0x9A },
    4304                 : { 0x00, 0x9B, 0x9B },
    4305                 : { 0x00, 0x9C, 0x9C },
    4306                 : { 0x00, 0x9D, 0x9D },
    4307                 : { 0x00, 0x9E, 0x9E },
    4308                 : { 0x00, 0x9F, 0x9F },
    4309                 : { 0x00, 0xA0, 0xA0 },
    4310                 : { 0x00, 0xA1, 0xA1 },
    4311                 : { 0x00, 0xA2, 0xA2 },
    4312                 : { 0x00, 0xA3, 0xA3 },
    4313                 : { 0x00, 0xA4, 0xA4 },
    4314                 : { 0x00, 0xA5, 0xA5 },
    4315                 : { 0x00, 0xA6, 0xA6 },
    4316                 : { 0x00, 0xA7, 0xA7 },
    4317                 : { 0x01, 0xB8, 0xA8 },
    4318                 : { 0x00, 0xA9, 0xA9 },
    4319                 : { 0x01, 0xBA, 0xAA },
    4320                 : { 0x00, 0xAB, 0xAB },
    4321                 : { 0x00, 0xAC, 0xAC },
    4322                 : { 0x00, 0xAD, 0xAD },
    4323                 : { 0x00, 0xAE, 0xAE },
    4324                 : { 0x01, 0xBF, 0xAF },
    4325                 : { 0x00, 0xB0, 0xB0 },
    4326                 : { 0x00, 0xB1, 0xB1 },
    4327                 : { 0x00, 0xB2, 0xB2 },
    4328                 : { 0x00, 0xB3, 0xB3 },
    4329                 : { 0x00, 0xB4, 0xB4 },
    4330                 : { 0x00, 0xB5, 0xB5 },
    4331                 : { 0x00, 0xB6, 0xB6 },
    4332                 : { 0x00, 0xB7, 0xB7 },
    4333                 : { 0x00, 0xB8, 0xA8 },
    4334                 : { 0x00, 0xB9, 0xB9 },
    4335                 : { 0x00, 0xBA, 0xAA },
    4336                 : { 0x00, 0xBB, 0xBB },
    4337                 : { 0x00, 0xBC, 0xBC },
    4338                 : { 0x00, 0xBD, 0xBD },
    4339                 : { 0x00, 0xBE, 0xBE },
    4340                 : { 0x00, 0xBF, 0xAF },
    4341                 : { 0x01, 0xE0, 0xC0 },
    4342                 : { 0x01, 0xE1, 0xC1 },
    4343                 : { 0x01, 0xE2, 0xC2 },
    4344                 : { 0x01, 0xE3, 0xC3 },
    4345                 : { 0x01, 0xE4, 0xC4 },
    4346                 : { 0x01, 0xE5, 0xC5 },
    4347                 : { 0x01, 0xE6, 0xC6 },
    4348                 : { 0x01, 0xE7, 0xC7 },
    4349                 : { 0x01, 0xE8, 0xC8 },
    4350                 : { 0x01, 0xE9, 0xC9 },
    4351                 : { 0x01, 0xEA, 0xCA },
    4352                 : { 0x01, 0xEB, 0xCB },
    4353                 : { 0x01, 0xEC, 0xCC },
    4354                 : { 0x01, 0xED, 0xCD },
    4355                 : { 0x01, 0xEE, 0xCE },
    4356                 : { 0x01, 0xEF, 0xCF },
    4357                 : { 0x01, 0xF0, 0xD0 },
    4358                 : { 0x01, 0xF1, 0xD1 },
    4359                 : { 0x01, 0xF2, 0xD2 },
    4360                 : { 0x01, 0xF3, 0xD3 },
    4361                 : { 0x01, 0xF4, 0xD4 },
    4362                 : { 0x01, 0xF5, 0xD5 },
    4363                 : { 0x01, 0xF6, 0xD6 },
    4364                 : { 0x00, 0xD7, 0xD7 },
    4365                 : { 0x01, 0xF8, 0xD8 },
    4366                 : { 0x01, 0xF9, 0xD9 },
    4367                 : { 0x01, 0xFA, 0xDA },
    4368                 : { 0x01, 0xFB, 0xDB },
    4369                 : { 0x01, 0xFC, 0xDC },
    4370                 : { 0x01, 0xFD, 0xDD },
    4371                 : { 0x01, 0xFE, 0xDE },
    4372                 : { 0x00, 0xDF, 0xDF },
    4373                 : { 0x00, 0xE0, 0xC0 },
    4374                 : { 0x00, 0xE1, 0xC1 },
    4375                 : { 0x00, 0xE2, 0xC2 },
    4376                 : { 0x00, 0xE3, 0xC3 },
    4377                 : { 0x00, 0xE4, 0xC4 },
    4378                 : { 0x00, 0xE5, 0xC5 },
    4379                 : { 0x00, 0xE6, 0xC6 },
    4380                 : { 0x00, 0xE7, 0xC7 },
    4381                 : { 0x00, 0xE8, 0xC8 },
    4382                 : { 0x00, 0xE9, 0xC9 },
    4383                 : { 0x00, 0xEA, 0xCA },
    4384                 : { 0x00, 0xEB, 0xCB },
    4385                 : { 0x00, 0xEC, 0xCC },
    4386                 : { 0x00, 0xED, 0xCD },
    4387                 : { 0x00, 0xEE, 0xCE },
    4388                 : { 0x00, 0xEF, 0xCF },
    4389                 : { 0x00, 0xF0, 0xD0 },
    4390                 : { 0x00, 0xF1, 0xD1 },
    4391                 : { 0x00, 0xF2, 0xD2 },
    4392                 : { 0x00, 0xF3, 0xD3 },
    4393                 : { 0x00, 0xF4, 0xD4 },
    4394                 : { 0x00, 0xF5, 0xD5 },
    4395                 : { 0x00, 0xF6, 0xD6 },
    4396                 : { 0x00, 0xF7, 0xF7 },
    4397                 : { 0x00, 0xF8, 0xD8 },
    4398                 : { 0x00, 0xF9, 0xD9 },
    4399                 : { 0x00, 0xFA, 0xDA },
    4400                 : { 0x00, 0xFB, 0xDB },
    4401                 : { 0x00, 0xFC, 0xDC },
    4402                 : { 0x00, 0xFD, 0xDD },
    4403                 : { 0x00, 0xFE, 0xDE },
    4404                 : { 0x00, 0xFF, 0xFF }
    4405                 : };
    4406                 : 
    4407                 : 
    4408                 : static struct cs_info iso14_tbl[] = {
    4409                 : { 0x00, 0x00, 0x00 },
    4410                 : { 0x00, 0x01, 0x01 },
    4411                 : { 0x00, 0x02, 0x02 },
    4412                 : { 0x00, 0x03, 0x03 },
    4413                 : { 0x00, 0x04, 0x04 },
    4414                 : { 0x00, 0x05, 0x05 },
    4415                 : { 0x00, 0x06, 0x06 },
    4416                 : { 0x00, 0x07, 0x07 },
    4417                 : { 0x00, 0x08, 0x08 },
    4418                 : { 0x00, 0x09, 0x09 },
    4419                 : { 0x00, 0x0a, 0x0a },
    4420                 : { 0x00, 0x0b, 0x0b },
    4421                 : { 0x00, 0x0c, 0x0c },
    4422                 : { 0x00, 0x0d, 0x0d },
    4423                 : { 0x00, 0x0e, 0x0e },
    4424                 : { 0x00, 0x0f, 0x0f },
    4425                 : { 0x00, 0x10, 0x10 },
    4426                 : { 0x00, 0x11, 0x11 },
    4427                 : { 0x00, 0x12, 0x12 },
    4428                 : { 0x00, 0x13, 0x13 },
    4429                 : { 0x00, 0x14, 0x14 },
    4430                 : { 0x00, 0x15, 0x15 },
    4431                 : { 0x00, 0x16, 0x16 },
    4432                 : { 0x00, 0x17, 0x17 },
    4433                 : { 0x00, 0x18, 0x18 },
    4434                 : { 0x00, 0x19, 0x19 },
    4435                 : { 0x00, 0x1a, 0x1a },
    4436                 : { 0x00, 0x1b, 0x1b },
    4437                 : { 0x00, 0x1c, 0x1c },
    4438                 : { 0x00, 0x1d, 0x1d },
    4439                 : { 0x00, 0x1e, 0x1e },
    4440                 : { 0x00, 0x1f, 0x1f },
    4441                 : { 0x00, 0x20, 0x20 },
    4442                 : { 0x00, 0x21, 0x21 },
    4443                 : { 0x00, 0x22, 0x22 },
    4444                 : { 0x00, 0x23, 0x23 },
    4445                 : { 0x00, 0x24, 0x24 },
    4446                 : { 0x00, 0x25, 0x25 },
    4447                 : { 0x00, 0x26, 0x26 },
    4448                 : { 0x00, 0x27, 0x27 },
    4449                 : { 0x00, 0x28, 0x28 },
    4450                 : { 0x00, 0x29, 0x29 },
    4451                 : { 0x00, 0x2a, 0x2a },
    4452                 : { 0x00, 0x2b, 0x2b },
    4453                 : { 0x00, 0x2c, 0x2c },
    4454                 : { 0x00, 0x2d, 0x2d },
    4455                 : { 0x00, 0x2e, 0x2e },
    4456                 : { 0x00, 0x2f, 0x2f },
    4457                 : { 0x00, 0x30, 0x30 },
    4458                 : { 0x00, 0x31, 0x31 },
    4459                 : { 0x00, 0x32, 0x32 },
    4460                 : { 0x00, 0x33, 0x33 },
    4461                 : { 0x00, 0x34, 0x34 },
    4462                 : { 0x00, 0x35, 0x35 },
    4463                 : { 0x00, 0x36, 0x36 },
    4464                 : { 0x00, 0x37, 0x37 },
    4465                 : { 0x00, 0x38, 0x38 },
    4466                 : { 0x00, 0x39, 0x39 },
    4467                 : { 0x00, 0x3a, 0x3a },
    4468                 : { 0x00, 0x3b, 0x3b },
    4469                 : { 0x00, 0x3c, 0x3c },
    4470                 : { 0x00, 0x3d, 0x3d },
    4471                 : { 0x00, 0x3e, 0x3e },
    4472                 : { 0x00, 0x3f, 0x3f },
    4473                 : { 0x00, 0x40, 0x40 },
    4474                 : { 0x01, 0x61, 0x41 },
    4475                 : { 0x01, 0x62, 0x42 },
    4476                 : { 0x01, 0x63, 0x43 },
    4477                 : { 0x01, 0x64, 0x44 },
    4478                 : { 0x01, 0x65, 0x45 },
    4479                 : { 0x01, 0x66, 0x46 },
    4480                 : { 0x01, 0x67, 0x47 },
    4481                 : { 0x01, 0x68, 0x48 },
    4482                 : { 0x01, 0x69, 0x49 },
    4483                 : { 0x01, 0x6a, 0x4a },
    4484                 : { 0x01, 0x6b, 0x4b },
    4485                 : { 0x01, 0x6c, 0x4c },
    4486                 : { 0x01, 0x6d, 0x4d },
    4487                 : { 0x01, 0x6e, 0x4e },
    4488                 : { 0x01, 0x6f, 0x4f },
    4489                 : { 0x01, 0x70, 0x50 },
    4490                 : { 0x01, 0x71, 0x51 },
    4491                 : { 0x01, 0x72, 0x52 },
    4492                 : { 0x01, 0x73, 0x53 },
    4493                 : { 0x01, 0x74, 0x54 },
    4494                 : { 0x01, 0x75, 0x55 },
    4495                 : { 0x01, 0x76, 0x56 },
    4496                 : { 0x01, 0x77, 0x57 },
    4497                 : { 0x01, 0x78, 0x58 },
    4498                 : { 0x01, 0x79, 0x59 },
    4499                 : { 0x01, 0x7a, 0x5a },
    4500                 : { 0x00, 0x5b, 0x5b },
    4501                 : { 0x00, 0x5c, 0x5c },
    4502                 : { 0x00, 0x5d, 0x5d },
    4503                 : { 0x00, 0x5e, 0x5e },
    4504                 : { 0x00, 0x5f, 0x5f },
    4505                 : { 0x00, 0x60, 0x60 },
    4506                 : { 0x00, 0x61, 0x41 },
    4507                 : { 0x00, 0x62, 0x42 },
    4508                 : { 0x00, 0x63, 0x43 },
    4509                 : { 0x00, 0x64, 0x44 },
    4510                 : { 0x00, 0x65, 0x45 },
    4511                 : { 0x00, 0x66, 0x46 },
    4512                 : { 0x00, 0x67, 0x47 },
    4513                 : { 0x00, 0x68, 0x48 },
    4514                 : { 0x00, 0x69, 0x49 },
    4515                 : { 0x00, 0x6a, 0x4a },
    4516                 : { 0x00, 0x6b, 0x4b },
    4517                 : { 0x00, 0x6c, 0x4c },
    4518                 : { 0x00, 0x6d, 0x4d },
    4519                 : { 0x00, 0x6e, 0x4e },
    4520                 : { 0x00, 0x6f, 0x4f },
    4521                 : { 0x00, 0x70, 0x50 },
    4522                 : { 0x00, 0x71, 0x51 },
    4523                 : { 0x00, 0x72, 0x52 },
    4524                 : { 0x00, 0x73, 0x53 },
    4525                 : { 0x00, 0x74, 0x54 },
    4526                 : { 0x00, 0x75, 0x55 },
    4527                 : { 0x00, 0x76, 0x56 },
    4528                 : { 0x00, 0x77, 0x57 },
    4529                 : { 0x00, 0x78, 0x58 },
    4530                 : { 0x00, 0x79, 0x59 },
    4531                 : { 0x00, 0x7a, 0x5a },
    4532                 : { 0x00, 0x7b, 0x7b },
    4533                 : { 0x00, 0x7c, 0x7c },
    4534                 : { 0x00, 0x7d, 0x7d },
    4535                 : { 0x00, 0x7e, 0x7e },
    4536                 : { 0x00, 0x7f, 0x7f },
    4537                 : { 0x00, 0x80, 0x80 },
    4538                 : { 0x00, 0x81, 0x81 },
    4539                 : { 0x00, 0x82, 0x82 },
    4540                 : { 0x00, 0x83, 0x83 },
    4541                 : { 0x00, 0x84, 0x84 },
    4542                 : { 0x00, 0x85, 0x85 },
    4543                 : { 0x00, 0x86, 0x86 },
    4544                 : { 0x00, 0x87, 0x87 },
    4545                 : { 0x00, 0x88, 0x88 },
    4546                 : { 0x00, 0x89, 0x89 },
    4547                 : { 0x00, 0x8a, 0x8a },
    4548                 : { 0x00, 0x8b, 0x8b },
    4549                 : { 0x00, 0x8c, 0x8c },
    4550                 : { 0x00, 0x8d, 0x8d },
    4551                 : { 0x00, 0x8e, 0x8e },
    4552                 : { 0x00, 0x8f, 0x8f },
    4553                 : { 0x00, 0x90, 0x90 },
    4554                 : { 0x00, 0x91, 0x91 },
    4555                 : { 0x00, 0x92, 0x92 },
    4556                 : { 0x00, 0x93, 0x93 },
    4557                 : { 0x00, 0x94, 0x94 },
    4558                 : { 0x00, 0x95, 0x95 },
    4559                 : { 0x00, 0x96, 0x96 },
    4560                 : { 0x00, 0x97, 0x97 },
    4561                 : { 0x00, 0x98, 0x98 },
    4562                 : { 0x00, 0x99, 0x99 },
    4563                 : { 0x00, 0x9a, 0x9a },
    4564                 : { 0x00, 0x9b, 0x9b },
    4565                 : { 0x00, 0x9c, 0x9c },
    4566                 : { 0x00, 0x9d, 0x9d },
    4567                 : { 0x00, 0x9e, 0x9e },
    4568                 : { 0x00, 0x9f, 0x9f },
    4569                 : { 0x00, 0xa0, 0xa0 },
    4570                 : { 0x01, 0xa2, 0xa1 },
    4571                 : { 0x00, 0xa2, 0xa1 },
    4572                 : { 0x00, 0xa3, 0xa3 },
    4573                 : { 0x01, 0xa5, 0xa4 },
    4574                 : { 0x00, 0xa5, 0xa4 },
    4575                 : { 0x01, 0xa6, 0xab },
    4576                 : { 0x00, 0xa7, 0xa7 },
    4577                 : { 0x01, 0xb8, 0xa8 },
    4578                 : { 0x00, 0xa9, 0xa9 },
    4579                 : { 0x01, 0xba, 0xaa },
    4580                 : { 0x00, 0xab, 0xa6 },
    4581                 : { 0x01, 0xbc, 0xac },
    4582                 : { 0x00, 0xad, 0xad },
    4583                 : { 0x00, 0xae, 0xae },
    4584                 : { 0x01, 0xff, 0xaf },
    4585                 : { 0x01, 0xb1, 0xb0 },
    4586                 : { 0x00, 0xb1, 0xb0 },
    4587                 : { 0x01, 0xb3, 0xb2 },
    4588                 : { 0x00, 0xb3, 0xb2 },
    4589                 : { 0x01, 0xb5, 0xb4 },
    4590                 : { 0x00, 0xb5, 0xb4 },
    4591                 : { 0x00, 0xb6, 0xb6 },
    4592                 : { 0x01, 0xb9, 0xb7 },
    4593                 : { 0x00, 0xb8, 0xa8 },
    4594                 : { 0x00, 0xb9, 0xb6 },
    4595                 : { 0x00, 0xba, 0xaa },
    4596                 : { 0x01, 0xbf, 0xbb },
    4597                 : { 0x00, 0xbc, 0xac },
    4598                 : { 0x01, 0xbe, 0xbd },
    4599                 : { 0x00, 0xbe, 0xbd },
    4600                 : { 0x00, 0xbf, 0xbb },
    4601                 : { 0x01, 0xe0, 0xc0 },
    4602                 : { 0x01, 0xe1, 0xc1 },
    4603                 : { 0x01, 0xe2, 0xc2 },
    4604                 : { 0x01, 0xe3, 0xc3 },
    4605                 : { 0x01, 0xe4, 0xc4 },
    4606                 : { 0x01, 0xe5, 0xc5 },
    4607                 : { 0x01, 0xe6, 0xc6 },
    4608                 : { 0x01, 0xe7, 0xc7 },
    4609                 : { 0x01, 0xe8, 0xc8 },
    4610                 : { 0x01, 0xe9, 0xc9 },
    4611                 : { 0x01, 0xea, 0xca },
    4612                 : { 0x01, 0xeb, 0xcb },
    4613                 : { 0x01, 0xec, 0xcc },
    4614                 : { 0x01, 0xed, 0xcd },
    4615                 : { 0x01, 0xee, 0xce },
    4616                 : { 0x01, 0xef, 0xcf },
    4617                 : { 0x01, 0xf0, 0xd0 },
    4618                 : { 0x01, 0xf1, 0xd1 },
    4619                 : { 0x01, 0xf2, 0xd2 },
    4620                 : { 0x01, 0xf3, 0xd3 },
    4621                 : { 0x01, 0xf4, 0xd4 },
    4622                 : { 0x01, 0xf5, 0xd5 },
    4623                 : { 0x01, 0xf6, 0xd6 },
    4624                 : { 0x01, 0xf7, 0xd7 },
    4625                 : { 0x01, 0xf8, 0xd8 },
    4626                 : { 0x01, 0xf9, 0xd9 },
    4627                 : { 0x01, 0xfa, 0xda },
    4628                 : { 0x01, 0xfb, 0xdb },
    4629                 : { 0x01, 0xfc, 0xdc },
    4630                 : { 0x01, 0xfd, 0xdd },
    4631                 : { 0x01, 0xfe, 0xde },
    4632                 : { 0x00, 0xdf, 0xdf },
    4633                 : { 0x00, 0xe0, 0xc0 },
    4634                 : { 0x00, 0xe1, 0xc1 },
    4635                 : { 0x00, 0xe2, 0xc2 },
    4636                 : { 0x00, 0xe3, 0xc3 },
    4637                 : { 0x00, 0xe4, 0xc4 },
    4638                 : { 0x00, 0xe5, 0xc5 },
    4639                 : { 0x00, 0xe6, 0xc6 },
    4640                 : { 0x00, 0xe7, 0xc7 },
    4641                 : { 0x00, 0xe8, 0xc8 },
    4642                 : { 0x00, 0xe9, 0xc9 },
    4643                 : { 0x00, 0xea, 0xca },
    4644                 : { 0x00, 0xeb, 0xcb },
    4645                 : { 0x00, 0xec, 0xcc },
    4646                 : { 0x00, 0xed, 0xcd },
    4647                 : { 0x00, 0xee, 0xce },
    4648                 : { 0x00, 0xef, 0xcf },
    4649                 : { 0x00, 0xf0, 0xd0 },
    4650                 : { 0x00, 0xf1, 0xd1 },
    4651                 : { 0x00, 0xf2, 0xd2 },
    4652                 : { 0x00, 0xf3, 0xd3 },
    4653                 : { 0x00, 0xf4, 0xd4 },
    4654                 : { 0x00, 0xf5, 0xd5 },
    4655                 : { 0x00, 0xf6, 0xd6 },
    4656                 : { 0x00, 0xf7, 0xd7 },
    4657                 : { 0x00, 0xf8, 0xd8 },
    4658                 : { 0x00, 0xf9, 0xd9 },
    4659                 : { 0x00, 0xfa, 0xda },
    4660                 : { 0x00, 0xfb, 0xdb },
    4661                 : { 0x00, 0xfc, 0xdc },
    4662                 : { 0x00, 0xfd, 0xdd },
    4663                 : { 0x00, 0xfe, 0xde },
    4664                 : { 0x00, 0xff, 0xff }
    4665                 : };
    4666                 : 
    4667                 : static struct cs_info iso15_tbl[] = {
    4668                 : { 0x00, 0x00, 0x00 },
    4669                 : { 0x00, 0x01, 0x01 },
    4670                 : { 0x00, 0x02, 0x02 },
    4671                 : { 0x00, 0x03, 0x03 },
    4672                 : { 0x00, 0x04, 0x04 },
    4673                 : { 0x00, 0x05, 0x05 },
    4674                 : { 0x00, 0x06, 0x06 },
    4675                 : { 0x00, 0x07, 0x07 },
    4676                 : { 0x00, 0x08, 0x08 },
    4677                 : { 0x00, 0x09, 0x09 },
    4678                 : { 0x00, 0x0a, 0x0a },
    4679                 : { 0x00, 0x0b, 0x0b },
    4680                 : { 0x00, 0x0c, 0x0c },
    4681                 : { 0x00, 0x0d, 0x0d },
    4682                 : { 0x00, 0x0e, 0x0e },
    4683                 : { 0x00, 0x0f, 0x0f },
    4684                 : { 0x00, 0x10, 0x10 },
    4685                 : { 0x00, 0x11, 0x11 },
    4686                 : { 0x00, 0x12, 0x12 },
    4687                 : { 0x00, 0x13, 0x13 },
    4688                 : { 0x00, 0x14, 0x14 },
    4689                 : { 0x00, 0x15, 0x15 },
    4690                 : { 0x00, 0x16, 0x16 },
    4691                 : { 0x00, 0x17, 0x17 },
    4692                 : { 0x00, 0x18, 0x18 },
    4693                 : { 0x00, 0x19, 0x19 },
    4694                 : { 0x00, 0x1a, 0x1a },
    4695                 : { 0x00, 0x1b, 0x1b },
    4696                 : { 0x00, 0x1c, 0x1c },
    4697                 : { 0x00, 0x1d, 0x1d },
    4698                 : { 0x00, 0x1e, 0x1e },
    4699                 : { 0x00, 0x1f, 0x1f },
    4700                 : { 0x00, 0x20, 0x20 },
    4701                 : { 0x00, 0x21, 0x21 },
    4702                 : { 0x00, 0x22, 0x22 },
    4703                 : { 0x00, 0x23, 0x23 },
    4704                 : { 0x00, 0x24, 0x24 },
    4705                 : { 0x00, 0x25, 0x25 },
    4706                 : { 0x00, 0x26, 0x26 },
    4707                 : { 0x00, 0x27, 0x27 },
    4708                 : { 0x00, 0x28, 0x28 },
    4709                 : { 0x00, 0x29, 0x29 },
    4710                 : { 0x00, 0x2a, 0x2a },
    4711                 : { 0x00, 0x2b, 0x2b },
    4712                 : { 0x00, 0x2c, 0x2c },
    4713                 : { 0x00, 0x2d, 0x2d },
    4714                 : { 0x00, 0x2e, 0x2e },
    4715                 : { 0x00, 0x2f, 0x2f },
    4716                 : { 0x00, 0x30, 0x30 },
    4717                 : { 0x00, 0x31, 0x31 },
    4718                 : { 0x00, 0x32, 0x32 },
    4719                 : { 0x00, 0x33, 0x33 },
    4720                 : { 0x00, 0x34, 0x34 },
    4721                 : { 0x00, 0x35, 0x35 },
    4722                 : { 0x00, 0x36, 0x36 },
    4723                 : { 0x00, 0x37, 0x37 },
    4724                 : { 0x00, 0x38, 0x38 },
    4725                 : { 0x00, 0x39, 0x39 },
    4726                 : { 0x00, 0x3a, 0x3a },
    4727                 : { 0x00, 0x3b, 0x3b },
    4728                 : { 0x00, 0x3c, 0x3c },
    4729                 : { 0x00, 0x3d, 0x3d },
    4730                 : { 0x00, 0x3e, 0x3e },
    4731                 : { 0x00, 0x3f, 0x3f },
    4732                 : { 0x00, 0x40, 0x40 },
    4733                 : { 0x01, 0x61, 0x41 },
    4734                 : { 0x01, 0x62, 0x42 },
    4735                 : { 0x01, 0x63, 0x43 },
    4736                 : { 0x01, 0x64, 0x44 },
    4737                 : { 0x01, 0x65, 0x45 },
    4738                 : { 0x01, 0x66, 0x46 },
    4739                 : { 0x01, 0x67, 0x47 },
    4740                 : { 0x01, 0x68, 0x48 },
    4741                 : { 0x01, 0x69, 0x49 },
    4742                 : { 0x01, 0x6a, 0x4a },
    4743                 : { 0x01, 0x6b, 0x4b },
    4744                 : { 0x01, 0x6c, 0x4c },
    4745                 : { 0x01, 0x6d, 0x4d },
    4746                 : { 0x01, 0x6e, 0x4e },
    4747                 : { 0x01, 0x6f, 0x4f },
    4748                 : { 0x01, 0x70, 0x50 },
    4749                 : { 0x01, 0x71, 0x51 },
    4750                 : { 0x01, 0x72, 0x52 },
    4751                 : { 0x01, 0x73, 0x53 },
    4752                 : { 0x01, 0x74, 0x54 },
    4753                 : { 0x01, 0x75, 0x55 },
    4754                 : { 0x01, 0x76, 0x56 },
    4755                 : { 0x01, 0x77, 0x57 },
    4756                 : { 0x01, 0x78, 0x58 },
    4757                 : { 0x01, 0x79, 0x59 },
    4758                 : { 0x01, 0x7a, 0x5a },
    4759                 : { 0x00, 0x5b, 0x5b },
    4760                 : { 0x00, 0x5c, 0x5c },
    4761                 : { 0x00, 0x5d, 0x5d },
    4762                 : { 0x00, 0x5e, 0x5e },
    4763                 : { 0x00, 0x5f, 0x5f },
    4764                 : { 0x00, 0x60, 0x60 },
    4765                 : { 0x00, 0x61, 0x41 },
    4766                 : { 0x00, 0x62, 0x42 },
    4767                 : { 0x00, 0x63, 0x43 },
    4768                 : { 0x00, 0x64, 0x44 },
    4769                 : { 0x00, 0x65, 0x45 },
    4770                 : { 0x00, 0x66, 0x46 },
    4771                 : { 0x00, 0x67, 0x47 },
    4772                 : { 0x00, 0x68, 0x48 },
    4773                 : { 0x00, 0x69, 0x49 },
    4774                 : { 0x00, 0x6a, 0x4a },
    4775                 : { 0x00, 0x6b, 0x4b },
    4776                 : { 0x00, 0x6c, 0x4c },
    4777                 : { 0x00, 0x6d, 0x4d },
    4778                 : { 0x00, 0x6e, 0x4e },
    4779                 : { 0x00, 0x6f, 0x4f },
    4780                 : { 0x00, 0x70, 0x50 },
    4781                 : { 0x00, 0x71, 0x51 },
    4782                 : { 0x00, 0x72, 0x52 },
    4783                 : { 0x00, 0x73, 0x53 },
    4784                 : { 0x00, 0x74, 0x54 },
    4785                 : { 0x00, 0x75, 0x55 },
    4786                 : { 0x00, 0x76, 0x56 },
    4787                 : { 0x00, 0x77, 0x57 },
    4788                 : { 0x00, 0x78, 0x58 },
    4789                 : { 0x00, 0x79, 0x59 },
    4790                 : { 0x00, 0x7a, 0x5a },
    4791                 : { 0x00, 0x7b, 0x7b },
    4792                 : { 0x00, 0x7c, 0x7c },
    4793                 : { 0x00, 0x7d, 0x7d },
    4794                 : { 0x00, 0x7e, 0x7e },
    4795                 : { 0x00, 0x7f, 0x7f },
    4796                 : { 0x00, 0x80, 0x80 },
    4797                 : { 0x00, 0x81, 0x81 },
    4798                 : { 0x00, 0x82, 0x82 },
    4799                 : { 0x00, 0x83, 0x83 },
    4800                 : { 0x00, 0x84, 0x84 },
    4801                 : { 0x00, 0x85, 0x85 },
    4802                 : { 0x00, 0x86, 0x86 },
    4803                 : { 0x00, 0x87, 0x87 },
    4804                 : { 0x00, 0x88, 0x88 },
    4805                 : { 0x00, 0x89, 0x89 },
    4806                 : { 0x00, 0x8a, 0x8a },
    4807                 : { 0x00, 0x8b, 0x8b },
    4808                 : { 0x00, 0x8c, 0x8c },
    4809                 : { 0x00, 0x8d, 0x8d },
    4810                 : { 0x00, 0x8e, 0x8e },
    4811                 : { 0x00, 0x8f, 0x8f },
    4812                 : { 0x00, 0x90, 0x90 },
    4813                 : { 0x00, 0x91, 0x91 },
    4814                 : { 0x00, 0x92, 0x92 },
    4815                 : { 0x00, 0x93, 0x93 },
    4816                 : { 0x00, 0x94, 0x94 },
    4817                 : { 0x00, 0x95, 0x95 },
    4818                 : { 0x00, 0x96, 0x96 },
    4819                 : { 0x00, 0x97, 0x97 },
    4820                 : { 0x00, 0x98, 0x98 },
    4821                 : { 0x00, 0x99, 0x99 },
    4822                 : { 0x00, 0x9a, 0x9a },
    4823                 : { 0x00, 0x9b, 0x9b },
    4824                 : { 0x00, 0x9c, 0x9c },
    4825                 : { 0x00, 0x9d, 0x9d },
    4826                 : { 0x00, 0x9e, 0x9e },
    4827                 : { 0x00, 0x9f, 0x9f },
    4828                 : { 0x00, 0xa0, 0xa0 },
    4829                 : { 0x00, 0xa1, 0xa1 },
    4830                 : { 0x00, 0xa2, 0xa2 },
    4831                 : { 0x00, 0xa3, 0xa3 },
    4832                 : { 0x00, 0xa4, 0xa4 },
    4833                 : { 0x00, 0xa5, 0xa5 },
    4834                 : { 0x01, 0xa8, 0xa6 },
    4835                 : { 0x00, 0xa7, 0xa7 },
    4836                 : { 0x00, 0xa8, 0xa6 },
    4837                 : { 0x00, 0xa9, 0xa9 },
    4838                 : { 0x00, 0xaa, 0xaa },
    4839                 : { 0x00, 0xab, 0xab },
    4840                 : { 0x00, 0xac, 0xac },
    4841                 : { 0x00, 0xad, 0xad },
    4842                 : { 0x00, 0xae, 0xae },
    4843                 : { 0x00, 0xaf, 0xaf },
    4844                 : { 0x00, 0xb0, 0xb0 },
    4845                 : { 0x00, 0xb1, 0xb1 },
    4846                 : { 0x00, 0xb2, 0xb2 },
    4847                 : { 0x00, 0xb3, 0xb3 },
    4848                 : { 0x01, 0xb8, 0xb4 },
    4849                 : { 0x00, 0xb5, 0xb5 },
    4850                 : { 0x00, 0xb6, 0xb6 },
    4851                 : { 0x00, 0xb7, 0xb7 },
    4852                 : { 0x00, 0xb8, 0xb4 },
    4853                 : { 0x00, 0xb9, 0xb9 },
    4854                 : { 0x00, 0xba, 0xba },
    4855                 : { 0x00, 0xbb, 0xbb },
    4856                 : { 0x01, 0xbd, 0xbc },
    4857                 : { 0x00, 0xbd, 0xbc },
    4858                 : { 0x01, 0xff, 0xbe },
    4859                 : { 0x00, 0xbf, 0xbf },
    4860                 : { 0x01, 0xe0, 0xc0 },
    4861                 : { 0x01, 0xe1, 0xc1 },
    4862                 : { 0x01, 0xe2, 0xc2 },
    4863                 : { 0x01, 0xe3, 0xc3 },
    4864                 : { 0x01, 0xe4, 0xc4 },
    4865                 : { 0x01, 0xe5, 0xc5 },
    4866                 : { 0x01, 0xe6, 0xc6 },
    4867                 : { 0x01, 0xe7, 0xc7 },
    4868                 : { 0x01, 0xe8, 0xc8 },
    4869                 : { 0x01, 0xe9, 0xc9 },
    4870                 : { 0x01, 0xea, 0xca },
    4871                 : { 0x01, 0xeb, 0xcb },
    4872                 : { 0x01, 0xec, 0xcc },
    4873                 : { 0x01, 0xed, 0xcd },
    4874                 : { 0x01, 0xee, 0xce },
    4875                 : { 0x01, 0xef, 0xcf },
    4876                 : { 0x01, 0xf0, 0xd0 },
    4877                 : { 0x01, 0xf1, 0xd1 },
    4878                 : { 0x01, 0xf2, 0xd2 },
    4879                 : { 0x01, 0xf3, 0xd3 },
    4880                 : { 0x01, 0xf4, 0xd4 },
    4881                 : { 0x01, 0xf5, 0xd5 },
    4882                 : { 0x01, 0xf6, 0xd6 },
    4883                 : { 0x00, 0xd7, 0xd7 },
    4884                 : { 0x01, 0xf8, 0xd8 },
    4885                 : { 0x01, 0xf9, 0xd9 },
    4886                 : { 0x01, 0xfa, 0xda },
    4887                 : { 0x01, 0xfb, 0xdb },
    4888                 : { 0x01, 0xfc, 0xdc },
    4889                 : { 0x01, 0xfd, 0xdd },
    4890                 : { 0x01, 0xfe, 0xde },
    4891                 : { 0x00, 0xdf, 0xdf },
    4892                 : { 0x00, 0xe0, 0xc0 },
    4893                 : { 0x00, 0xe1, 0xc1 },
    4894                 : { 0x00, 0xe2, 0xc2 },
    4895                 : { 0x00, 0xe3, 0xc3 },
    4896                 : { 0x00, 0xe4, 0xc4 },
    4897                 : { 0x00, 0xe5, 0xc5 },
    4898                 : { 0x00, 0xe6, 0xc6 },
    4899                 : { 0x00, 0xe7, 0xc7 },
    4900                 : { 0x00, 0xe8, 0xc8 },
    4901                 : { 0x00, 0xe9, 0xc9 },
    4902                 : { 0x00, 0xea, 0xca },
    4903                 : { 0x00, 0xeb, 0xcb },
    4904                 : { 0x00, 0xec, 0xcc },
    4905                 : { 0x00, 0xed, 0xcd },
    4906                 : { 0x00, 0xee, 0xce },
    4907                 : { 0x00, 0xef, 0xcf },
    4908                 : { 0x00, 0xf0, 0xd0 },
    4909                 : { 0x00, 0xf1, 0xd1 },
    4910                 : { 0x00, 0xf2, 0xd2 },
    4911                 : { 0x00, 0xf3, 0xd3 },
    4912                 : { 0x00, 0xf4, 0xd4 },
    4913                 : { 0x00, 0xf5, 0xd5 },
    4914                 : { 0x00, 0xf6, 0xd6 },
    4915                 : { 0x00, 0xf7, 0xf7 },
    4916                 : { 0x00, 0xf8, 0xd8 },
    4917                 : { 0x00, 0xf9, 0xd9 },
    4918                 : { 0x00, 0xfa, 0xda },
    4919                 : { 0x00, 0xfb, 0xdb },
    4920                 : { 0x00, 0xfc, 0xdc },
    4921                 : { 0x00, 0xfd, 0xdd },
    4922                 : { 0x00, 0xfe, 0xde },
    4923                 : { 0x00, 0xff, 0xbe }
    4924                 : };
    4925                 : 
    4926                 : static struct cs_info iscii_devanagari_tbl[] = {
    4927                 : { 0x00, 0x00, 0x00 },
    4928                 : { 0x00, 0x01, 0x01 },
    4929                 : { 0x00, 0x02, 0x02 },
    4930                 : { 0x00, 0x03, 0x03 },
    4931                 : { 0x00, 0x04, 0x04 },
    4932                 : { 0x00, 0x05, 0x05 },
    4933                 : { 0x00, 0x06, 0x06 },
    4934                 : { 0x00, 0x07, 0x07 },
    4935                 : { 0x00, 0x08, 0x08 },
    4936                 : { 0x00, 0x09, 0x09 },
    4937                 : { 0x00, 0x0a, 0x0a },
    4938                 : { 0x00, 0x0b, 0x0b },
    4939                 : { 0x00, 0x0c, 0x0c },
    4940                 : { 0x00, 0x0d, 0x0d },
    4941                 : { 0x00, 0x0e, 0x0e },
    4942                 : { 0x00, 0x0f, 0x0f },
    4943                 : { 0x00, 0x10, 0x10 },
    4944                 : { 0x00, 0x11, 0x11 },
    4945                 : { 0x00, 0x12, 0x12 },
    4946                 : { 0x00, 0x13, 0x13 },
    4947                 : { 0x00, 0x14, 0x14 },
    4948                 : { 0x00, 0x15, 0x15 },
    4949                 : { 0x00, 0x16, 0x16 },
    4950                 : { 0x00, 0x17, 0x17 },
    4951                 : { 0x00, 0x18, 0x18 },
    4952                 : { 0x00, 0x19, 0x19 },
    4953                 : { 0x00, 0x1a, 0x1a },
    4954                 : { 0x00, 0x1b, 0x1b },
    4955                 : { 0x00, 0x1c, 0x1c },
    4956                 : { 0x00, 0x1d, 0x1d },
    4957                 : { 0x00, 0x1e, 0x1e },
    4958                 : { 0x00, 0x1f, 0x1f },
    4959                 : { 0x00, 0x20, 0x20 },
    4960                 : { 0x00, 0x21, 0x21 },
    4961                 : { 0x00, 0x22, 0x22 },
    4962                 : { 0x00, 0x23, 0x23 },
    4963                 : { 0x00, 0x24, 0x24 },
    4964                 : { 0x00, 0x25, 0x25 },
    4965                 : { 0x00, 0x26, 0x26 },
    4966                 : { 0x00, 0x27, 0x27 },
    4967                 : { 0x00, 0x28, 0x28 },
    4968                 : { 0x00, 0x29, 0x29 },
    4969                 : { 0x00, 0x2a, 0x2a },
    4970                 : { 0x00, 0x2b, 0x2b },
    4971                 : { 0x00, 0x2c, 0x2c },
    4972                 : { 0x00, 0x2d, 0x2d },
    4973                 : { 0x00, 0x2e, 0x2e },
    4974                 : { 0x00, 0x2f, 0x2f },
    4975                 : { 0x00, 0x30, 0x30 },
    4976                 : { 0x00, 0x31, 0x31 },
    4977                 : { 0x00, 0x32, 0x32 },
    4978                 : { 0x00, 0x33, 0x33 },
    4979                 : { 0x00, 0x34, 0x34 },
    4980                 : { 0x00, 0x35, 0x35 },
    4981                 : { 0x00, 0x36, 0x36 },
    4982                 : { 0x00, 0x37, 0x37 },
    4983                 : { 0x00, 0x38, 0x38 },
    4984                 : { 0x00, 0x39, 0x39 },
    4985                 : { 0x00, 0x3a, 0x3a },
    4986                 : { 0x00, 0x3b, 0x3b },
    4987                 : { 0x00, 0x3c, 0x3c },
    4988                 : { 0x00, 0x3d, 0x3d },
    4989                 : { 0x00, 0x3e, 0x3e },
    4990                 : { 0x00, 0x3f, 0x3f },
    4991                 : { 0x00, 0x40, 0x40 },
    4992                 : { 0x01, 0x61, 0x41 },
    4993                 : { 0x01, 0x62, 0x42 },
    4994                 : { 0x01, 0x63, 0x43 },
    4995                 : { 0x01, 0x64, 0x44 },
    4996                 : { 0x01, 0x65, 0x45 },
    4997                 : { 0x01, 0x66, 0x46 },
    4998                 : { 0x01, 0x67, 0x47 },
    4999                 : { 0x01, 0x68, 0x48 },
    5000                 : { 0x01, 0x69, 0x49 },
    5001                 : { 0x01, 0x6a, 0x4a },
    5002                 : { 0x01, 0x6b, 0x4b },
    5003                 : { 0x01, 0x6c, 0x4c },
    5004                 : { 0x01, 0x6d, 0x4d },
    5005                 : { 0x01, 0x6e, 0x4e },
    5006                 : { 0x01, 0x6f, 0x4f },
    5007                 : { 0x01, 0x70, 0x50 },
    5008                 : { 0x01, 0x71, 0x51 },
    5009                 : { 0x01, 0x72, 0x52 },
    5010                 : { 0x01, 0x73, 0x53 },
    5011                 : { 0x01, 0x74, 0x54 },
    5012                 : { 0x01, 0x75, 0x55 },
    5013                 : { 0x01, 0x76, 0x56 },
    5014                 : { 0x01, 0x77, 0x57 },
    5015                 : { 0x01, 0x78, 0x58 },
    5016                 : { 0x01, 0x79, 0x59 },
    5017                 : { 0x01, 0x7a, 0x5a },
    5018                 : { 0x00, 0x5b, 0x5b },
    5019                 : { 0x00, 0x5c, 0x5c },
    5020                 : { 0x00, 0x5d, 0x5d },
    5021                 : { 0x00, 0x5e, 0x5e },
    5022                 : { 0x00, 0x5f, 0x5f },
    5023                 : { 0x00, 0x60, 0x60 },
    5024                 : { 0x00, 0x61, 0x41 },
    5025                 : { 0x00, 0x62, 0x42 },
    5026                 : { 0x00, 0x63, 0x43 },
    5027                 : { 0x00, 0x64, 0x44 },
    5028                 : { 0x00, 0x65, 0x45 },
    5029                 : { 0x00, 0x66, 0x46 },
    5030                 : { 0x00, 0x67, 0x47 },
    5031                 : { 0x00, 0x68, 0x48 },
    5032                 : { 0x00, 0x69, 0x49 },
    5033                 : { 0x00, 0x6a, 0x4a },
    5034                 : { 0x00, 0x6b, 0x4b },
    5035                 : { 0x00, 0x6c, 0x4c },
    5036                 : { 0x00, 0x6d, 0x4d },
    5037                 : { 0x00, 0x6e, 0x4e },
    5038                 : { 0x00, 0x6f, 0x4f },
    5039                 : { 0x00, 0x70, 0x50 },
    5040                 : { 0x00, 0x71, 0x51 },
    5041                 : { 0x00, 0x72, 0x52 },
    5042                 : { 0x00, 0x73, 0x53 },
    5043                 : { 0x00, 0x74, 0x54 },
    5044                 : { 0x00, 0x75, 0x55 },
    5045                 : { 0x00, 0x76, 0x56 },
    5046                 : { 0x00, 0x77, 0x57 },
    5047                 : { 0x00, 0x78, 0x58 },
    5048                 : { 0x00, 0x79, 0x59 },
    5049                 : { 0x00, 0x7a, 0x5a },
    5050                 : { 0x00, 0x7b, 0x7b },
    5051                 : { 0x00, 0x7c, 0x7c },
    5052                 : { 0x00, 0x7d, 0x7d },
    5053                 : { 0x00, 0x7e, 0x7e },
    5054                 : { 0x00, 0x7f, 0x7f },
    5055                 : { 0x00, 0x80, 0x80 },
    5056                 : { 0x00, 0x81, 0x81 },
    5057                 : { 0x00, 0x82, 0x82 },
    5058                 : { 0x00, 0x83, 0x83 },
    5059                 : { 0x00, 0x84, 0x84 },
    5060                 : { 0x00, 0x85, 0x85 },
    5061                 : { 0x00, 0x86, 0x86 },
    5062                 : { 0x00, 0x87, 0x87 },
    5063                 : { 0x00, 0x88, 0x88 },
    5064                 : { 0x00, 0x89, 0x89 },
    5065                 : { 0x00, 0x8a, 0x8a },
    5066                 : { 0x00, 0x8b, 0x8b },
    5067                 : { 0x00, 0x8c, 0x8c },
    5068                 : { 0x00, 0x8d, 0x8d },
    5069                 : { 0x00, 0x8e, 0x8e },
    5070                 : { 0x00, 0x8f, 0x8f },
    5071                 : { 0x00, 0x90, 0x90 },
    5072                 : { 0x00, 0x91, 0x91 },
    5073                 : { 0x00, 0x92, 0x92 },
    5074                 : { 0x00, 0x93, 0x93 },
    5075                 : { 0x00, 0x94, 0x94 },
    5076                 : { 0x00, 0x95, 0x95 },
    5077                 : { 0x00, 0x96, 0x96 },
    5078                 : { 0x00, 0x97, 0x97 },
    5079                 : { 0x00, 0x98, 0x98 },
    5080                 : { 0x00, 0x99, 0x99 },
    5081                 : { 0x00, 0x9a, 0x9a },
    5082                 : { 0x00, 0x9b, 0x9b },
    5083                 : { 0x00, 0x9c, 0x9c },
    5084                 : { 0x00, 0x9d, 0x9d },
    5085                 : { 0x00, 0x9e, 0x9e },
    5086                 : { 0x00, 0x9f, 0x9f },
    5087                 : { 0x00, 0xa0, 0xa0 },
    5088                 : { 0x00, 0xa1, 0xa1 },
    5089                 : { 0x00, 0xa2, 0xa2 },
    5090                 : { 0x00, 0xa3, 0xa3 },
    5091                 : { 0x00, 0xa4, 0xa4 },
    5092                 : { 0x00, 0xa5, 0xa5 },
    5093                 : { 0x00, 0xa6, 0xa6 },
    5094                 : { 0x00, 0xa7, 0xa7 },
    5095                 : { 0x00, 0xa8, 0xa8 },
    5096                 : { 0x00, 0xa9, 0xa9 },
    5097                 : { 0x00, 0xaa, 0xaa },
    5098                 : { 0x00, 0xab, 0xab },
    5099                 : { 0x00, 0xac, 0xac },
    5100                 : { 0x00, 0xad, 0xad },
    5101                 : { 0x00, 0xae, 0xae },
    5102                 : { 0x00, 0xaf, 0xaf },
    5103                 : { 0x00, 0xb0, 0xb0 },
    5104                 : { 0x00, 0xb1, 0xb1 },
    5105                 : { 0x00, 0xb2, 0xb2 },
    5106                 : { 0x00, 0xb3, 0xb3 },
    5107                 : { 0x00, 0xb4, 0xb4 },
    5108                 : { 0x00, 0xb5, 0xb5 },
    5109                 : { 0x00, 0xb6, 0xb6 },
    5110                 : { 0x00, 0xb7, 0xb7 },
    5111                 : { 0x00, 0xb8, 0xb8 },
    5112                 : { 0x00, 0xb9, 0xb9 },
    5113                 : { 0x00, 0xba, 0xba },
    5114                 : { 0x00, 0xbb, 0xbb },
    5115                 : { 0x00, 0xbc, 0xbc },
    5116                 : { 0x00, 0xbd, 0xbd },
    5117                 : { 0x00, 0xbe, 0xbe },
    5118                 : { 0x00, 0xbf, 0xbf },
    5119                 : { 0x00, 0xc0, 0xc0 },
    5120                 : { 0x00, 0xc1, 0xc1 },
    5121                 : { 0x00, 0xc2, 0xc2 },
    5122                 : { 0x00, 0xc3, 0xc3 },
    5123                 : { 0x00, 0xc4, 0xc4 },
    5124                 : { 0x00, 0xc5, 0xc5 },
    5125                 : { 0x00, 0xc6, 0xc6 },
    5126                 : { 0x00, 0xc7, 0xc7 },
    5127                 : { 0x00, 0xc8, 0xc8 },
    5128                 : { 0x00, 0xc9, 0xc9 },
    5129                 : { 0x00, 0xca, 0xca },
    5130                 : { 0x00, 0xcb, 0xcb },
    5131                 : { 0x00, 0xcc, 0xcc },
    5132                 : { 0x00, 0xcd, 0xcd },
    5133                 : { 0x00, 0xce, 0xce },
    5134                 : { 0x00, 0xcf, 0xcf },
    5135                 : { 0x00, 0xd0, 0xd0 },
    5136                 : { 0x00, 0xd1, 0xd1 },
    5137                 : { 0x00, 0xd2, 0xd2 },
    5138                 : { 0x00, 0xd3, 0xd3 },
    5139                 : { 0x00, 0xd4, 0xd4 },
    5140                 : { 0x00, 0xd5, 0xd5 },
    5141                 : { 0x00, 0xd6, 0xd6 },
    5142                 : { 0x00, 0xd7, 0xd7 },
    5143                 : { 0x00, 0xd8, 0xd8 },
    5144                 : { 0x00, 0xd9, 0xd9 },
    5145                 : { 0x00, 0xda, 0xda },
    5146                 : { 0x00, 0xdb, 0xdb },
    5147                 : { 0x00, 0xdc, 0xdc },
    5148                 : { 0x00, 0xdd, 0xdd },
    5149                 : { 0x00, 0xde, 0xde },
    5150                 : { 0x00, 0xdf, 0xdf },
    5151                 : { 0x00, 0xe0, 0xe0 },
    5152                 : { 0x00, 0xe1, 0xe1 },
    5153                 : { 0x00, 0xe2, 0xe2 },
    5154                 : { 0x00, 0xe3, 0xe3 },
    5155                 : { 0x00, 0xe4, 0xe4 },
    5156                 : { 0x00, 0xe5, 0xe5 },
    5157                 : { 0x00, 0xe6, 0xe6 },
    5158                 : { 0x00, 0xe7, 0xe7 },
    5159                 : { 0x00, 0xe8, 0xe8 },
    5160                 : { 0x00, 0xe9, 0xe9 },
    5161                 : { 0x00, 0xea, 0xea },
    5162                 : { 0x00, 0xeb, 0xeb },
    5163                 : { 0x00, 0xec, 0xec },
    5164                 : { 0x00, 0xed, 0xed },
    5165                 : { 0x00, 0xee, 0xee },
    5166                 : { 0x00, 0xef, 0xef },
    5167                 : { 0x00, 0xf0, 0xf0 },
    5168                 : { 0x00, 0xf1, 0xf1 },
    5169                 : { 0x00, 0xf2, 0xf2 },
    5170                 : { 0x00, 0xf3, 0xf3 },
    5171                 : { 0x00, 0xf4, 0xf4 },
    5172                 : { 0x00, 0xf5, 0xf5 },
    5173                 : { 0x00, 0xf6, 0xf6 },
    5174                 : { 0x00, 0xf7, 0xf7 },
    5175                 : { 0x00, 0xf8, 0xf8 },
    5176                 : { 0x00, 0xf9, 0xf9 },
    5177                 : { 0x00, 0xfa, 0xfa },
    5178                 : { 0x00, 0xfb, 0xfb },
    5179                 : { 0x00, 0xfc, 0xfc },
    5180                 : { 0x00, 0xfd, 0xfd },
    5181                 : { 0x00, 0xfe, 0xfe },
    5182                 : { 0x00, 0xff, 0xff }
    5183                 : };
    5184                 : 
    5185                 : static struct cs_info tis620_tbl[] = {
    5186                 : { 0x00, 0x00, 0x00 },
    5187                 : { 0x00, 0x01, 0x01 },
    5188                 : { 0x00, 0x02, 0x02 },
    5189                 : { 0x00, 0x03, 0x03 },
    5190                 : { 0x00, 0x04, 0x04 },
    5191                 : { 0x00, 0x05, 0x05 },
    5192                 : { 0x00, 0x06, 0x06 },
    5193                 : { 0x00, 0x07, 0x07 },
    5194                 : { 0x00, 0x08, 0x08 },
    5195                 : { 0x00, 0x09, 0x09 },
    5196                 : { 0x00, 0x0a, 0x0a },
    5197                 : { 0x00, 0x0b, 0x0b },
    5198                 : { 0x00, 0x0c, 0x0c },
    5199                 : { 0x00, 0x0d, 0x0d },
    5200                 : { 0x00, 0x0e, 0x0e },
    5201                 : { 0x00, 0x0f, 0x0f },
    5202                 : { 0x00, 0x10, 0x10 },
    5203                 : { 0x00, 0x11, 0x11 },
    5204                 : { 0x00, 0x12, 0x12 },
    5205                 : { 0x00, 0x13, 0x13 },
    5206                 : { 0x00, 0x14, 0x14 },
    5207                 : { 0x00, 0x15, 0x15 },
    5208                 : { 0x00, 0x16, 0x16 },
    5209                 : { 0x00, 0x17, 0x17 },
    5210                 : { 0x00, 0x18, 0x18 },
    5211                 : { 0x00, 0x19, 0x19 },
    5212                 : { 0x00, 0x1a, 0x1a },
    5213                 : { 0x00, 0x1b, 0x1b },
    5214                 : { 0x00, 0x1c, 0x1c },
    5215                 : { 0x00, 0x1d, 0x1d },
    5216                 : { 0x00, 0x1e, 0x1e },
    5217                 : { 0x00, 0x1f, 0x1f },
    5218                 : { 0x00, 0x20, 0x20 },
    5219                 : { 0x00, 0x21, 0x21 },
    5220                 : { 0x00, 0x22, 0x22 },
    5221                 : { 0x00, 0x23, 0x23 },
    5222                 : { 0x00, 0x24, 0x24 },
    5223                 : { 0x00, 0x25, 0x25 },
    5224                 : { 0x00, 0x26, 0x26 },
    5225                 : { 0x00, 0x27, 0x27 },
    5226                 : { 0x00, 0x28, 0x28 },
    5227                 : { 0x00, 0x29, 0x29 },
    5228                 : { 0x00, 0x2a, 0x2a },
    5229                 : { 0x00, 0x2b, 0x2b },
    5230                 : { 0x00, 0x2c, 0x2c },
    5231                 : { 0x00, 0x2d, 0x2d },
    5232                 : { 0x00, 0x2e, 0x2e },
    5233                 : { 0x00, 0x2f, 0x2f },
    5234                 : { 0x00, 0x30, 0x30 },
    5235                 : { 0x00, 0x31, 0x31 },
    5236                 : { 0x00, 0x32, 0x32 },
    5237                 : { 0x00, 0x33, 0x33 },
    5238                 : { 0x00, 0x34, 0x34 },
    5239                 : { 0x00, 0x35, 0x35 },
    5240                 : { 0x00, 0x36, 0x36 },
    5241                 : { 0x00, 0x37, 0x37 },
    5242                 : { 0x00, 0x38, 0x38 },
    5243                 : { 0x00, 0x39, 0x39 },
    5244                 : { 0x00, 0x3a, 0x3a },
    5245                 : { 0x00, 0x3b, 0x3b },
    5246                 : { 0x00, 0x3c, 0x3c },
    5247                 : { 0x00, 0x3d, 0x3d },
    5248                 : { 0x00, 0x3e, 0x3e },
    5249                 : { 0x00, 0x3f, 0x3f },
    5250                 : { 0x00, 0x40, 0x40 },
    5251                 : { 0x01, 0x61, 0x41 },
    5252                 : { 0x01, 0x62, 0x42 },
    5253                 : { 0x01, 0x63, 0x43 },
    5254                 : { 0x01, 0x64, 0x44 },
    5255                 : { 0x01, 0x65, 0x45 },
    5256                 : { 0x01, 0x66, 0x46 },
    5257                 : { 0x01, 0x67, 0x47 },
    5258                 : { 0x01, 0x68, 0x48 },
    5259                 : { 0x01, 0x69, 0x49 },
    5260                 : { 0x01, 0x6a, 0x4a },
    5261                 : { 0x01, 0x6b, 0x4b },
    5262                 : { 0x01, 0x6c, 0x4c },
    5263                 : { 0x01, 0x6d, 0x4d },
    5264                 : { 0x01, 0x6e, 0x4e },
    5265                 : { 0x01, 0x6f, 0x4f },
    5266                 : { 0x01, 0x70, 0x50 },
    5267                 : { 0x01, 0x71, 0x51 },
    5268                 : { 0x01, 0x72, 0x52 },
    5269                 : { 0x01, 0x73, 0x53 },
    5270                 : { 0x01, 0x74, 0x54 },
    5271                 : { 0x01, 0x75, 0x55 },
    5272                 : { 0x01, 0x76, 0x56 },
    5273                 : { 0x01, 0x77, 0x57 },
    5274                 : { 0x01, 0x78, 0x58 },
    5275                 : { 0x01, 0x79, 0x59 },
    5276                 : { 0x01, 0x7a, 0x5a },
    5277                 : { 0x00, 0x5b, 0x5b },
    5278                 : { 0x00, 0x5c, 0x5c },
    5279                 : { 0x00, 0x5d, 0x5d },
    5280                 : { 0x00, 0x5e, 0x5e },
    5281                 : { 0x00, 0x5f, 0x5f },
    5282                 : { 0x00, 0x60, 0x60 },
    5283                 : { 0x00, 0x61, 0x41 },
    5284                 : { 0x00, 0x62, 0x42 },
    5285                 : { 0x00, 0x63, 0x43 },
    5286                 : { 0x00, 0x64, 0x44 },
    5287                 : { 0x00, 0x65, 0x45 },
    5288                 : { 0x00, 0x66, 0x46 },
    5289                 : { 0x00, 0x67, 0x47 },
    5290                 : { 0x00, 0x68, 0x48 },
    5291                 : { 0x00, 0x69, 0x49 },
    5292                 : { 0x00, 0x6a, 0x4a },
    5293                 : { 0x00, 0x6b, 0x4b },
    5294                 : { 0x00, 0x6c, 0x4c },
    5295                 : { 0x00, 0x6d, 0x4d },
    5296                 : { 0x00, 0x6e, 0x4e },
    5297                 : { 0x00, 0x6f, 0x4f },
    5298                 : { 0x00, 0x70, 0x50 },
    5299                 : { 0x00, 0x71, 0x51 },
    5300                 : { 0x00, 0x72, 0x52 },
    5301                 : { 0x00, 0x73, 0x53 },
    5302                 : { 0x00, 0x74, 0x54 },
    5303                 : { 0x00, 0x75, 0x55 },
    5304                 : { 0x00, 0x76, 0x56 },
    5305                 : { 0x00, 0x77, 0x57 },
    5306                 : { 0x00, 0x78, 0x58 },
    5307                 : { 0x00, 0x79, 0x59 },
    5308                 : { 0x00, 0x7a, 0x5a },
    5309                 : { 0x00, 0x7b, 0x7b },
    5310                 : { 0x00, 0x7c, 0x7c },
    5311                 : { 0x00, 0x7d, 0x7d },
    5312                 : { 0x00, 0x7e, 0x7e },
    5313                 : { 0x00, 0x7f, 0x7f },
    5314                 : { 0x00, 0x80, 0x80 },
    5315                 : { 0x00, 0x81, 0x81 },
    5316                 : { 0x00, 0x82, 0x82 },
    5317                 : { 0x00, 0x83, 0x83 },
    5318                 : { 0x00, 0x84, 0x84 },
    5319                 : { 0x00, 0x85, 0x85 },
    5320                 : { 0x00, 0x86, 0x86 },
    5321                 : { 0x00, 0x87, 0x87 },
    5322                 : { 0x00, 0x88, 0x88 },
    5323                 : { 0x00, 0x89, 0x89 },
    5324                 : { 0x00, 0x8a, 0x8a },
    5325                 : { 0x00, 0x8b, 0x8b },
    5326                 : { 0x00, 0x8c, 0x8c },
    5327                 : { 0x00, 0x8d, 0x8d },
    5328                 : { 0x00, 0x8e, 0x8e },
    5329                 : { 0x00, 0x8f, 0x8f },
    5330                 : { 0x00, 0x90, 0x90 },
    5331                 : { 0x00, 0x91, 0x91 },
    5332                 : { 0x00, 0x92, 0x92 },
    5333                 : { 0x00, 0x93, 0x93 },
    5334                 : { 0x00, 0x94, 0x94 },
    5335                 : { 0x00, 0x95, 0x95 },
    5336                 : { 0x00, 0x96, 0x96 },
    5337                 : { 0x00, 0x97, 0x97 },
    5338                 : { 0x00, 0x98, 0x98 },
    5339                 : { 0x00, 0x99, 0x99 },
    5340                 : { 0x00, 0x9a, 0x9a },
    5341                 : { 0x00, 0x9b, 0x9b },
    5342                 : { 0x00, 0x9c, 0x9c },
    5343                 : { 0x00, 0x9d, 0x9d },
    5344                 : { 0x00, 0x9e, 0x9e },
    5345                 : { 0x00, 0x9f, 0x9f },
    5346                 : { 0x00, 0xa0, 0xa0 },
    5347                 : { 0x00, 0xa1, 0xa1 },
    5348                 : { 0x00, 0xa2, 0xa2 },
    5349                 : { 0x00, 0xa3, 0xa3 },
    5350                 : { 0x00, 0xa4, 0xa4 },
    5351                 : { 0x00, 0xa5, 0xa5 },
    5352                 : { 0x00, 0xa6, 0xa6 },
    5353                 : { 0x00, 0xa7, 0xa7 },
    5354                 : { 0x00, 0xa8, 0xa8 },
    5355                 : { 0x00, 0xa9, 0xa9 },
    5356                 : { 0x00, 0xaa, 0xaa },
    5357                 : { 0x00, 0xab, 0xab },
    5358                 : { 0x00, 0xac, 0xac },
    5359                 : { 0x00, 0xad, 0xad },
    5360                 : { 0x00, 0xae, 0xae },
    5361                 : { 0x00, 0xaf, 0xaf },
    5362                 : { 0x00, 0xb0, 0xb0 },
    5363                 : { 0x00, 0xb1, 0xb1 },
    5364                 : { 0x00, 0xb2, 0xb2 },
    5365                 : { 0x00, 0xb3, 0xb3 },
    5366                 : { 0x00, 0xb4, 0xb4 },
    5367                 : { 0x00, 0xb5, 0xb5 },
    5368                 : { 0x00, 0xb6, 0xb6 },
    5369                 : { 0x00, 0xb7, 0xb7 },
    5370                 : { 0x00, 0xb8, 0xb8 },
    5371                 : { 0x00, 0xb9, 0xb9 },
    5372                 : { 0x00, 0xba, 0xba },
    5373                 : { 0x00, 0xbb, 0xbb },
    5374                 : { 0x00, 0xbc, 0xbc },
    5375                 : { 0x00, 0xbd, 0xbd },
    5376                 : { 0x00, 0xbe, 0xbe },
    5377                 : { 0x00, 0xbf, 0xbf },
    5378                 : { 0x00, 0xc0, 0xc0 },
    5379                 : { 0x00, 0xc1, 0xc1 },
    5380                 : { 0x00, 0xc2, 0xc2 },
    5381                 : { 0x00, 0xc3, 0xc3 },
    5382                 : { 0x00, 0xc4, 0xc4 },
    5383                 : { 0x00, 0xc5, 0xc5 },
    5384                 : { 0x00, 0xc6, 0xc6 },
    5385                 : { 0x00, 0xc7, 0xc7 },
    5386                 : { 0x00, 0xc8, 0xc8 },
    5387                 : { 0x00, 0xc9, 0xc9 },
    5388                 : { 0x00, 0xca, 0xca },
    5389                 : { 0x00, 0xcb, 0xcb },
    5390                 : { 0x00, 0xcc, 0xcc },
    5391                 : { 0x00, 0xcd, 0xcd },
    5392                 : { 0x00, 0xce, 0xce },
    5393                 : { 0x00, 0xcf, 0xcf },
    5394                 : { 0x00, 0xd0, 0xd0 },
    5395                 : { 0x00, 0xd1, 0xd1 },
    5396                 : { 0x00, 0xd2, 0xd2 },
    5397                 : { 0x00, 0xd3, 0xd3 },
    5398                 : { 0x00, 0xd4, 0xd4 },
    5399                 : { 0x00, 0xd5, 0xd5 },
    5400                 : { 0x00, 0xd6, 0xd6 },
    5401                 : { 0x00, 0xd7, 0xd7 },
    5402                 : { 0x00, 0xd8, 0xd8 },
    5403                 : { 0x00, 0xd9, 0xd9 },
    5404                 : { 0x00, 0xda, 0xda },
    5405                 : { 0x00, 0xdb, 0xdb },
    5406                 : { 0x00, 0xdc, 0xdc },
    5407                 : { 0x00, 0xdd, 0xdd },
    5408                 : { 0x00, 0xde, 0xde },
    5409                 : { 0x00, 0xdf, 0xdf },
    5410                 : { 0x00, 0xe0, 0xe0 },
    5411                 : { 0x00, 0xe1, 0xe1 },
    5412                 : { 0x00, 0xe2, 0xe2 },
    5413                 : { 0x00, 0xe3, 0xe3 },
    5414                 : { 0x00, 0xe4, 0xe4 },
    5415                 : { 0x00, 0xe5, 0xe5 },
    5416                 : { 0x00, 0xe6, 0xe6 },
    5417                 : { 0x00, 0xe7, 0xe7 },
    5418                 : { 0x00, 0xe8, 0xe8 },
    5419                 : { 0x00, 0xe9, 0xe9 },
    5420                 : { 0x00, 0xea, 0xea },
    5421                 : { 0x00, 0xeb, 0xeb },
    5422                 : { 0x00, 0xec, 0xec },
    5423                 : { 0x00, 0xed, 0xed },
    5424                 : { 0x00, 0xee, 0xee },
    5425                 : { 0x00, 0xef, 0xef },
    5426                 : { 0x00, 0xf0, 0xf0 },
    5427                 : { 0x00, 0xf1, 0xf1 },
    5428                 : { 0x00, 0xf2, 0xf2 },
    5429                 : { 0x00, 0xf3, 0xf3 },
    5430                 : { 0x00, 0xf4, 0xf4 },
    5431                 : { 0x00, 0xf5, 0xf5 },
    5432                 : { 0x00, 0xf6, 0xf6 },
    5433                 : { 0x00, 0xf7, 0xf7 },
    5434                 : { 0x00, 0xf8, 0xf8 },
    5435                 : { 0x00, 0xf9, 0xf9 },
    5436                 : { 0x00, 0xfa, 0xfa },
    5437                 : { 0x00, 0xfb, 0xfb },
    5438                 : { 0x00, 0xfc, 0xfc },
    5439                 : { 0x00, 0xfd, 0xfd },
    5440                 : { 0x00, 0xfe, 0xfe },
    5441                 : { 0x00, 0xff, 0xff }
    5442                 : };
    5443                 : 
    5444                 : struct enc_entry {
    5445                 :   const char * enc_name;
    5446                 :   struct cs_info * cs_table;
    5447                 : };
    5448                 : 
    5449                 : static struct enc_entry encds[] = {
    5450                 :   {"iso88591",iso1_tbl},                     //ISO-8859-1
    5451                 :   {"iso88592",iso2_tbl},                     //ISO-8859-2
    5452                 :   {"iso88593",iso3_tbl},                     //ISO-8859-3
    5453                 :   {"iso88594",iso4_tbl},                     //ISO-8859-4
    5454                 :   {"iso88595",iso5_tbl},                     //ISO-8859-5
    5455                 :   {"iso88596",iso6_tbl},                     //ISO-8859-6
    5456                 :   {"iso88597",iso7_tbl},                     //ISO-8859-7
    5457                 :   {"iso88598",iso8_tbl},                     //ISO-8859-8
    5458                 :   {"iso88599",iso9_tbl},                     //ISO-8859-9
    5459                 :   {"iso885910",iso10_tbl},                   //ISO-8859-10
    5460                 :   {"tis620",tis620_tbl},                     //TIS-620/ISO-8859-11
    5461                 :   {"tis6202533",tis620_tbl},                 //TIS-620/ISO-8859-11
    5462                 :   {"iso885911",tis620_tbl},                  //TIS-620/ISO-8859-11
    5463                 :   {"iso885913", iso13_tbl},                  //ISO-8859-13
    5464                 :   {"iso885914", iso14_tbl},                  //ISO-8859-14
    5465                 :   {"iso885915", iso15_tbl},                  //ISO-8859-15
    5466                 :   {"koi8r",koi8r_tbl},                       //KOI8-R
    5467                 :   {"koi8u",koi8u_tbl},                       //KOI8-U
    5468                 :   {"cp1251",cp1251_tbl},                     //CP-1251
    5469                 :   {"microsoftcp1251",cp1251_tbl},            //microsoft-cp1251
    5470                 :   {"xisciias", iscii_devanagari_tbl},        //x-iscii-as
    5471                 :   {"isciidevanagari", iscii_devanagari_tbl}  //ISCII-DEVANAGARI
    5472                 : };
    5473                 : 
    5474                 : /* map to lower case and remove non alphanumeric chars */
    5475                 : static void toAsciiLowerAndRemoveNonAlphanumeric( const char* pName, char* pBuf )
    5476                 : {
    5477                 :     while ( *pName )
    5478                 :     {
    5479                 :         /* A-Z */
    5480                 :         if ( (*pName >= 0x41) && (*pName <= 0x5A) )
    5481                 :         {
    5482                 :             *pBuf = (*pName)+0x20;  /* toAsciiLower */
    5483                 :             pBuf++;
    5484                 :         }
    5485                 :         /* a-z, 0-9 */
    5486                 :         else if ( ((*pName >= 0x61) && (*pName <= 0x7A)) ||
    5487                 :                   ((*pName >= 0x30) && (*pName <= 0x39)) )
    5488                 :         {
    5489                 :             *pBuf = *pName;
    5490                 :             pBuf++;
    5491                 :         }
    5492                 : 
    5493                 :         pName++;
    5494                 :     }
    5495                 : 
    5496                 :     *pBuf = '\0';
    5497                 : }
    5498                 : 
    5499                 : struct cs_info * get_current_cs(const char * es) {
    5500                 :   char *normalized_encoding = new char[strlen(es)+1];
    5501                 :   toAsciiLowerAndRemoveNonAlphanumeric(es, normalized_encoding);
    5502                 : 
    5503                 :   struct cs_info * ccs = NULL;
    5504                 :   int n = sizeof(encds) / sizeof(encds[0]);
    5505                 :   for (int i = 0; i < n; i++) {
    5506                 :     if (strcmp(normalized_encoding,encds[i].enc_name) == 0) {
    5507                 :       ccs = encds[i].cs_table;
    5508                 :       break;
    5509                 :     }
    5510                 :   }
    5511                 : 
    5512                 :   delete[] normalized_encoding;
    5513                 : 
    5514                 :   if (!ccs) {
    5515                 :     HUNSPELL_WARNING(stderr, "error: unknown encoding %s: using %s as fallback\n", es, encds[0].enc_name);
    5516                 :     ccs = encds[0].cs_table;
    5517                 :   }
    5518                 : 
    5519                 :   return ccs;
    5520                 : }
    5521                 : #else
    5522                 : // XXX This function was rewritten for mozilla. Instead of storing the
    5523                 : // conversion tables static in this file, create them when needed
    5524                 : // with help the mozilla backend.
    5525             356 : struct cs_info * get_current_cs(const char * es) {
    5526             356 :   struct cs_info *ccs = new cs_info[256];
    5527                 :   // Initialze the array with dummy data so that we wouldn't need
    5528                 :   // to return null in case of failures.
    5529           91492 :   for (int i = 0; i <= 0xff; ++i) {
    5530           91136 :     ccs[i].ccase = false;
    5531           91136 :     ccs[i].clower = i;
    5532           91136 :     ccs[i].cupper = i;
    5533                 :   }
    5534                 : 
    5535             712 :   nsCOMPtr<nsIUnicodeEncoder> encoder; 
    5536             712 :   nsCOMPtr<nsIUnicodeDecoder> decoder; 
    5537                 : 
    5538                 :   nsresult rv;
    5539             712 :   nsCOMPtr<nsICharsetConverterManager> ccm = do_GetService(kCharsetConverterManagerCID, &rv);
    5540             356 :   if (NS_FAILED(rv))
    5541               0 :     return ccs;
    5542                 : 
    5543             356 :   rv = ccm->GetUnicodeEncoder(es, getter_AddRefs(encoder));
    5544             356 :   if (NS_FAILED(rv))
    5545               0 :     return ccs;
    5546             356 :   encoder->SetOutputErrorBehavior(encoder->kOnError_Signal, nsnull, '?');
    5547             356 :   rv = ccm->GetUnicodeDecoder(es, getter_AddRefs(decoder));
    5548             356 :   if (NS_FAILED(rv))
    5549               0 :     return ccs;
    5550             356 :   decoder->SetInputErrorBehavior(decoder->kOnError_Signal);
    5551                 : 
    5552             356 :   if (NS_FAILED(rv))
    5553               0 :     return ccs;
    5554                 : 
    5555           91492 :   for (unsigned int i = 0; i <= 0xff; ++i) {
    5556           91136 :     bool success = false;
    5557                 :     // We want to find the upper/lowercase equivalents of each byte
    5558                 :     // in this 1-byte character encoding.  Call our encoding/decoding
    5559                 :     // APIs separately for each byte since they may reject some of the
    5560                 :     // bytes, and we want to handle errors separately for each byte.
    5561                 :     char lower, upper;
    5562                 :     do {
    5563           91136 :       if (i == 0)
    5564             356 :         break;
    5565           90780 :       const char source = char(i);
    5566                 :       PRUnichar uni, uniCased;
    5567           90780 :       PRInt32 charLength = 1, uniLength = 1;
    5568                 : 
    5569           90780 :       rv = decoder->Convert(&source, &charLength, &uni, &uniLength);
    5570                 :       // Explicitly check NS_OK because we don't want to allow
    5571                 :       // NS_OK_UDEC_MOREOUTPUT or NS_OK_UDEC_MOREINPUT.
    5572           90780 :       if (rv != NS_OK || charLength != 1 || uniLength != 1)
    5573               0 :         break;
    5574           90780 :       uniCased = ToLowerCase(uni);
    5575           90780 :       rv = encoder->Convert(&uniCased, &uniLength, &lower, &charLength);
    5576                 :       // Explicitly check NS_OK because we don't want to allow
    5577                 :       // NS_OK_UDEC_MOREOUTPUT or NS_OK_UDEC_MOREINPUT.
    5578           90780 :       if (rv != NS_OK || charLength != 1 || uniLength != 1)
    5579           10880 :         break;
    5580                 : 
    5581           79900 :       uniCased = ToUpperCase(uni);
    5582           79900 :       rv = encoder->Convert(&uniCased, &uniLength, &upper, &charLength);
    5583                 :       // Explicitly check NS_OK because we don't want to allow
    5584                 :       // NS_OK_UDEC_MOREOUTPUT or NS_OK_UDEC_MOREINPUT.
    5585           79900 :       if (rv != NS_OK || charLength != 1 || uniLength != 1)
    5586            1032 :         break;
    5587                 : 
    5588           78868 :       success = true;
    5589                 :     } while (0);
    5590                 : 
    5591           91136 :     if (success) {
    5592           78868 :       ccs[i].cupper = upper;
    5593           78868 :       ccs[i].clower = lower;
    5594                 :     } else {
    5595           12268 :       ccs[i].cupper = i;
    5596           12268 :       ccs[i].clower = i;
    5597                 :     }
    5598                 : 
    5599           91136 :     if (ccs[i].clower != (unsigned char)i)
    5600           20024 :       ccs[i].ccase = true;
    5601                 :     else
    5602           71112 :       ccs[i].ccase = false;
    5603                 :   }
    5604                 : 
    5605             356 :   return ccs;
    5606                 : }
    5607                 : #endif
    5608                 : 
    5609                 : // primitive isalpha() replacement for tokenization
    5610               0 : char * get_casechars(const char * enc) {
    5611               0 :     struct cs_info * csconv = get_current_cs(enc);
    5612                 :     char expw[MAXLNLEN];
    5613               0 :     char * p =  expw;
    5614               0 :     for (int i = 0; i <= 255; i++) {
    5615               0 :         if ((csconv[i].cupper != csconv[i].clower)) {
    5616               0 :             *p = (char) i;
    5617               0 :             p++;
    5618                 :         }
    5619                 :     }
    5620               0 :     *p = '\0';
    5621                 : #ifdef MOZILLA_CLIENT
    5622               0 :     delete [] csconv;
    5623                 : #endif
    5624               0 :     return mystrdup(expw);
    5625                 : }
    5626                 : 
    5627                 : // language to encoding default map
    5628                 : 
    5629                 : struct lang_map {
    5630                 :   const char * lang;
    5631                 :   int num;
    5632                 : };
    5633                 : 
    5634                 : static struct lang_map lang2enc[] = {
    5635                 : {"ar", LANG_ar},
    5636                 : {"az", LANG_az},
    5637                 : {"az_AZ", LANG_az}, // for back-compatibility
    5638                 : {"bg", LANG_bg},
    5639                 : {"ca", LANG_ca},
    5640                 : {"cs", LANG_cs},
    5641                 : {"da", LANG_da},
    5642                 : {"de", LANG_de},
    5643                 : {"el", LANG_el},
    5644                 : {"en", LANG_en},
    5645                 : {"es", LANG_es},
    5646                 : {"eu", LANG_eu},
    5647                 : {"gl", LANG_gl},
    5648                 : {"fr", LANG_fr},
    5649                 : {"hr", LANG_hr},
    5650                 : {"hu", LANG_hu},
    5651                 : {"hu_HU", LANG_hu}, // for back-compatibility
    5652                 : {"it", LANG_it},
    5653                 : {"la", LANG_la},
    5654                 : {"lv", LANG_lv},
    5655                 : {"nl", LANG_nl},
    5656                 : {"pl", LANG_pl},
    5657                 : {"pt", LANG_pt},
    5658                 : {"sv", LANG_sv},
    5659                 : {"tr", LANG_tr},
    5660                 : {"tr_TR", LANG_tr}, // for back-compatibility
    5661                 : {"ru", LANG_ru},
    5662                 : {"uk", LANG_uk}
    5663                 : };
    5664                 : 
    5665                 : 
    5666               0 : int get_lang_num(const char * lang) {
    5667               0 :   int n = sizeof(lang2enc) / sizeof(lang2enc[0]);
    5668               0 :   for (int i = 0; i < n; i++) {
    5669               0 :     if (strcmp(lang, lang2enc[i].lang) == 0) {
    5670               0 :       return lang2enc[i].num;
    5671                 :     }
    5672                 :   }
    5673               0 :   return LANG_xx;
    5674                 : }
    5675                 : 
    5676                 : #ifndef OPENOFFICEORG
    5677                 : #ifndef MOZILLA_CLIENT
    5678                 : int initialize_utf_tbl() {
    5679                 :   utf_tbl_count++;
    5680                 :   if (utf_tbl) return 0;
    5681                 :   utf_tbl = (unicode_info2 *) malloc(CONTSIZE * sizeof(unicode_info2));
    5682                 :   if (utf_tbl) {
    5683                 :     size_t j;
    5684                 :     for (j = 0; j < CONTSIZE; j++) {
    5685                 :       utf_tbl[j].cletter = 0;
    5686                 :       utf_tbl[j].clower = (unsigned short) j;
    5687                 :       utf_tbl[j].cupper = (unsigned short) j;
    5688                 :     }
    5689                 :     for (j = 0; j < UTF_LST_LEN; j++) {
    5690                 :       utf_tbl[utf_lst[j].c].cletter = 1;
    5691                 :       utf_tbl[utf_lst[j].c].clower = utf_lst[j].clower;
    5692                 :       utf_tbl[utf_lst[j].c].cupper = utf_lst[j].cupper;
    5693                 :     }
    5694                 :   } else return 1;
    5695                 :   return 0;
    5696                 : }
    5697                 : #endif
    5698                 : #endif
    5699                 : 
    5700             110 : void free_utf_tbl() {
    5701             110 :   if (utf_tbl_count > 0) utf_tbl_count--;
    5702             110 :   if (utf_tbl && (utf_tbl_count == 0)) {
    5703               0 :     free(utf_tbl);
    5704               0 :     utf_tbl = NULL;
    5705                 :   }
    5706             110 : }
    5707                 : 
    5708            2071 : unsigned short unicodetoupper(unsigned short c, int langnum)
    5709                 : {
    5710                 :   // In Azeri and Turkish, I and i dictinct letters:
    5711                 :   // There are a dotless lower case i pair of upper `I',
    5712                 :   // and an upper I with dot pair of lower `i'. 
    5713            2071 :   if (c == 0x0069 && ((langnum == LANG_az) || (langnum == LANG_tr)))
    5714               0 :     return 0x0130;
    5715                 : #ifdef OPENOFFICEORG
    5716                 :   return u_toupper(c);
    5717                 : #else
    5718                 : #ifdef MOZILLA_CLIENT
    5719            2071 :   return ToUpperCase((PRUnichar) c);
    5720                 : #else
    5721                 :   return (utf_tbl) ? utf_tbl[c].cupper : c;
    5722                 : #endif
    5723                 : #endif
    5724                 : }
    5725                 : 
    5726            4426 : unsigned short unicodetolower(unsigned short c, int langnum)
    5727                 : {
    5728                 :   // In Azeri and Turkish, I and i dictinct letters:
    5729                 :   // There are a dotless lower case i pair of upper `I',
    5730                 :   // and an upper I with dot pair of lower `i'. 
    5731            4426 :   if (c == 0x0049 && ((langnum == LANG_az) || (langnum == LANG_tr)))
    5732               0 :     return 0x0131;
    5733                 : #ifdef OPENOFFICEORG
    5734                 :   return u_tolower(c);
    5735                 : #else
    5736                 : #ifdef MOZILLA_CLIENT
    5737            4426 :   return ToLowerCase((PRUnichar) c);
    5738                 : #else
    5739                 :   return (utf_tbl) ? utf_tbl[c].clower : c;
    5740                 : #endif
    5741                 : #endif
    5742                 : }
    5743                 : 
    5744               0 : int unicodeisalpha(unsigned short c)
    5745                 : {
    5746                 : #ifdef OPENOFFICEORG
    5747                 :   return u_isalpha(c);
    5748                 : #else
    5749               0 :   return (utf_tbl) ? utf_tbl[c].cletter : 0;
    5750                 : #endif
    5751                 : }
    5752                 : 
    5753                 : /* get type of capitalization */
    5754            1202 : int get_captype(char * word, int nl, cs_info * csconv) {
    5755                 :    // now determine the capitalization type of the first nl letters
    5756            1202 :    int ncap = 0;
    5757            1202 :    int nneutral = 0;
    5758            1202 :    int firstcap = 0;
    5759            1202 :    if (csconv == NULL) return NOCAP;
    5760            9226 :    for (char * q = word; *q != '\0'; q++) {
    5761            8024 :       if (csconv[*((unsigned char *)q)].ccase) ncap++;
    5762            8024 :       if (csconv[*((unsigned char *)q)].cupper == csconv[*((unsigned char *)q)].clower) nneutral++;
    5763                 :    }
    5764            1202 :    if (ncap) {
    5765             226 :      firstcap = csconv[*((unsigned char *) word)].ccase;
    5766                 :    }
    5767                 : 
    5768                 :    // now finally set the captype
    5769            1202 :    if (ncap == 0) {
    5770             976 :         return NOCAP;
    5771             226 :    } else if ((ncap == 1) && firstcap) {
    5772             122 :         return INITCAP;
    5773             104 :    } else if ((ncap == nl) || ((ncap + nneutral) == nl)) {
    5774              34 :         return ALLCAP;
    5775              70 :    } else if ((ncap > 1) && firstcap) {
    5776              38 :         return HUHINITCAP;
    5777                 :    }
    5778              32 :    return HUHCAP;
    5779                 : }
    5780                 : 
    5781             362 : int get_captype_utf8(w_char * word, int nl, int langnum) {
    5782                 :    // now determine the capitalization type of the first nl letters
    5783             362 :    int ncap = 0;
    5784             362 :    int nneutral = 0;
    5785             362 :    int firstcap = 0;
    5786                 :    unsigned short idx;
    5787                 :    // don't check too long words
    5788             362 :    if (nl >= MAXWORDLEN) return 0;
    5789                 :    // big Unicode character (non BMP area)
    5790             362 :    if (nl == -1) return NOCAP;
    5791            2384 :    for (int i = 0; i < nl; i++) {
    5792            2026 :      idx = (word[i].h << 8) + word[i].l;
    5793            2026 :      if (idx != unicodetolower(idx, langnum)) ncap++;
    5794            2026 :      if (unicodetoupper(idx, langnum) == unicodetolower(idx, langnum)) nneutral++;
    5795                 :    }
    5796             358 :    if (ncap) {
    5797              61 :       idx = (word[0].h << 8) + word[0].l;
    5798              61 :       firstcap = (idx != unicodetolower(idx, langnum));
    5799                 :   }
    5800                 : 
    5801                 :    // now finally set the captype
    5802             358 :    if (ncap == 0) {
    5803             297 :         return NOCAP;
    5804              61 :    } else if ((ncap == 1) && firstcap) {
    5805              37 :         return INITCAP;
    5806              24 :    } else if ((ncap == nl) || ((ncap + nneutral) == nl)) {
    5807              16 :         return ALLCAP;
    5808               8 :    } else if ((ncap > 1) && firstcap) {
    5809               6 :         return HUHINITCAP;
    5810                 :    }
    5811               2 :    return HUHCAP;
    5812                 : }
    5813                 : 
    5814                 : 
    5815                 : // strip all ignored characters in the string
    5816              24 : void remove_ignored_chars_utf(char * word, unsigned short ignored_chars[], int ignored_len)
    5817                 : {
    5818                 :    w_char w[MAXWORDLEN];
    5819                 :    w_char w2[MAXWORDLEN];
    5820                 :    int i;
    5821                 :    int j;
    5822              24 :    int len = u8_u16(w, MAXWORDLEN, word);
    5823             130 :    for (i = 0, j = 0; i < len; i++) {
    5824             106 :       if (!flag_bsearch(ignored_chars, ((unsigned short *) w)[i], ignored_len)) {
    5825              97 :          w2[j] = w[i];
    5826              97 :          j++;
    5827                 :       }
    5828                 :    }
    5829              24 :    if (j < i) u16_u8(word, MAXWORDUTF8LEN, w2, j);
    5830              24 : }
    5831                 : 
    5832                 : // strip all ignored characters in the string
    5833               8 : void remove_ignored_chars(char * word, char * ignored_chars)
    5834                 : {
    5835              63 :    for (char * p = word; *p != '\0'; p++) {
    5836              55 :       if (!strchr(ignored_chars, *p)) {
    5837              38 :         *word = *p;
    5838              38 :         word++;
    5839                 :       }
    5840                 :    }
    5841               8 :    *word = '\0';
    5842               8 : }
    5843                 : 
    5844             262 : int parse_string(char * line, char ** out, int ln)
    5845                 : {
    5846             262 :    char * tp = line;
    5847                 :    char * piece;
    5848             262 :    int i = 0;
    5849             262 :    int np = 0;
    5850             262 :    if (*out) {
    5851               0 :       HUNSPELL_WARNING(stderr, "error: line %d: multiple definitions\n", ln);
    5852               0 :       return 1;
    5853                 :    }
    5854             262 :    piece = mystrsep(&tp, 0);
    5855            1048 :    while (piece) {
    5856             524 :       if (*piece != '\0') {
    5857             524 :           switch(i) {
    5858             262 :               case 0: { np++; break; }
    5859                 :               case 1: { 
    5860             262 :                 *out = mystrdup(piece);
    5861             262 :                 if (!*out) return 1;
    5862             262 :                 np++;
    5863             262 :                 break;
    5864                 :               }
    5865               0 :               default: break;
    5866                 :           }
    5867             524 :           i++;
    5868                 :       }
    5869                 :       // free(piece);
    5870             524 :       piece = mystrsep(&tp, 0);
    5871                 :    }
    5872             262 :    if (np != 2) {
    5873               0 :       HUNSPELL_WARNING(stderr, "error: line %d: missing data\n", ln);
    5874               0 :       return 1;
    5875                 :    } 
    5876             262 :    return 0;
    5877                 : }
    5878                 : 
    5879              41 : int parse_array(char * line, char ** out, unsigned short ** out_utf16,
    5880                 :        int * out_utf16_len, int utf8, int ln) {
    5881              41 :    if (parse_string(line, out, ln)) return 1;
    5882              41 :    if (utf8) {
    5883                 :         w_char w[MAXWORDLEN];
    5884              18 :         int n = u8_u16(w, MAXWORDLEN, *out);
    5885              18 :         if (n > 0) {
    5886              18 :             flag_qsort((unsigned short *) w, 0, n);
    5887              18 :             *out_utf16 = (unsigned short *) malloc(n * sizeof(unsigned short));
    5888              18 :             if (!*out_utf16) return 1;
    5889              18 :             memcpy(*out_utf16, w, n * sizeof(unsigned short));
    5890                 :         }
    5891              18 :         *out_utf16_len = n;
    5892                 :    }
    5893              41 :    return 0;
    5894                 : }

Generated by: LCOV version 1.7