The Tor Browser / file revision

 /******* BEGIN LICENSE BLOCK *******

  * Version: MPL 1.1/GPL 2.0/LGPL 2.1

  * 

  * The contents of this file are subject to the Mozilla Public License Version

  * 1.1 (the "License"); you may not use this file except in compliance with

  * the License. You may obtain a copy of the License at

  * http://www.mozilla.org/MPL/

  * 

  * Software distributed under the License is distributed on an "AS IS" basis,

  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

  * for the specific language governing rights and limitations under the

  * License.

  * 

  * The Initial Developers of the Original Code are Kevin Hendricks (MySpell)

  * and László Németh (Hunspell). Portions created by the Initial Developers

  * are Copyright (C) 2002-2005 the Initial Developers. All Rights Reserved.

  * 

  * Contributor(s): Kevin Hendricks (kevin.hendricks@sympatico.ca)

  *                 David Einstein (deinst@world.std.com)

  *                 László Németh (nemethl@gyorsposta.hu)

  *                 L. David Baron (dbaron@dbaron.org)

  *                 Caolan McNamara (caolanm@redhat.com)

  *                 Davide Prina

  *                 Giuseppe Modugno

  *                 Gianluca Turconi

  *                 Simon Brouwer

  *                 Noll Janos

  *                 Biro Arpad

  *                 Goldman Eleonora

  *                 Sarlos Tamas

  *                 Bencsath Boldizsar

  *                 Halacsy Peter

  *                 Dvornik Laszlo

  *                 Gefferth Andras

  *                 Nagy Viktor

  *                 Varga Daniel

  *                 Chris Halls

  *                 Rene Engelhard

  *                 Bram Moolenaar

  *                 Dafydd Jones

  *                 Harri Pitkanen

  *                 Andras Timar

  *                 Tor Lillqvist

  * 

  * Alternatively, the contents of this file may be used under the terms of

  * either the GNU General Public License Version 2 or later (the "GPL"), or

  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

  * in which case the provisions of the GPL or the LGPL are applicable instead

  * of those above. If you wish to allow use of your version of this file only

  * under the terms of either the GPL or the LGPL, and not to allow others to

  * use your version of this file under the terms of the MPL, indicate your

  * decision by deleting the provisions above and replace them with the notice

  * and other provisions required by the GPL or the LGPL. If you do not delete

  * the provisions above, a recipient may use your version of this file under

  * the terms of any one of the MPL, the GPL or the LGPL.

  *

  ******* END LICENSE BLOCK *******/

 #include <stdlib.h> 

 #include <string.h>

 #include <stdio.h> 

 #include <ctype.h>

 #include "csutil.hxx"

 #include "atypes.hxx"

 #include "langnum.hxx"

 // Unicode character encoding information

 struct unicode_info {

   unsigned short c;

   unsigned short cupper;

   unsigned short clower;

 };

 #ifdef OPENOFFICEORG

 #  include <unicode/uchar.h>

 #else

 #  ifndef MOZILLA_CLIENT

 #    include "utf_info.cxx"

 #    define UTF_LST_LEN (sizeof(utf_lst) / (sizeof(unicode_info)))

 #  endif

 #endif

 #ifdef MOZILLA_CLIENT

 #include "nsCOMPtr.h"

 #include "nsServiceManagerUtils.h"

 #include "nsIUnicodeEncoder.h"

 #include "nsIUnicodeDecoder.h"

 #include "nsUnicharUtils.h"

 #include "nsICharsetConverterManager.h"

 static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);

 #endif

 struct unicode_info2 {

   char cletter;

   unsigned short cupper;

   unsigned short clower;

 };

 static struct unicode_info2 * utf_tbl = NULL;

 static int utf_tbl_count = 0; // utf_tbl can be used by multiple Hunspell instances

 /* only UTF-16 (BMP) implementation */

 char * u16_u8(char * dest, int size, const w_char * src, int srclen) {

     signed char * u8 = (signed char *)dest;

     signed char * u8_max = (signed char *)(u8 + size);

     const w_char * u2 = src;

     const w_char * u2_max = src + srclen;

     while ((u2 < u2_max) && (u8 < u8_max)) {

         if (u2->h) { // > 0xFF

             // XXX 4-byte haven't implemented yet.

             if (u2->h >= 0x08) {   // >= 0x800 (3-byte UTF-8 character)

                 *u8 = 0xe0 + (u2->h >> 4);

                 u8++;

                 if (u8 < u8_max) {

                     *u8 = 0x80 + ((u2->h & 0xf) << 2) + (u2->l >> 6);

                     u8++;

                     if (u8 < u8_max) {

                         *u8 = 0x80 + (u2->l & 0x3f);

                         u8++;

                     }

                 }

             } else { // < 0x800 (2-byte UTF-8 character)

                 *u8 = 0xc0 + (u2->h << 2) + (u2->l >> 6);

                 u8++;

                 if (u8 < u8_max) {

                     *u8 = 0x80 + (u2->l & 0x3f);

                     u8++;

                 }

             }

         } else { // <= 0xFF

             if (u2->l & 0x80) { // >0x80 (2-byte UTF-8 character)

                 *u8 = 0xc0 + (u2->l >> 6);

                 u8++;

                 if (u8 < u8_max) {

                     *u8 = 0x80 + (u2->l & 0x3f);

                     u8++;

                 }

             } else { // < 0x80 (1-byte UTF-8 character)

                 *u8 = u2->l;

                 u8++;

             }

         }

         u2++;

     }

     *u8 = '\0';

     return dest;

 }

 /* only UTF-16 (BMP) implementation */

 int u8_u16(w_char * dest, int size, const char * src) {

     const signed char * u8 = (const signed char *)src;

     w_char * u2 = dest;

     w_char * u2_max = u2 + size;

     while ((u2 < u2_max) && *u8) {

     switch ((*u8) & 0xf0) {

         case 0x00:

         case 0x10:

         case 0x20:

         case 0x30:

         case 0x40:

         case 0x50:

         case 0x60:

         case 0x70: {

             u2->h = 0;

             u2->l = *u8;

             break;

         }

         case 0x80:

         case 0x90:

         case 0xa0:

         case 0xb0: {

             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);    

             u2->h = 0xff;

             u2->l = 0xfd;

             break;

         }

         case 0xc0:

         case 0xd0: {    // 2-byte UTF-8 codes

             if ((*(u8+1) & 0xc0) == 0x80) {

                 u2->h = (*u8 & 0x1f) >> 2;

                 u2->l = (*u8 << 6) + (*(u8+1) & 0x3f);

                 u8++;

             } else {

                 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);

                 u2->h = 0xff;

                 u2->l = 0xfd;

             }

             break;

         }

         case 0xe0: {    // 3-byte UTF-8 codes

             if ((*(u8+1) & 0xc0) == 0x80) {

                 u2->h = ((*u8 & 0x0f) << 4) + ((*(u8+1) & 0x3f) >> 2);

                 u8++;

                 if ((*(u8+1) & 0xc0) == 0x80) {

                     u2->l = (*u8 << 6) + (*(u8+1) & 0x3f);

                     u8++;

                 } else {

                     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);

                     u2->h = 0xff;

                     u2->l = 0xfd;

                 }

             } else {

                 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);

                 u2->h = 0xff;

                 u2->l = 0xfd;

             }

             break;

         }

         case 0xf0: {    // 4 or more byte UTF-8 codes

             HUNSPELL_WARNING(stderr, "This UTF-8 encoding can't convert to UTF-16:\n%s\n", src);

             u2->h = 0xff;

             u2->l = 0xfd;

             return -1;

         }

     }

     u8++;

     u2++;

     }

     return (int)(u2 - dest);

 }

 void flag_qsort(unsigned short flags[], int begin, int end) {

     unsigned short reg;

     if (end > begin) {

         unsigned short pivot = flags[begin];

         int l = begin + 1;

         int r = end;

         while(l < r) {

             if (flags[l] <= pivot) {

                 l++;

             } else {

              r--;

              reg = flags[l];

              flags[l] = flags[r];

              flags[r] = reg;

           }

        }

        l--;

        reg = flags[begin];

        flags[begin] = flags[l];

        flags[l] = reg;

        flag_qsort(flags, begin, l);

        flag_qsort(flags, r, end);

     }

  }

 int flag_bsearch(unsigned short flags[], unsigned short flag, int length) {

    int mid;

    int left = 0;

    int right = length - 1;

    while (left <= right) {

       mid = (left + right) / 2;

       if (flags[mid] == flag) return 1;

       if (flag < flags[mid]) right = mid - 1;

       else left = mid + 1;

    }

    return 0;

 }

  // strip strings into token based on single char delimiter

  // acts like strsep() but only uses a delim char and not

  // a delim string

  // default delimiter: white space characters

  char * mystrsep(char ** stringp, const char delim)

  {

    char * mp = *stringp;

    if (*mp != '\0') {

       char * dp;

       if (delim) {

         dp = strchr(mp, delim);

       } else {

         // don't use isspace() here, the string can be in some random charset

         // that's way different than the locale's

         for (dp = mp; (*dp && *dp != ' ' && *dp != '\t'); dp++);

         if (!*dp) dp = NULL;

       }

       if (dp) {

          *stringp = dp+1;

          *dp = '\0';

       } else {

          *stringp = mp + strlen(mp);

       }

       return mp;

    }

    return NULL;

  }

  // replaces strdup with ansi version

  char * mystrdup(const char * s)

  {

    char * d = NULL;

    if (s) {

       size_t sl = strlen(s)+1;

       d = (char *) malloc(sl);

       if (d) {

          memcpy(d,s,sl);

       } else {

          HUNSPELL_WARNING(stderr, "Can't allocate memory.\n");

       }

    }

    return d;

  }

  // strcat for limited length destination string

  char * mystrcat(char * dest, const char * st, int max) {

    int len;

    int len2;

    if (dest == NULL || st == NULL) return dest;

    len = strlen(dest);

    len2 = strlen(st);

    if (len + len2 + 1 > max) return dest;

    strcpy(dest + len, st);

    return dest;

  }

  // remove cross-platform text line end characters

  void mychomp(char * s)

  {

    size_t k = strlen(s);

    if ((k > 0) && ((*(s+k-1)=='\r') || (*(s+k-1)=='\n'))) *(s+k-1) = '\0';

    if ((k > 1) && (*(s+k-2) == '\r')) *(s+k-2) = '\0';

  }

  //  does an ansi strdup of the reverse of a string

  char * myrevstrdup(const char * s)

  {

      char * d = NULL;

      if (s) {

         size_t sl = strlen(s);

         d = (char *) malloc(sl+1);

         if (d) {

           const char * p = s + sl - 1;

           char * q = d;

           while (p >= s) *q++ = *p--;

           *q = '\0';

         } else {

           HUNSPELL_WARNING(stderr, "Can't allocate memory.\n");

         }

      }

      return d;

  }

 // break text to lines

 // return number of lines

 int line_tok(const char * text, char *** lines, char breakchar) {

     int linenum = 0;

     if (!text) {

         return linenum;

     }

     char * dup = mystrdup(text);

     char * p = strchr(dup, breakchar);

     while (p) {

         linenum++;

         *p = '\0';

         p++;

         p = strchr(p, breakchar);

     }

     linenum++;

     *lines = (char **) malloc(linenum * sizeof(char *));

     if (!(*lines)) {

         free(dup);

         return 0;

     }

     p = dup;

     int l = 0;

     for (int i = 0; i < linenum; i++) {

         if (*p != '\0') {

             (*lines)[l] = mystrdup(p);

             if (!(*lines)[l]) {

                 for (i = 0; i < l; i++) free((*lines)[i]);

                 free(dup);

                 return 0;

             }

             l++;

         }

         p += strlen(p) + 1;

     }

     free(dup);

     if (!l) free(*lines);

     return l;

 }

 // uniq line in place

 char * line_uniq(char * text, char breakchar) {

     char ** lines;

     int linenum = line_tok(text, &lines, breakchar);

     int i;

     strcpy(text, lines[0]);

     for ( i = 1; i < linenum; i++ ) {

         int dup = 0;

         for (int j = 0; j < i; j++) {

             if (strcmp(lines[i], lines[j]) == 0) dup = 1;

         }

         if (!dup) {

             if ((i > 1) || (*(lines[0]) != '\0')) {

                 sprintf(text + strlen(text), "%c", breakchar);

             }

             strcat(text, lines[i]);

         }

     }

     for ( i = 0; i < linenum; i++ ) {

         if (lines[i]) free(lines[i]);

     }

     if (lines) free(lines);

     return text;

 }

 // uniq and boundary for compound analysis: "1\n\2\n\1" -> " ( \1 | \2 ) "

 char * line_uniq_app(char ** text, char breakchar) {

     if (!strchr(*text, breakchar)) {

         return *text;

     }

     char ** lines;

     int i;

     int linenum = line_tok(*text, &lines, breakchar);

     int dup = 0;

     for (i = 0; i < linenum; i++) {

         for (int j = 0; j < (i - 1); j++) {

             if (strcmp(lines[i], lines[j]) == 0) {

                 *(lines[i]) = '\0';

                 dup++;

                 break;

             }

         }

     }

     if ((linenum - dup) == 1) {

         strcpy(*text, lines[0]);

         freelist(&lines, linenum);

         return *text;

     }

     char * newtext = (char *) malloc(strlen(*text) + 2 * linenum + 3 + 1);

     if (newtext) {

         free(*text);

         *text = newtext;

     } else {

         freelist(&lines, linenum);

         return *text;

     }    

     strcpy(*text," ( ");

     for (i = 0; i < linenum; i++) if (*(lines[i])) {

         sprintf(*text + strlen(*text), "%s%s", lines[i], " | ");

     }

     (*text)[strlen(*text) - 2] = ')'; // " ) "

     freelist(&lines, linenum);

     return *text;

 }

  // append s to ends of every lines in text

  void strlinecat(char * dest, const char * s)

  {

     char * dup = mystrdup(dest);

     char * source = dup;

     int len = strlen(s);

     if (dup) {

         while (*source) {

             if (*source == '\n') {

                 strncpy(dest, s, len);

                 dest += len;

             }

             *dest = *source;

             source++; dest++;

         }

         strcpy(dest, s);

         free(dup);

     }

  }

 // change \n to char c

 char * tr(char * text, char oldc, char newc) {

     char * p;

     for (p = text; *p; p++) if (*p == oldc) *p = newc;

     return text;

 }

 // morphcmp(): compare MORPH_DERI_SFX, MORPH_INFL_SFX and MORPH_TERM_SFX fields

 // in the first line of the inputs

 // return 0, if inputs equal

 // return 1, if inputs may equal with a secondary suffix

 // otherwise return -1

 int morphcmp(const char * s, const char * t)

 {

     int se = 0;

     int te = 0;

     const char * sl;

     const char * tl;    

     const char * olds;

     const char * oldt;

     if (!s || !t) return 1;

     olds = s;

     sl = strchr(s, '\n');

     s = strstr(s, MORPH_DERI_SFX);

     if (!s || (sl && sl < s)) s = strstr(olds, MORPH_INFL_SFX);

     if (!s || (sl && sl < s)) {

         s= strstr(olds, MORPH_TERM_SFX);

         olds = NULL;

     }

     oldt = t;

     tl = strchr(t, '\n');

     t = strstr(t, MORPH_DERI_SFX);

     if (!t || (tl && tl < t)) t = strstr(oldt, MORPH_INFL_SFX);

     if (!t || (tl && tl < t)) {

         t = strstr(oldt, MORPH_TERM_SFX);

         oldt = NULL;

     }

     while (s && t && (!sl || sl > s) && (!tl || tl > t)) {

         s += MORPH_TAG_LEN;

         t += MORPH_TAG_LEN;

         se = 0;

         te = 0;

         while ((*s == *t) && !se && !te) {

             s++;

             t++;

             switch(*s) {

                 case ' ':

                 case '\n':

                 case '\t':

                 case '\0': se = 1;

             }

             switch(*t) {

                 case ' ':

                 case '\n':

                 case '\t':

                 case '\0': te = 1;

             }

         }

         if (!se || !te) {

             // not terminal suffix difference

             if (olds) return -1;

             return 1;

         }

         olds = s;

         s = strstr(s, MORPH_DERI_SFX);

         if (!s || (sl && sl < s)) s = strstr(olds, MORPH_INFL_SFX);

         if (!s || (sl && sl < s)) {

             s = strstr(olds, MORPH_TERM_SFX);

             olds = NULL;

         }

         oldt = t;

         t = strstr(t, MORPH_DERI_SFX);

         if (!t || (tl && tl < t)) t = strstr(oldt, MORPH_INFL_SFX);

         if (!t || (tl && tl < t)) {

             t = strstr(oldt, MORPH_TERM_SFX);

             oldt = NULL;

         }

     }

     if (!s && !t && se && te) return 0;

     return 1;

 }

 int get_sfxcount(const char * morph)

 {

     if (!morph || !*morph) return 0;

     int n = 0;

     const char * old = morph;

     morph = strstr(morph, MORPH_DERI_SFX);

     if (!morph) morph = strstr(old, MORPH_INFL_SFX);

     if (!morph) morph = strstr(old, MORPH_TERM_SFX);

     while (morph) {

         n++;

         old = morph;

         morph = strstr(morph + 1, MORPH_DERI_SFX);

         if (!morph) morph = strstr(old + 1, MORPH_INFL_SFX);

         if (!morph) morph = strstr(old + 1, MORPH_TERM_SFX);

     }

     return n;

 }

 int fieldlen(const char * r)

 {

     int n = 0;

     while (r && *r != ' ' && *r != '\t' && *r != '\0' && *r != '\n') {

         r++;

         n++;

     }

     return n;

 }

 char * copy_field(char * dest, const char * morph, const char * var)

 {

     if (!morph) return NULL;

     const char * beg = strstr(morph, var);

     if (beg) {

        char * d = dest;

        for (beg += MORPH_TAG_LEN; *beg != ' ' && *beg != '\t' &&

             *beg != '\n' && *beg != '\0'; d++, beg++) {

          *d = *beg;

        }

        *d = '\0';

        return dest;

   }

   return NULL;

 }

 char * mystrrep(char * word, const char * pat, const char * rep) {

     char * pos = strstr(word, pat);

     if (pos) {

       int replen = strlen(rep);

       int patlen = strlen(pat);

       while (pos) {

         if (replen < patlen) {

             char * end = word + strlen(word);

             char * next = pos + replen;

             char * prev = pos + strlen(pat);

             for (; prev < end; *next = *prev, prev++, next++);

             *next = '\0';

         } else if (replen > patlen) {

             char * end = pos + patlen;

             char * next = word + strlen(word) + replen - patlen;

             char * prev = next - replen + patlen;

             for (; prev >= end; *next = *prev, prev--, next--);

         }

         strncpy(pos, rep, replen);

         pos = strstr(word, pat);

       }

     }

     return word;

 }

  // reverse word 

  int reverseword(char * word) {

    char r;

    for (char * dest = word + strlen(word) - 1; word < dest; word++, dest--) {

      r=*word;

      *word = *dest;

      *dest = r;

    }

    return 0;

  }

  // reverse word (error: 1)

  int reverseword_utf(char * word) {

    w_char w[MAXWORDLEN];

    w_char * p;

    w_char r;

    int l = u8_u16(w, MAXWORDLEN, word);

    if (l == -1) return 1;

    p = w;

    for (w_char * dest = w + l - 1; p < dest; p++, dest--) {

      r=*p;

      *p = *dest;

      *dest = r;

    }

    u16_u8(word, MAXWORDUTF8LEN, w, l);

    return 0;

  }

  int uniqlist(char ** list, int n) {

    int i;

    if (n < 2) return n;

    for (i = 0; i < n; i++) {

      for (int j = 0; j < i; j++) {

         if (list[j] && list[i] && (strcmp(list[j], list[i]) == 0)) {

             free(list[i]);

             list[i] = NULL;

             break;

         }

      }

    } 

    int m = 1;  

    for (i = 1; i < n; i++) if (list[i]) {

         list[m] = list[i];

         m++;

     }

    return m;

  }

  void freelist(char *** list, int n) {

    if (list && *list && n > 0) {

      for (int i = 0; i < n; i++) if ((*list)[i]) free((*list)[i]);

      free(*list);

      *list = NULL;

    }

  }

  // convert null terminated string to all caps

  void mkallcap(char * p, const struct cs_info * csconv)

  {

    while (*p != '\0') {

      *p = csconv[((unsigned char) *p)].cupper;

      p++;

    }

  }

  // convert null terminated string to all little

  void mkallsmall(char * p, const struct cs_info * csconv)

  {

    while (*p != '\0') {

      *p = csconv[((unsigned char) *p)].clower;

      p++;

    }

  }

 void mkallsmall_utf(w_char * u, int nc, int langnum) {

     for (int i = 0; i < nc; i++) {

         unsigned short idx = (u[i].h << 8) + u[i].l;

         if (idx != unicodetolower(idx, langnum)) {

             u[i].h = (unsigned char) (unicodetolower(idx, langnum) >> 8);

             u[i].l = (unsigned char) (unicodetolower(idx, langnum) & 0x00FF);

         }

     }

 }

 void mkallcap_utf(w_char * u, int nc, int langnum) {

     for (int i = 0; i < nc; i++) {

         unsigned short idx = (u[i].h << 8) + u[i].l;

         if (idx != unicodetoupper(idx, langnum)) {

             u[i].h = (unsigned char) (unicodetoupper(idx, langnum) >> 8);

             u[i].l = (unsigned char) (unicodetoupper(idx, langnum) & 0x00FF);

         }

     }

 }

  // convert null terminated string to have initial capital

  void mkinitcap(char * p, const struct cs_info * csconv)

  {

    if (*p != '\0') *p = csconv[((unsigned char)*p)].cupper;

  }

  // conversion function for protected memory

  void store_pointer(char * dest, char * source)

  {

     memcpy(dest, &source, sizeof(char *));

  }

  // conversion function for protected memory

  char * get_stored_pointer(const char * s)

  {

     char * p;

     memcpy(&p, s, sizeof(char *));

     return p;

  }

 #ifndef MOZILLA_CLIENT

  // convert null terminated string to all caps using encoding

  void enmkallcap(char * d, const char * p, const char * encoding)

  {

    struct cs_info * csconv = get_current_cs(encoding);

    while (*p != '\0') {

      *d++ = csconv[((unsigned char) *p)].cupper;

      p++;

    }

    *d = '\0';

  }

  // convert null terminated string to all little using encoding

  void enmkallsmall(char * d, const char * p, const char * encoding)

  {

    struct cs_info * csconv = get_current_cs(encoding);

    while (*p != '\0') {

      *d++ = csconv[((unsigned char) *p)].clower;

      p++;

    }

    *d = '\0';

  }

  // convert null terminated string to have initial capital using encoding

  void enmkinitcap(char * d, const char * p, const char * encoding)

  {

    struct cs_info * csconv = get_current_cs(encoding);

    memcpy(d,p,(strlen(p)+1));

    if (*p != '\0') *d= csconv[((unsigned char)*p)].cupper;

  }

 // these are simple character mappings for the 

 // encodings supported

 // supplying isupper, tolower, and toupper

 static struct cs_info iso1_tbl[] = {

 { 0x00, 0x00, 0x00 },

 { 0x00, 0x01, 0x01 },

 { 0x00, 0x02, 0x02 },

 { 0x00, 0x03, 0x03 },

 { 0x00, 0x04, 0x04 },

 { 0x00, 0x05, 0x05 },

 { 0x00, 0x06, 0x06 },

 { 0x00, 0x07, 0x07 },

 { 0x00, 0x08, 0x08 },

 { 0x00, 0x09, 0x09 },

 { 0x00, 0x0a, 0x0a },

 { 0x00, 0x0b, 0x0b },

 { 0x00, 0x0c, 0x0c },

 { 0x00, 0x0d, 0x0d },

 { 0x00, 0x0e, 0x0e },

 { 0x00, 0x0f, 0x0f },

 { 0x00, 0x10, 0x10 },

 { 0x00, 0x11, 0x11 },

 { 0x00, 0x12, 0x12 },

 { 0x00, 0x13, 0x13 },

 { 0x00, 0x14, 0x14 },

 { 0x00, 0x15, 0x15 },

 { 0x00, 0x16, 0x16 },

 { 0x00, 0x17, 0x17 },

 { 0x00, 0x18, 0x18 },

 { 0x00, 0x19, 0x19 },

 { 0x00, 0x1a, 0x1a },

 { 0x00, 0x1b, 0x1b },

 { 0x00, 0x1c, 0x1c },

 { 0x00, 0x1d, 0x1d },

 { 0x00, 0x1e, 0x1e },

 { 0x00, 0x1f, 0x1f },

 { 0x00, 0x20, 0x20 },

 { 0x00, 0x21, 0x21 },

 { 0x00, 0x22, 0x22 },

 { 0x00, 0x23, 0x23 },

 { 0x00, 0x24, 0x24 },

 { 0x00, 0x25, 0x25 },

 { 0x00, 0x26, 0x26 },

 { 0x00, 0x27, 0x27 },

 { 0x00, 0x28, 0x28 },

 { 0x00, 0x29, 0x29 },

 { 0x00, 0x2a, 0x2a },

 { 0x00, 0x2b, 0x2b },

 { 0x00, 0x2c, 0x2c },

 { 0x00, 0x2d, 0x2d },

 { 0x00, 0x2e, 0x2e },

 { 0x00, 0x2f, 0x2f },

 { 0x00, 0x30, 0x30 },

 { 0x00, 0x31, 0x31 },

 { 0x00, 0x32, 0x32 },

 { 0x00, 0x33, 0x33 },

 { 0x00, 0x34, 0x34 },

 { 0x00, 0x35, 0x35 },

 { 0x00, 0x36, 0x36 },

 { 0x00, 0x37, 0x37 },

 { 0x00, 0x38, 0x38 },

 { 0x00, 0x39, 0x39 },

 { 0x00, 0x3a, 0x3a },

 { 0x00, 0x3b, 0x3b },

 { 0x00, 0x3c, 0x3c },

 { 0x00, 0x3d, 0x3d },

 { 0x00, 0x3e, 0x3e },

 { 0x00, 0x3f, 0x3f },

 { 0x00, 0x40, 0x40 },

 { 0x01, 0x61, 0x41 },

 { 0x01, 0x62, 0x42 },

 { 0x01, 0x63, 0x43 },

 { 0x01, 0x64, 0x44 },

 { 0x01, 0x65, 0x45 },

 { 0x01, 0x66, 0x46 },

 { 0x01, 0x67, 0x47 },

 { 0x01, 0x68, 0x48 },

 { 0x01, 0x69, 0x49 },

 { 0x01, 0x6a, 0x4a },

 { 0x01, 0x6b, 0x4b },

 { 0x01, 0x6c, 0x4c },

 { 0x01, 0x6d, 0x4d },

 { 0x01, 0x6e, 0x4e },

 { 0x01, 0x6f, 0x4f },

 { 0x01, 0x70, 0x50 },

 { 0x01, 0x71, 0x51 },

 { 0x01, 0x72, 0x52 },

 { 0x01, 0x73, 0x53 },

 { 0x01, 0x74, 0x54 },

 { 0x01, 0x75, 0x55 },

 { 0x01, 0x76, 0x56 },

 { 0x01, 0x77, 0x57 },

 { 0x01, 0x78, 0x58 },

 { 0x01, 0x79, 0x59 },

 { 0x01, 0x7a, 0x5a },

 { 0x00, 0x5b, 0x5b },

 { 0x00, 0x5c, 0x5c },

 { 0x00, 0x5d, 0x5d },

 { 0x00, 0x5e, 0x5e },

 { 0x00, 0x5f, 0x5f },

 { 0x00, 0x60, 0x60 },

 { 0x00, 0x61, 0x41 },

 { 0x00, 0x62, 0x42 },

 { 0x00, 0x63, 0x43 },

 { 0x00, 0x64, 0x44 },

 { 0x00, 0x65, 0x45 },

 { 0x00, 0x66, 0x46 },

 { 0x00, 0x67, 0x47 },

 { 0x00, 0x68, 0x48 },

 { 0x00, 0x69, 0x49 },

 { 0x00, 0x6a, 0x4a },

 { 0x00, 0x6b, 0x4b },

 { 0x00, 0x6c, 0x4c },

 { 0x00, 0x6d, 0x4d },

 { 0x00, 0x6e, 0x4e },

 { 0x00, 0x6f, 0x4f },

 { 0x00, 0x70, 0x50 },

 { 0x00, 0x71, 0x51 },

 { 0x00, 0x72, 0x52 },

 { 0x00, 0x73, 0x53 },

 { 0x00, 0x74, 0x54 },

 { 0x00, 0x75, 0x55 },

 { 0x00, 0x76, 0x56 },

 { 0x00, 0x77, 0x57 },

 { 0x00, 0x78, 0x58 },

 { 0x00, 0x79, 0x59 },

 { 0x00, 0x7a, 0x5a },

 { 0x00, 0x7b, 0x7b },

 { 0x00, 0x7c, 0x7c },

 { 0x00, 0x7d, 0x7d },

 { 0x00, 0x7e, 0x7e },

 { 0x00, 0x7f, 0x7f },

 { 0x00, 0x80, 0x80 },

 { 0x00, 0x81, 0x81 },

 { 0x00, 0x82, 0x82 },

 { 0x00, 0x83, 0x83 },

 { 0x00, 0x84, 0x84 },

 { 0x00, 0x85, 0x85 },

 { 0x00, 0x86, 0x86 },

 { 0x00, 0x87, 0x87 },

 { 0x00, 0x88, 0x88 },

 { 0x00, 0x89, 0x89 },

 { 0x00, 0x8a, 0x8a },

 { 0x00, 0x8b, 0x8b },

 { 0x00, 0x8c, 0x8c },

 { 0x00, 0x8d, 0x8d },

 { 0x00, 0x8e, 0x8e },

 { 0x00, 0x8f, 0x8f },

 { 0x00, 0x90, 0x90 },

 { 0x00, 0x91, 0x91 },

 { 0x00, 0x92, 0x92 },

 { 0x00, 0x93, 0x93 },

 { 0x00, 0x94, 0x94 },

 { 0x00, 0x95, 0x95 },

 { 0x00, 0x96, 0x96 },

 { 0x00, 0x97, 0x97 },

 { 0x00, 0x98, 0x98 },

 { 0x00, 0x99, 0x99 },

 { 0x00, 0x9a, 0x9a },

 { 0x00, 0x9b, 0x9b },

 { 0x00, 0x9c, 0x9c },

 { 0x00, 0x9d, 0x9d },

 { 0x00, 0x9e, 0x9e },

 { 0x00, 0x9f, 0x9f },

 { 0x00, 0xa0, 0xa0 },

 { 0x00, 0xa1, 0xa1 },

 { 0x00, 0xa2, 0xa2 },

 { 0x00, 0xa3, 0xa3 },

 { 0x00, 0xa4, 0xa4 },

 { 0x00, 0xa5, 0xa5 },

 { 0x00, 0xa6, 0xa6 },

 { 0x00, 0xa7, 0xa7 },

 { 0x00, 0xa8, 0xa8 },

 { 0x00, 0xa9, 0xa9 },

 { 0x00, 0xaa, 0xaa },

 { 0x00, 0xab, 0xab },

 { 0x00, 0xac, 0xac },

 { 0x00, 0xad, 0xad },

 { 0x00, 0xae, 0xae },

 { 0x00, 0xaf, 0xaf },

 { 0x00, 0xb0, 0xb0 },

 { 0x00, 0xb1, 0xb1 },

 { 0x00, 0xb2, 0xb2 },

 { 0x00, 0xb3, 0xb3 },

 { 0x00, 0xb4, 0xb4 },

 { 0x00, 0xb5, 0xb5 },

 { 0x00, 0xb6, 0xb6 },

 { 0x00, 0xb7, 0xb7 },

 { 0x00, 0xb8, 0xb8 },

 { 0x00, 0xb9, 0xb9 },

 { 0x00, 0xba, 0xba },

 { 0x00, 0xbb, 0xbb },

 { 0x00, 0xbc, 0xbc },

 { 0x00, 0xbd, 0xbd },

 { 0x00, 0xbe, 0xbe },

 { 0x00, 0xbf, 0xbf },

 { 0x01, 0xe0, 0xc0 },

 { 0x01, 0xe1, 0xc1 },

 { 0x01, 0xe2, 0xc2 },

 { 0x01, 0xe3, 0xc3 },

 { 0x01, 0xe4, 0xc4 },

 { 0x01, 0xe5, 0xc5 },

 { 0x01, 0xe6, 0xc6 },

 { 0x01, 0xe7, 0xc7 },

 { 0x01, 0xe8, 0xc8 },

 { 0x01, 0xe9, 0xc9 },

 { 0x01, 0xea, 0xca },

 { 0x01, 0xeb, 0xcb },

 { 0x01, 0xec, 0xcc },

 { 0x01, 0xed, 0xcd },

 { 0x01, 0xee, 0xce },

 { 0x01, 0xef, 0xcf },

 { 0x01, 0xf0, 0xd0 },

 { 0x01, 0xf1, 0xd1 },

 { 0x01, 0xf2, 0xd2 },

 { 0x01, 0xf3, 0xd3 },

 { 0x01, 0xf4, 0xd4 },

 { 0x01, 0xf5, 0xd5 },

 { 0x01, 0xf6, 0xd6 },

 { 0x00, 0xd7, 0xd7 },

 { 0x01, 0xf8, 0xd8 },

 { 0x01, 0xf9, 0xd9 },

 { 0x01, 0xfa, 0xda },

 { 0x01, 0xfb, 0xdb },

 { 0x01, 0xfc, 0xdc },

 { 0x01, 0xfd, 0xdd },

 { 0x01, 0xfe, 0xde },

 { 0x00, 0xdf, 0xdf },

 { 0x00, 0xe0, 0xc0 },

 { 0x00, 0xe1, 0xc1 },

 { 0x00, 0xe2, 0xc2 },

 { 0x00, 0xe3, 0xc3 },

 { 0x00, 0xe4, 0xc4 },

 { 0x00, 0xe5, 0xc5 },

 { 0x00, 0xe6, 0xc6 },

 { 0x00, 0xe7, 0xc7 },

 { 0x00, 0xe8, 0xc8 },

 { 0x00, 0xe9, 0xc9 },

 { 0x00, 0xea, 0xca },

 { 0x00, 0xeb, 0xcb },

 { 0x00, 0xec, 0xcc },

 { 0x00, 0xed, 0xcd },

 { 0x00, 0xee, 0xce },

 { 0x00, 0xef, 0xcf },

 { 0x00, 0xf0, 0xd0 },

 { 0x00, 0xf1, 0xd1 },

 { 0x00, 0xf2, 0xd2 },

 { 0x00, 0xf3, 0xd3 },

 { 0x00, 0xf4, 0xd4 },

 { 0x00, 0xf5, 0xd5 },

 { 0x00, 0xf6, 0xd6 },

 { 0x00, 0xf7, 0xf7 },

 { 0x00, 0xf8, 0xd8 },

 { 0x00, 0xf9, 0xd9 },

 { 0x00, 0xfa, 0xda },

 { 0x00, 0xfb, 0xdb },

 { 0x00, 0xfc, 0xdc },

 { 0x00, 0xfd, 0xdd },

 { 0x00, 0xfe, 0xde },

 { 0x00, 0xff, 0xff }

 };

 static struct cs_info iso2_tbl[] = {

 { 0x00, 0x00, 0x00 },

 { 0x00, 0x01, 0x01 },

 { 0x00, 0x02, 0x02 },

 { 0x00, 0x03, 0x03 },

 { 0x00, 0x04, 0x04 },

 { 0x00, 0x05, 0x05 },

 { 0x00, 0x06, 0x06 },

 { 0x00, 0x07, 0x07 },

 { 0x00, 0x08, 0x08 },

 { 0x00, 0x09, 0x09 },

 { 0x00, 0x0a, 0x0a },

 { 0x00, 0x0b, 0x0b },

 { 0x00, 0x0c, 0x0c },

 { 0x00, 0x0d, 0x0d },

 { 0x00, 0x0e, 0x0e },

 { 0x00, 0x0f, 0x0f },

 { 0x00, 0x10, 0x10 },

 { 0x00, 0x11, 0x11 },

 { 0x00, 0x12, 0x12 },

 { 0x00, 0x13, 0x13 },

 { 0x00, 0x14, 0x14 },

 { 0x00, 0x15, 0x15 },

 { 0x00, 0x16, 0x16 },

 { 0x00, 0x17, 0x17 },

 { 0x00, 0x18, 0x18 },

 { 0x00, 0x19, 0x19 },

 { 0x00, 0x1a, 0x1a },

 { 0x00, 0x1b, 0x1b },

 { 0x00, 0x1c, 0x1c },

 { 0x00, 0x1d, 0x1d },

 { 0x00, 0x1e, 0x1e },

 { 0x00, 0x1f, 0x1f },

 { 0x00, 0x20, 0x20 },

 { 0x00, 0x21, 0x21 },

 { 0x00, 0x22, 0x22 },

 { 0x00, 0x23, 0x23 },

 { 0x00, 0x24, 0x24 },

 { 0x00, 0x25, 0x25 },

 { 0x00, 0x26, 0x26 },

 { 0x00, 0x27, 0x27 },

 { 0x00, 0x28, 0x28 },

 { 0x00, 0x29, 0x29 },

 { 0x00, 0x2a, 0x2a },

 { 0x00, 0x2b, 0x2b },

 { 0x00, 0x2c, 0x2c },

 { 0x00, 0x2d, 0x2d },

 { 0x00, 0x2e, 0x2e },

 { 0x00, 0x2f, 0x2f },

 { 0x00, 0x30, 0x30 },

 { 0x00, 0x31, 0x31 },

 { 0x00, 0x32, 0x32 },

 { 0x00, 0x33, 0x33 },

 { 0x00, 0x34, 0x34 },

 { 0x00, 0x35, 0x35 },

 { 0x00, 0x36, 0x36 },

 { 0x00, 0x37, 0x37 },

 { 0x00, 0x38, 0x38 },

 { 0x00, 0x39, 0x39 },

 { 0x00, 0x3a, 0x3a },

 { 0x00, 0x3b, 0x3b },

 { 0x00, 0x3c, 0x3c },

 { 0x00, 0x3d, 0x3d },

 { 0x00, 0x3e, 0x3e },

 { 0x00, 0x3f, 0x3f },

 { 0x00, 0x40, 0x40 },

 { 0x01, 0x61, 0x41 },

 { 0x01, 0x62, 0x42 },

 { 0x01, 0x63, 0x43 },

 { 0x01, 0x64, 0x44 },

 { 0x01, 0x65, 0x45 },

 { 0x01, 0x66, 0x46 },

 { 0x01, 0x67, 0x47 },

 { 0x01, 0x68, 0x48 },

 { 0x01, 0x69, 0x49 },

 { 0x01, 0x6a, 0x4a },

 { 0x01, 0x6b, 0x4b },

 { 0x01, 0x6c, 0x4c },

 { 0x01, 0x6d, 0x4d },

 { 0x01, 0x6e, 0x4e },

 { 0x01, 0x6f, 0x4f },

 { 0x01, 0x70, 0x50 },

 { 0x01, 0x71, 0x51 },

 { 0x01, 0x72, 0x52 },

 { 0x01, 0x73, 0x53 },

 { 0x01, 0x74, 0x54 },

 { 0x01, 0x75, 0x55 },

 { 0x01, 0x76, 0x56 },

 { 0x01, 0x77, 0x57 },

 { 0x01, 0x78, 0x58 },

 { 0x01, 0x79, 0x59 },

 { 0x01, 0x7a, 0x5a },

 { 0x00, 0x5b, 0x5b },

 { 0x00, 0x5c, 0x5c },

 { 0x00, 0x5d, 0x5d },

 { 0x00, 0x5e, 0x5e },

 { 0x00, 0x5f, 0x5f },

 { 0x00, 0x60, 0x60 },

 { 0x00, 0x61, 0x41 },

 { 0x00, 0x62, 0x42 },

 { 0x00, 0x63, 0x43 },

 { 0x00, 0x64, 0x44 },

 { 0x00, 0x65, 0x45 },

 { 0x00, 0x66, 0x46 },

 { 0x00, 0x67, 0x47 },

 { 0x00, 0x68, 0x48 },

 { 0x00, 0x69, 0x49 },

 { 0x00, 0x6a, 0x4a },

 { 0x00, 0x6b, 0x4b },

 { 0x00, 0x6c, 0x4c },

 { 0x00, 0x6d, 0x4d },

 { 0x00, 0x6e, 0x4e },

 { 0x00, 0x6f, 0x4f },

 { 0x00, 0x70, 0x50 },

 { 0x00, 0x71, 0x51 },

 { 0x00, 0x72, 0x52 },

 { 0x00, 0x73, 0x53 },

 { 0x00, 0x74, 0x54 },

 { 0x00, 0x75, 0x55 },

 { 0x00, 0x76, 0x56 },

 { 0x00, 0x77, 0x57 },

 { 0x00, 0x78, 0x58 },

 { 0x00, 0x79, 0x59 },

 { 0x00, 0x7a, 0x5a },

 { 0x00, 0x7b, 0x7b },

 { 0x00, 0x7c, 0x7c },

 { 0x00, 0x7d, 0x7d },

 { 0x00, 0x7e, 0x7e },

 { 0x00, 0x7f, 0x7f },

 { 0x00, 0x80, 0x80 },

 { 0x00, 0x81, 0x81 },

 { 0x00, 0x82, 0x82 },

 { 0x00, 0x83, 0x83 },

 { 0x00, 0x84, 0x84 },

 { 0x00, 0x85, 0x85 },

 { 0x00, 0x86, 0x86 },

 { 0x00, 0x87, 0x87 },

 { 0x00, 0x88, 0x88 },

 { 0x00, 0x89, 0x89 },

 { 0x00, 0x8a, 0x8a },

 { 0x00, 0x8b, 0x8b },

 { 0x00, 0x8c, 0x8c },

 { 0x00, 0x8d, 0x8d },

 { 0x00, 0x8e, 0x8e },

 { 0x00, 0x8f, 0x8f },

 { 0x00, 0x90, 0x90 },

 { 0x00, 0x91, 0x91 },

 { 0x00, 0x92, 0x92 },

 { 0x00, 0x93, 0x93 },

 { 0x00, 0x94, 0x94 },

 { 0x00, 0x95, 0x95 },

 { 0x00, 0x96, 0x96 },

 { 0x00, 0x97, 0x97 },

 { 0x00, 0x98, 0x98 },

 { 0x00, 0x99, 0x99 },

 { 0x00, 0x9a, 0x9a },

 { 0x00, 0x9b, 0x9b },

 { 0x00, 0x9c, 0x9c },

 { 0x00, 0x9d, 0x9d },

 { 0x00, 0x9e, 0x9e },

 { 0x00, 0x9f, 0x9f },

 { 0x00, 0xa0, 0xa0 },

 { 0x01, 0xb1, 0xa1 },

 { 0x00, 0xa2, 0xa2 },

 { 0x01, 0xb3, 0xa3 },

 { 0x00, 0xa4, 0xa4 },

 { 0x01, 0xb5, 0xa5 },

 { 0x01, 0xb6, 0xa6 },

 { 0x00, 0xa7, 0xa7 },

 { 0x00, 0xa8, 0xa8 },

 { 0x01, 0xb9, 0xa9 },

 { 0x01, 0xba, 0xaa },

 { 0x01, 0xbb, 0xab },

 { 0x01, 0xbc, 0xac },

 { 0x00, 0xad, 0xad },

 { 0x01, 0xbe, 0xae },

 { 0x01, 0xbf, 0xaf },

 { 0x00, 0xb0, 0xb0 },

 { 0x00, 0xb1, 0xa1 },

 { 0x00, 0xb2, 0xb2 },

 { 0x00, 0xb3, 0xa3 },

 { 0x00, 0xb4, 0xb4 },

 { 0x00, 0xb5, 0xa5 },

 { 0x00, 0xb6, 0xa6 },

 { 0x00, 0xb7, 0xb7 },

 { 0x00, 0xb8, 0xb8 },

 { 0x00, 0xb9, 0xa9 },

 { 0x00, 0xba, 0xaa },

 { 0x00, 0xbb, 0xab },

 { 0x00, 0xbc, 0xac },

 { 0x00, 0xbd, 0xbd },

 { 0x00, 0xbe, 0xae },

 { 0x00, 0xbf, 0xaf },

 { 0x01, 0xe0, 0xc0 },

 { 0x01, 0xe1, 0xc1 },

 { 0x01, 0xe2, 0xc2 },

 { 0x01, 0xe3, 0xc3 },

 { 0x01, 0xe4, 0xc4 },

 { 0x01, 0xe5, 0xc5 },

 { 0x01, 0xe6, 0xc6 },

 { 0x01, 0xe7, 0xc7 },

 { 0x01, 0xe8, 0xc8 },

 { 0x01, 0xe9, 0xc9 },

 { 0x01, 0xea, 0xca },

 { 0x01, 0xeb, 0xcb },

 { 0x01, 0xec, 0xcc },

 { 0x01, 0xed, 0xcd },

 { 0x01, 0xee, 0xce },

 { 0x01, 0xef, 0xcf },

 { 0x01, 0xf0, 0xd0 },

 { 0x01, 0xf1, 0xd1 },

 { 0x01, 0xf2, 0xd2 },

 { 0x01, 0xf3, 0xd3 },

 { 0x01, 0xf4, 0xd4 },

 { 0x01, 0xf5, 0xd5 },

 { 0x01, 0xf6, 0xd6 },

 { 0x00, 0xd7, 0xd7 },

 { 0x01, 0xf8, 0xd8 },

 { 0x01, 0xf9, 0xd9 },

 { 0x01, 0xfa, 0xda },

 { 0x01, 0xfb, 0xdb },

 { 0x01, 0xfc, 0xdc },

 { 0x01, 0xfd, 0xdd },

 { 0x01, 0xfe, 0xde },

 { 0x00, 0xdf, 0xdf },

 { 0x00, 0xe0, 0xc0 },

 { 0x00, 0xe1, 0xc1 },

 { 0x00, 0xe2, 0xc2 },

 { 0x00, 0xe3, 0xc3 },

 { 0x00, 0xe4, 0xc4 },

 { 0x00, 0xe5, 0xc5 },

 { 0x00, 0xe6, 0xc6 },

 { 0x00, 0xe7, 0xc7 },

 { 0x00, 0xe8, 0xc8 },

 { 0x00, 0xe9, 0xc9 },

 { 0x00, 0xea, 0xca },

 { 0x00, 0xeb, 0xcb },

 { 0x00, 0xec, 0xcc },

 { 0x00, 0xed, 0xcd },

 { 0x00, 0xee, 0xce },

 { 0x00, 0xef, 0xcf },

 { 0x00, 0xf0, 0xd0 },

 { 0x00, 0xf1, 0xd1 },

 { 0x00, 0xf2, 0xd2 },

 { 0x00, 0xf3, 0xd3 },

 { 0x00, 0xf4, 0xd4 },

 { 0x00, 0xf5, 0xd5 },

 { 0x00, 0xf6, 0xd6 },

 { 0x00, 0xf7, 0xf7 },

 { 0x00, 0xf8, 0xd8 },

 { 0x00, 0xf9, 0xd9 },

 { 0x00, 0xfa, 0xda },

 { 0x00, 0xfb, 0xdb },

 { 0x00, 0xfc, 0xdc },

 { 0x00, 0xfd, 0xdd },

 { 0x00, 0xfe, 0xde },

 { 0x00, 0xff, 0xff }

 };

 static struct cs_info iso3_tbl[] = {

 { 0x00, 0x00, 0x00 },

 { 0x00, 0x01, 0x01 },

 { 0x00, 0x02, 0x02 },

 { 0x00, 0x03, 0x03 },

 { 0x00, 0x04, 0x04 },

 { 0x00, 0x05, 0x05 },

 { 0x00, 0x06, 0x06 },

 { 0x00, 0x07, 0x07 },

 { 0x00, 0x08, 0x08 },

 { 0x00, 0x09, 0x09 },

 { 0x00, 0x0a, 0x0a },

 { 0x00, 0x0b, 0x0b },

 { 0x00, 0x0c, 0x0c },

 { 0x00, 0x0d, 0x0d },

 { 0x00, 0x0e, 0x0e },

 { 0x00, 0x0f, 0x0f },

 { 0x00, 0x10, 0x10 },

 { 0x00, 0x11, 0x11 },

 { 0x00, 0x12, 0x12 },

 { 0x00, 0x13, 0x13 },

 { 0x00, 0x14, 0x14 },

 { 0x00, 0x15, 0x15 },

 { 0x00, 0x16, 0x16 },

 { 0x00, 0x17, 0x17 },

 { 0x00, 0x18, 0x18 },

 { 0x00, 0x19, 0x19 },

 { 0x00, 0x1a, 0x1a },

 { 0x00, 0x1b, 0x1b },

 { 0x00, 0x1c, 0x1c },

 { 0x00, 0x1d, 0x1d },

 { 0x00, 0x1e, 0x1e },

 { 0x00, 0x1f, 0x1f },

 { 0x00, 0x20, 0x20 },

 { 0x00, 0x21, 0x21 },

 { 0x00, 0x22, 0x22 },

 { 0x00, 0x23, 0x23 },

 { 0x00, 0x24, 0x24 },

 { 0x00, 0x25, 0x25 },

 { 0x00, 0x26, 0x26 },

 { 0x00, 0x27, 0x27 },

 { 0x00, 0x28, 0x28 },

 { 0x00, 0x29, 0x29 },

 { 0x00, 0x2a, 0x2a },

 { 0x00, 0x2b, 0x2b },

 { 0x00, 0x2c, 0x2c },

 { 0x00, 0x2d, 0x2d },

 { 0x00, 0x2e, 0x2e },

 { 0x00, 0x2f, 0x2f },

 { 0x00, 0x30, 0x30 },

 { 0x00, 0x31, 0x31 },

 { 0x00, 0x32, 0x32 },

 { 0x00, 0x33, 0x33 },

 { 0x00, 0x34, 0x34 },

 { 0x00, 0x35, 0x35 },

 { 0x00, 0x36, 0x36 },

 { 0x00, 0x37, 0x37 },

 { 0x00, 0x38, 0x38 },

 { 0x00, 0x39, 0x39 },

 { 0x00, 0x3a, 0x3a },

 { 0x00, 0x3b, 0x3b },

 { 0x00, 0x3c, 0x3c },

 { 0x00, 0x3d, 0x3d },

 { 0x00, 0x3e, 0x3e },

 { 0x00, 0x3f, 0x3f },

 { 0x00, 0x40, 0x40 },

 { 0x01, 0x61, 0x41 },

 { 0x01, 0x62, 0x42 },

 { 0x01, 0x63, 0x43 },

 { 0x01, 0x64, 0x44 },

 { 0x01, 0x65, 0x45 },

 { 0x01, 0x66, 0x46 },

 { 0x01, 0x67, 0x47 },

 { 0x01, 0x68, 0x48 },

 { 0x01, 0x69, 0x49 },

 { 0x01, 0x6a, 0x4a },

 { 0x01, 0x6b, 0x4b },

 { 0x01, 0x6c, 0x4c },

 { 0x01, 0x6d, 0x4d },

 { 0x01, 0x6e, 0x4e },

 { 0x01, 0x6f, 0x4f },

 { 0x01, 0x70, 0x50 },

 { 0x01, 0x71, 0x51 },

 { 0x01, 0x72, 0x52 },

 { 0x01, 0x73, 0x53 },

 { 0x01, 0x74, 0x54 },

 { 0x01, 0x75, 0x55 },

 { 0x01, 0x76, 0x56 },

 { 0x01, 0x77, 0x57 },

 { 0x01, 0x78, 0x58 },

 { 0x01, 0x79, 0x59 },

 { 0x01, 0x7a, 0x5a },

 { 0x00, 0x5b, 0x5b },

 { 0x00, 0x5c, 0x5c },

 { 0x00, 0x5d, 0x5d },

 { 0x00, 0x5e, 0x5e },

 { 0x00, 0x5f, 0x5f },

 { 0x00, 0x60, 0x60 },

 { 0x00, 0x61, 0x41 },

 { 0x00, 0x62, 0x42 },

 { 0x00, 0x63, 0x43 },

 { 0x00, 0x64, 0x44 },

 { 0x00, 0x65, 0x45 },

 { 0x00, 0x66, 0x46 },

 { 0x00, 0x67, 0x47 },

 { 0x00, 0x68, 0x48 },

 { 0x00, 0x69, 0x49 },

 { 0x00, 0x6a, 0x4a },

 { 0x00, 0x6b, 0x4b },

 { 0x00, 0x6c, 0x4c },

 { 0x00, 0x6d, 0x4d },

 { 0x00, 0x6e, 0x4e },

 { 0x00, 0x6f, 0x4f },

 { 0x00, 0x70, 0x50 },

 { 0x00, 0x71, 0x51 },

 { 0x00, 0x72, 0x52 },

 { 0x00, 0x73, 0x53 },

 { 0x00, 0x74, 0x54 },

 { 0x00, 0x75, 0x55 },

 { 0x00, 0x76, 0x56 },

 { 0x00, 0x77, 0x57 },

 { 0x00, 0x78, 0x58 },

 { 0x00, 0x79, 0x59 },

 { 0x00, 0x7a, 0x5a },

 { 0x00, 0x7b, 0x7b },

 { 0x00, 0x7c, 0x7c },

 { 0x00, 0x7d, 0x7d },

 { 0x00, 0x7e, 0x7e },

 { 0x00, 0x7f, 0x7f },

 { 0x00, 0x80, 0x80 },

 { 0x00, 0x81, 0x81 },

 { 0x00, 0x82, 0x82 },

 { 0x00, 0x83, 0x83 },

 { 0x00, 0x84, 0x84 },

 { 0x00, 0x85, 0x85 },

 { 0x00, 0x86, 0x86 },

 { 0x00, 0x87, 0x87 },

 { 0x00, 0x88, 0x88 },

 { 0x00, 0x89, 0x89 },

 { 0x00, 0x8a, 0x8a },

 { 0x00, 0x8b, 0x8b },

 { 0x00, 0x8c, 0x8c },

 { 0x00, 0x8d, 0x8d },

 { 0x00, 0x8e, 0x8e },

 { 0x00, 0x8f, 0x8f },

 { 0x00, 0x90, 0x90 },

 { 0x00, 0x91, 0x91 },

 { 0x00, 0x92, 0x92 },

 { 0x00, 0x93, 0x93 },

 { 0x00, 0x94, 0x94 },

 { 0x00, 0x95, 0x95 },

 { 0x00, 0x96, 0x96 },

 { 0x00, 0x97, 0x97 },

 { 0x00, 0x98, 0x98 },

 { 0x00, 0x99, 0x99 },

 { 0x00, 0x9a, 0x9a },

 { 0x00, 0x9b, 0x9b },

 { 0x00, 0x9c, 0x9c },

 { 0x00, 0x9d, 0x9d },

 { 0x00, 0x9e, 0x9e },

 { 0x00, 0x9f, 0x9f },

 { 0x00, 0xa0, 0xa0 },

 { 0x01, 0xb1, 0xa1 },

 { 0x00, 0xa2, 0xa2 },

 { 0x00, 0xa3, 0xa3 },

 { 0x00, 0xa4, 0xa4 },

 { 0x00, 0xa5, 0xa5 },

 { 0x01, 0xb6, 0xa6 },

 { 0x00, 0xa7, 0xa7 },

 { 0x00, 0xa8, 0xa8 },

 { 0x01, 0x69, 0xa9 },

 { 0x01, 0xba, 0xaa },

 { 0x01, 0xbb, 0xab },

 { 0x01, 0xbc, 0xac },

 { 0x00, 0xad, 0xad },

 { 0x00, 0xae, 0xae },

 { 0x01, 0xbf, 0xaf },

 { 0x00, 0xb0, 0xb0 },

 { 0x00, 0xb1, 0xa1 },

 { 0x00, 0xb2, 0xb2 },

 { 0x00, 0xb3, 0xb3 },

 { 0x00, 0xb4, 0xb4 },

 { 0x00, 0xb5, 0xb5 },

 { 0x00, 0xb6, 0xa6 },

 { 0x00, 0xb7, 0xb7 },

 { 0x00, 0xb8, 0xb8 },

 { 0x00, 0xb9, 0x49 },

 { 0x00, 0xba, 0xaa },

 { 0x00, 0xbb, 0xab },

 { 0x00, 0xbc, 0xac },

 { 0x00, 0xbd, 0xbd },

 { 0x00, 0xbe, 0xbe },

 { 0x00, 0xbf, 0xaf },

 { 0x01, 0xe0, 0xc0 },

 { 0x01, 0xe1, 0xc1 },

 { 0x01, 0xe2, 0xc2 },

 { 0x00, 0xc3, 0xc3 },

 { 0x01, 0xe4, 0xc4 },

 { 0x01, 0xe5, 0xc5 },

 { 0x01, 0xe6, 0xc6 },

 { 0x01, 0xe7, 0xc7 },

 { 0x01, 0xe8, 0xc8 },

 { 0x01, 0xe9, 0xc9 },

 { 0x01, 0xea, 0xca },

 { 0x01, 0xeb, 0xcb },

 { 0x01, 0xec, 0xcc },

 { 0x01, 0xed, 0xcd },

 { 0x01, 0xee, 0xce },

 { 0x01, 0xef, 0xcf },

 { 0x00, 0xd0, 0xd0 },

 { 0x01, 0xf1, 0xd1 },

 { 0x01, 0xf2, 0xd2 },

 { 0x01, 0xf3, 0xd3 },

 { 0x01, 0xf4, 0xd4 },

 { 0x01, 0xf5, 0xd5 },

 { 0x01, 0xf6, 0xd6 },

 { 0x00, 0xd7, 0xd7 },

 { 0x01, 0xf8, 0xd8 },

 { 0x01, 0xf9, 0xd9 },

 { 0x01, 0xfa, 0xda },

 { 0x01, 0xfb, 0xdb },

 { 0x01, 0xfc, 0xdc },

 { 0x01, 0xfd, 0xdd },

 { 0x01, 0xfe, 0xde },

 { 0x00, 0xdf, 0xdf },

 { 0x00, 0xe0, 0xc0 },

 { 0x00, 0xe1, 0xc1 },

 { 0x00, 0xe2, 0xc2 },

 { 0x00, 0xe3, 0xe3 },

 { 0x00, 0xe4, 0xc4 },

 { 0x00, 0xe5, 0xc5 },

 { 0x00, 0xe6, 0xc6 },

 { 0x00, 0xe7, 0xc7 },

 { 0x00, 0xe8, 0xc8 },

 { 0x00, 0xe9, 0xc9 },

 { 0x00, 0xea, 0xca },

 { 0x00, 0xeb, 0xcb },

 { 0x00, 0xec, 0xcc },

 { 0x00, 0xed, 0xcd },

 { 0x00, 0xee, 0xce },

 { 0x00, 0xef, 0xcf },

 { 0x00, 0xf0, 0xf0 },

 { 0x00, 0xf1, 0xd1 },

 { 0x00, 0xf2, 0xd2 },

 { 0x00, 0xf3, 0xd3 },

 { 0x00, 0xf4, 0xd4 },

 { 0x00, 0xf5, 0xd5 },

 { 0x00, 0xf6, 0xd6 },

 { 0x00, 0xf7, 0xf7 },

 { 0x00, 0xf8, 0xd8 },

 { 0x00, 0xf9, 0xd9 },

 { 0x00, 0xfa, 0xda },

 { 0x00, 0xfb, 0xdb },

 { 0x00, 0xfc, 0xdc },

 { 0x00, 0xfd, 0xdd },

 { 0x00, 0xfe, 0xde },

 { 0x00, 0xff, 0xff }

 };

 static struct cs_info iso4_tbl[] = {

 { 0x00, 0x00, 0x00 },

 { 0x00, 0x01, 0x01 },

 { 0x00, 0x02, 0x02 },

 { 0x00, 0x03, 0x03 },

 { 0x00, 0x04, 0x04 },

 { 0x00, 0x05, 0x05 },

 { 0x00, 0x06, 0x06 },

 { 0x00, 0x07, 0x07 },

 { 0x00, 0x08, 0x08 },

 { 0x00, 0x09, 0x09 },

 { 0x00, 0x0a, 0x0a },

 { 0x00, 0x0b, 0x0b },

 { 0x00, 0x0c, 0x0c },

 { 0x00, 0x0d, 0x0d },

 { 0x00, 0x0e, 0x0e },

 { 0x00, 0x0f, 0x0f },

 { 0x00, 0x10, 0x10 },

 { 0x00, 0x11, 0x11 },

 { 0x00, 0x12, 0x12 },

 { 0x00, 0x13, 0x13 },

 { 0x00, 0x14, 0x14 },

 { 0x00, 0x15, 0x15 },

 { 0x00, 0x16, 0x16 },

 { 0x00, 0x17, 0x17 },

 { 0x00, 0x18, 0x18 },

 { 0x00, 0x19, 0x19 },

 { 0x00, 0x1a, 0x1a },

 { 0x00, 0x1b, 0x1b },

 { 0x00, 0x1c, 0x1c },

 { 0x00, 0x1d, 0x1d },

 { 0x00, 0x1e, 0x1e },

 { 0x00, 0x1f, 0x1f },

 { 0x00, 0x20, 0x20 },

 { 0x00, 0x21, 0x21 },

 { 0x00, 0x22, 0x22 },

 { 0x00, 0x23, 0x23 },

 { 0x00, 0x24, 0x24 },

 { 0x00, 0x25, 0x25 },

 { 0x00, 0x26, 0x26 },

 { 0x00, 0x27, 0x27 },

 { 0x00, 0x28, 0x28 },

 { 0x00, 0x29, 0x29 },

 { 0x00, 0x2a, 0x2a },

 { 0x00, 0x2b, 0x2b },

 { 0x00, 0x2c, 0x2c },

 { 0x00, 0x2d, 0x2d },

 { 0x00, 0x2e, 0x2e },

 { 0x00, 0x2f, 0x2f },

 { 0x00, 0x30, 0x30 },

 { 0x00, 0x31, 0x31 },

 { 0x00, 0x32, 0x32 },

 { 0x00, 0x33, 0x33 },

 { 0x00, 0x34, 0x34 },

 { 0x00, 0x35, 0x35 },

 { 0x00, 0x36, 0x36 },

 { 0x00, 0x37, 0x37 },

 { 0x00, 0x38, 0x38 },

 { 0x00, 0x39, 0x39 },

 { 0x00, 0x3a, 0x3a },

 { 0x00, 0x3b, 0x3b },

 { 0x00, 0x3c, 0x3c },

 { 0x00, 0x3d, 0x3d },

 { 0x00, 0x3e, 0x3e },

 { 0x00, 0x3f, 0x3f },

 { 0x00, 0x40, 0x40 },

 { 0x01, 0x61, 0x41 },

 { 0x01, 0x62, 0x42 },

 { 0x01, 0x63, 0x43 },

 { 0x01, 0x64, 0x44 },

 { 0x01, 0x65, 0x45 },

 { 0x01, 0x66, 0x46 },

 { 0x01, 0x67, 0x47 },

 { 0x01, 0x68, 0x48 },

 { 0x01, 0x69, 0x49 },

 { 0x01, 0x6a, 0x4a },

 { 0x01, 0x6b, 0x4b },

 { 0x01, 0x6c, 0x4c },

 { 0x01, 0x6d, 0x4d },

 { 0x01, 0x6e, 0x4e },

 { 0x01, 0x6f, 0x4f },

 { 0x01, 0x70, 0x50 },

 { 0x01, 0x71, 0x51 },

 { 0x01, 0x72, 0x52 },

 { 0x01, 0x73, 0x53 },

 { 0x01, 0x74, 0x54 },

 { 0x01, 0x75, 0x55 },

 { 0x01, 0x76, 0x56 },

 { 0x01, 0x77, 0x57 },

 { 0x01, 0x78, 0x58 },

 { 0x01, 0x79, 0x59 },

 { 0x01, 0x7a, 0x5a },

 { 0x00, 0x5b, 0x5b },

 { 0x00, 0x5c, 0x5c },

 { 0x00, 0x5d, 0x5d },

 { 0x00, 0x5e, 0x5e },

 { 0x00, 0x5f, 0x5f },

 { 0x00, 0x60, 0x60 },

 { 0x00, 0x61, 0x41 },

 { 0x00, 0x62, 0x42 },

 { 0x00, 0x63, 0x43 },

 { 0x00, 0x64, 0x44 },

 { 0x00, 0x65, 0x45 },

 { 0x00, 0x66, 0x46 },

 { 0x00, 0x67, 0x47 },

 { 0x00, 0x68, 0x48 },

 { 0x00, 0x69, 0x49 },

 { 0x00, 0x6a, 0x4a },

 { 0x00, 0x6b, 0x4b },

 { 0x00, 0x6c, 0x4c },

 { 0x00, 0x6d, 0x4d },

 { 0x00, 0x6e, 0x4e },

 { 0x00, 0x6f, 0x4f },

 { 0x00, 0x70, 0x50 },

 { 0x00, 0x71, 0x51 },

 { 0x00, 0x72, 0x52 },

 { 0x00, 0x73, 0x53 },

 { 0x00, 0x74, 0x54 },

 { 0x00, 0x75, 0x55 },

 { 0x00, 0x76, 0x56 },

 { 0x00, 0x77, 0x57 },

 { 0x00, 0x78, 0x58 },

 { 0x00, 0x79, 0x59 },

 { 0x00, 0x7a, 0x5a },

 { 0x00, 0x7b, 0x7b },

 { 0x00, 0x7c, 0x7c },

 { 0x00, 0x7d, 0x7d },

 { 0x00, 0x7e, 0x7e },

 { 0x00, 0x7f, 0x7f },

 { 0x00, 0x80, 0x80 },

 { 0x00, 0x81, 0x81 },

 { 0x00, 0x82, 0x82 },

 { 0x00, 0x83, 0x83 },

 { 0x00, 0x84, 0x84 },

 { 0x00, 0x85, 0x85 },

 { 0x00, 0x86, 0x86 },

 { 0x00, 0x87, 0x87 },

 { 0x00, 0x88, 0x88 },

 { 0x00, 0x89, 0x89 },

 { 0x00, 0x8a, 0x8a },

 { 0x00, 0x8b, 0x8b },

 { 0x00, 0x8c, 0x8c },

 { 0x00, 0x8d, 0x8d },

 { 0x00, 0x8e, 0x8e },

 { 0x00, 0x8f, 0x8f },

 { 0x00, 0x90, 0x90 },

 { 0x00, 0x91, 0x91 },

 { 0x00, 0x92, 0x92 },

 { 0x00, 0x93, 0x93 },

 { 0x00, 0x94, 0x94 },

 { 0x00, 0x95, 0x95 },

 { 0x00, 0x96, 0x96 },

 { 0x00, 0x97, 0x97 },

 { 0x00, 0x98, 0x98 },

 { 0x00, 0x99, 0x99 },

 { 0x00, 0x9a, 0x9a },

 { 0x00, 0x9b, 0x9b },

 { 0x00, 0x9c, 0x9c },

 { 0x00, 0x9d, 0x9d },

 { 0x00, 0x9e, 0x9e },

 { 0x00, 0x9f, 0x9f },

 { 0x00, 0xa0, 0xa0 },

 { 0x01, 0xb1, 0xa1 },

 { 0x00, 0xa2, 0xa2 },

 { 0x01, 0xb3, 0xa3 },

 { 0x00, 0xa4, 0xa4 },

 { 0x01, 0xb5, 0xa5 },

 { 0x01, 0xb6, 0xa6 },

 { 0x00, 0xa7, 0xa7 },

 { 0x00, 0xa8, 0xa8 },

 { 0x01, 0xb9, 0xa9 },

 { 0x01, 0xba, 0xaa },

 { 0x01, 0xbb, 0xab },

 { 0x01, 0xbc, 0xac },

 { 0x00, 0xad, 0xad },

 { 0x01, 0xbe, 0xae },

 { 0x00, 0xaf, 0xaf },

 { 0x00, 0xb0, 0xb0 },

 { 0x00, 0xb1, 0xa1 },

 { 0x00, 0xb2, 0xb2 },

 { 0x00, 0xb3, 0xa3 },

 { 0x00, 0xb4, 0xb4 },

 { 0x00, 0xb5, 0xa5 },

 { 0x00, 0xb6, 0xa6 },

 { 0x00, 0xb7, 0xb7 },

 { 0x00, 0xb8, 0xb8 },

 { 0x00, 0xb9, 0xa9 },

 { 0x00, 0xba, 0xaa },

 { 0x00, 0xbb, 0xab },

 { 0x00, 0xbc, 0xac },

 { 0x00, 0xbd, 0xbd },

 { 0x00, 0xbe, 0xae },

 { 0x00, 0xbf, 0xbf },

 { 0x01, 0xe0, 0xc0 },

 { 0x01, 0xe1, 0xc1 },

 { 0x01, 0xe2, 0xc2 },

 { 0x01, 0xe3, 0xc3 },

 { 0x01, 0xe4, 0xc4 },

 { 0x01, 0xe5, 0xc5 },

 { 0x01, 0xe6, 0xc6 },

 { 0x01, 0xe7, 0xc7 },

 { 0x01, 0xe8, 0xc8 },

 { 0x01, 0xe9, 0xc9 },

 { 0x01, 0xea, 0xca },

 { 0x01, 0xeb, 0xcb },

 { 0x01, 0xec, 0xcc },

 { 0x01, 0xed, 0xcd },

 { 0x01, 0xee, 0xce },

 { 0x01, 0xef, 0xcf },

 { 0x01, 0xf0, 0xd0 },

 { 0x01, 0xf1, 0xd1 },

 { 0x01, 0xf2, 0xd2 },

 { 0x01, 0xf3, 0xd3 },

 { 0x01, 0xf4, 0xd4 },

 { 0x01, 0xf5, 0xd5 },

 { 0x01, 0xf6, 0xd6 },

 { 0x00, 0xd7, 0xd7 },

 { 0x01, 0xf8, 0xd8 },

 { 0x01, 0xf9, 0xd9 },

 { 0x01, 0xfa, 0xda },

 { 0x01, 0xfb, 0xdb },

 { 0x01, 0xfc, 0xdc },

 { 0x01, 0xfd, 0xdd },

 { 0x01, 0xfe, 0xde },

 { 0x00, 0xdf, 0xdf },

 { 0x00, 0xe0, 0xc0 },

 { 0x00, 0xe1, 0xc1 },

 { 0x00, 0xe2, 0xc2 },

 { 0x00, 0xe3, 0xc3 },

 { 0x00, 0xe4, 0xc4 },

 { 0x00, 0xe5, 0xc5 },

 { 0x00, 0xe6, 0xc6 },

 { 0x00, 0xe7, 0xc7 },

 { 0x00, 0xe8, 0xc8 },

 { 0x00, 0xe9, 0xc9 },

 { 0x00, 0xea, 0xca },

 { 0x00, 0xeb, 0xcb },

 { 0x00, 0xec, 0xcc },

 { 0x00, 0xed, 0xcd },

 { 0x00, 0xee, 0xce },

 { 0x00, 0xef, 0xcf },

 { 0x00, 0xf0, 0xd0 },

 { 0x00, 0xf1, 0xd1 },

 { 0x00, 0xf2, 0xd2 },

 { 0x00, 0xf3, 0xd3 },

 { 0x00, 0xf4, 0xd4 },

 { 0x00, 0xf5, 0xd5 },

 { 0x00, 0xf6, 0xd6 },

 { 0x00, 0xf7, 0xf7 },

 { 0x00, 0xf8, 0xd8 },

 { 0x00, 0xf9, 0xd9 },

 { 0x00, 0xfa, 0xda },

 { 0x00, 0xfb, 0xdb },

 { 0x00, 0xfc, 0xdc },

 { 0x00, 0xfd, 0xdd },

 { 0x00, 0xfe, 0xde },

 { 0x00, 0xff, 0xff }

 };

 static struct cs_info iso5_tbl[] = {

 { 0x00, 0x00, 0x00 },

 { 0x00, 0x01, 0x01 },

 { 0x00, 0x02, 0x02 },

 { 0x00, 0x03, 0x03 },

 { 0x00, 0x04, 0x04 },

 { 0x00, 0x05, 0x05 },

 { 0x00, 0x06, 0x06 },

 { 0x00, 0x07, 0x07 },

 { 0x00, 0x08, 0x08 },

 { 0x00, 0x09, 0x09 },

 { 0x00, 0x0a, 0x0a },

 { 0x00, 0x0b, 0x0b },

 { 0x00, 0x0c, 0x0c },

 { 0x00, 0x0d, 0x0d },

 { 0x00, 0x0e, 0x0e },

 { 0x00, 0x0f, 0x0f },

 { 0x00, 0x10, 0x10 },

 { 0x00, 0x11, 0x11 },

 { 0x00, 0x12, 0x12 },

 { 0x00, 0x13, 0x13 },

 { 0x00, 0x14, 0x14 },

 { 0x00, 0x15, 0x15 },

 { 0x00, 0x16, 0x16 },

 { 0x00, 0x17, 0x17 },

 { 0x00, 0x18, 0x18 },

 { 0x00, 0x19, 0x19 },

 { 0x00, 0x1a, 0x1a },

 { 0x00, 0x1b, 0x1b },

 { 0x00, 0x1c, 0x1c },

 { 0x00, 0x1d, 0x1d },

 { 0x00, 0x1e, 0x1e },

 { 0x00, 0x1f, 0x1f },

 { 0x00, 0x20, 0x20 },

 { 0x00, 0x21, 0x21 },

 { 0x00, 0x22, 0x22 },

 { 0x00, 0x23, 0x23 },

 { 0x00, 0x24, 0x24 },

 { 0x00, 0x25, 0x25 },

 { 0x00, 0x26, 0x26 },

 { 0x00, 0x27, 0x27 },

 { 0x00, 0x28, 0x28 },

 { 0x00, 0x29, 0x29 },

 { 0x00, 0x2a, 0x2a },

 { 0x00, 0x2b, 0x2b },

 { 0x00, 0x2c, 0x2c },

 { 0x00, 0x2d, 0x2d },

 { 0x00, 0x2e, 0x2e },

 { 0x00, 0x2f, 0x2f },

 { 0x00, 0x30, 0x30 },

 { 0x00, 0x31, 0x31 },

 { 0x00, 0x32, 0x32 },

 { 0x00, 0x33, 0x33 },

 { 0x00, 0x34, 0x34 },

 { 0x00, 0x35, 0x35 },

 { 0x00, 0x36, 0x36 },

 { 0x00, 0x37, 0x37 },

 { 0x00, 0x38, 0x38 },

 { 0x00, 0x39, 0x39 },

 { 0x00, 0x3a, 0x3a },

 { 0x00, 0x3b, 0x3b },

 { 0x00, 0x3c, 0x3c },

 { 0x00, 0x3d, 0x3d },

 { 0x00, 0x3e, 0x3e },

 { 0x00, 0x3f, 0x3f },

 { 0x00, 0x40, 0x40 },

 { 0x01, 0x61, 0x41 },

 { 0x01, 0x62, 0x42 },

 { 0x01, 0x63, 0x43 },

 { 0x01, 0x64, 0x44 },

 { 0x01, 0x65, 0x45 },

 { 0x01, 0x66, 0x46 },

 { 0x01, 0x67, 0x47 },

 { 0x01, 0x68, 0x48 },

 { 0x01, 0x69, 0x49 },

 { 0x01, 0x6a, 0x4a },

 { 0x01, 0x6b, 0x4b },

 { 0x01, 0x6c, 0x4c },

 { 0x01, 0x6d, 0x4d },

 { 0x01, 0x6e, 0x4e },

 { 0x01, 0x6f, 0x4f },

 { 0x01, 0x70, 0x50 },

 { 0x01, 0x71, 0x51 },

 { 0x01, 0x72, 0x52 },

 { 0x01, 0x73, 0x53 },

 { 0x01, 0x74, 0x54 },

 { 0x01, 0x75, 0x55 },

 { 0x01, 0x76, 0x56 },

 { 0x01, 0x77, 0x57 },

 { 0x01, 0x78, 0x58 },

 { 0x01, 0x79, 0x59 },

 { 0x01, 0x7a, 0x5a },

 { 0x00, 0x5b, 0x5b },

 { 0x00, 0x5c, 0x5c },

 { 0x00, 0x5d, 0x5d },

 { 0x00, 0x5e, 0x5e },

 { 0x00, 0x5f, 0x5f },

 { 0x00, 0x60, 0x60 },

 { 0x00, 0x61, 0x41 },

 { 0x00, 0x62, 0x42 },

 { 0x00, 0x63, 0x43 },

 { 0x00, 0x64, 0x44 },

 { 0x00, 0x65, 0x45 },

 { 0x00, 0x66, 0x46 },

 { 0x00, 0x67, 0x47 },

 { 0x00, 0x68, 0x48 },

 { 0x00, 0x69, 0x49 },

 { 0x00, 0x6a, 0x4a },

 { 0x00, 0x6b, 0x4b },

 { 0x00, 0x6c, 0x4c },

 { 0x00, 0x6d, 0x4d },

 { 0x00, 0x6e, 0x4e },

 { 0x00, 0x6f, 0x4f },

 { 0x00, 0x70, 0x50 },

 { 0x00, 0x71, 0x51 },

 { 0x00, 0x72, 0x52 },

 { 0x00, 0x73, 0x53 },

 { 0x00, 0x74, 0x54 },

 { 0x00, 0x75, 0x55 },

 { 0x00, 0x76, 0x56 },

 { 0x00, 0x77, 0x57 },

 { 0x00, 0x78, 0x58 },

 { 0x00, 0x79, 0x59 },

 { 0x00, 0x7a, 0x5a },

 { 0x00, 0x7b, 0x7b },

 { 0x00, 0x7c, 0x7c },

 { 0x00, 0x7d, 0x7d },

 { 0x00, 0x7e, 0x7e },

 { 0x00, 0x7f, 0x7f },

 { 0x00, 0x80, 0x80 },

 { 0x00, 0x81, 0x81 },

 { 0x00, 0x82, 0x82 },

 { 0x00, 0x83, 0x83 },

 { 0x00, 0x84, 0x84 },

 { 0x00, 0x85, 0x85 },

 { 0x00, 0x86, 0x86 },

 { 0x00, 0x87, 0x87 },

 { 0x00, 0x88, 0x88 },

 { 0x00, 0x89, 0x89 },

 { 0x00, 0x8a, 0x8a },

 { 0x00, 0x8b, 0x8b },

 { 0x00, 0x8c, 0x8c },

 { 0x00, 0x8d, 0x8d },

 { 0x00, 0x8e, 0x8e },

 { 0x00, 0x8f, 0x8f },

 { 0x00, 0x90, 0x90 },

 { 0x00, 0x91, 0x91 },

 { 0x00, 0x92, 0x92 },

 { 0x00, 0x93, 0x93 },

 { 0x00, 0x94, 0x94 },

 { 0x00, 0x95, 0x95 },

 { 0x00, 0x96, 0x96 },

 { 0x00, 0x97, 0x97 },

 { 0x00, 0x98, 0x98 },

 { 0x00, 0x99, 0x99 },

 { 0x00, 0x9a, 0x9a },

 { 0x00, 0x9b, 0x9b },

 { 0x00, 0x9c, 0x9c },

 { 0x00, 0x9d, 0x9d },

 { 0x00, 0x9e, 0x9e },

 { 0x00, 0x9f, 0x9f },

 { 0x00, 0xa0, 0xa0 },

 { 0x01, 0xf1, 0xa1 },

 { 0x01, 0xf2, 0xa2 },

 { 0x01, 0xf3, 0xa3 },

 { 0x01, 0xf4, 0xa4 },

 { 0x01, 0xf5, 0xa5 },

 { 0x01, 0xf6, 0xa6 },

 { 0x01, 0xf7, 0xa7 },

 { 0x01, 0xf8, 0xa8 },

 { 0x01, 0xf9, 0xa9 },

 { 0x01, 0xfa, 0xaa },

 { 0x01, 0xfb, 0xab },

 { 0x01, 0xfc, 0xac },

 { 0x00, 0xad, 0xad },

 { 0x01, 0xfe, 0xae },

 { 0x01, 0xff, 0xaf },

 { 0x01, 0xd0, 0xb0 },

 { 0x01, 0xd1, 0xb1 },

 { 0x01, 0xd2, 0xb2 },

 { 0x01, 0xd3, 0xb3 },

 { 0x01, 0xd4, 0xb4 },

 { 0x01, 0xd5, 0xb5 },

 { 0x01, 0xd6, 0xb6 },

 { 0x01, 0xd7, 0xb7 },

 { 0x01, 0xd8, 0xb8 },

 { 0x01, 0xd9, 0xb9 },

 { 0x01, 0xda, 0xba },

 { 0x01, 0xdb, 0xbb },

 { 0x01, 0xdc, 0xbc },

 { 0x01, 0xdd, 0xbd },

 { 0x01, 0xde, 0xbe },

 { 0x01, 0xdf, 0xbf },

 { 0x01, 0xe0, 0xc0 },

 { 0x01, 0xe1, 0xc1 },

 { 0x01, 0xe2, 0xc2 },

 { 0x01, 0xe3, 0xc3 },

 { 0x01, 0xe4, 0xc4 },

 { 0x01, 0xe5, 0xc5 },

 { 0x01, 0xe6, 0xc6 },

 { 0x01, 0xe7, 0xc7 },

 { 0x01, 0xe8, 0xc8 },

 { 0x01, 0xe9, 0xc9 },

 { 0x01, 0xea, 0xca },

 { 0x01, 0xeb, 0xcb },

 { 0x01, 0xec, 0xcc },

 { 0x01, 0xed, 0xcd },

 { 0x01, 0xee, 0xce },

 { 0x01, 0xef, 0xcf },

 { 0x00, 0xd0, 0xb0 },

 { 0x00, 0xd1, 0xb1 },

 { 0x00, 0xd2, 0xb2 },

 { 0x00, 0xd3, 0xb3 },

 { 0x00, 0xd4, 0xb4 },

 { 0x00, 0xd5, 0xb5 },

 { 0x00, 0xd6, 0xb6 },

 { 0x00, 0xd7, 0xb7 },

 { 0x00, 0xd8, 0xb8 },

 { 0x00, 0xd9, 0xb9 },

 { 0x00, 0xda, 0xba },

 { 0x00, 0xdb, 0xbb },

 { 0x00, 0xdc, 0xbc },

 { 0x00, 0xdd, 0xbd },

 { 0x00, 0xde, 0xbe },

 { 0x00, 0xdf, 0xbf },

 { 0x00, 0xe0, 0xc0 },

 { 0x00, 0xe1, 0xc1 },

 { 0x00, 0xe2, 0xc2 },

 { 0x00, 0xe3, 0xc3 },

 { 0x00, 0xe4, 0xc4 },

 { 0x00, 0xe5, 0xc5 },

 { 0x00, 0xe6, 0xc6 },

 { 0x00, 0xe7, 0xc7 },

 { 0x00, 0xe8, 0xc8 },

 { 0x00, 0xe9, 0xc9 },

 { 0x00, 0xea, 0xca },

 { 0x00, 0xeb, 0xcb },

 { 0x00, 0xec, 0xcc },

 { 0x00, 0xed, 0xcd },

 { 0x00, 0xee, 0xce },

 { 0x00, 0xef, 0xcf },

 { 0x00, 0xf0, 0xf0 },

 { 0x00, 0xf1, 0xa1 },

 { 0x00, 0xf2, 0xa2 },

 { 0x00, 0xf3, 0xa3 },

 { 0x00, 0xf4, 0xa4 },

 { 0x00, 0xf5, 0xa5 },

 { 0x00, 0xf6, 0xa6 },

 { 0x00, 0xf7, 0xa7 },

 { 0x00, 0xf8, 0xa8 },

 { 0x00, 0xf9, 0xa9 },

 { 0x00, 0xfa, 0xaa },

 { 0x00, 0xfb, 0xab },

 { 0x00, 0xfc, 0xac },

 { 0x00, 0xfd, 0xfd },

 { 0x00, 0xfe, 0xae },

 { 0x00, 0xff, 0xaf }

 };

 static struct cs_info iso6_tbl[] = {

 { 0x00, 0x00, 0x00 },

 { 0x00, 0x01, 0x01 },

 { 0x00, 0x02, 0x02 },

 { 0x00, 0x03, 0x03 },

 { 0x00, 0x04, 0x04 },

 { 0x00, 0x05, 0x05 },

 { 0x00, 0x06, 0x06 },

 { 0x00, 0x07, 0x07 },

 { 0x00, 0x08, 0x08 },

 { 0x00, 0x09, 0x09 },

 { 0x00, 0x0a, 0x0a },

 { 0x00, 0x0b, 0x0b },

 { 0x00, 0x0c, 0x0c },

 { 0x00, 0x0d, 0x0d },

 { 0x00, 0x0e, 0x0e },

 { 0x00, 0x0f, 0x0f },

 { 0x00, 0x10, 0x10 },

 { 0x00, 0x11, 0x11 },

 { 0x00, 0x12, 0x12 },

 { 0x00, 0x13, 0x13 },

 { 0x00, 0x14, 0x14 },

 { 0x00, 0x15, 0x15 },

 { 0x00, 0x16, 0x16 },

 { 0x00, 0x17, 0x17 },

 { 0x00, 0x18, 0x18 },

 { 0x00, 0x19, 0x19 },

 { 0x00, 0x1a, 0x1a },

 { 0x00, 0x1b, 0x1b },

 { 0x00, 0x1c, 0x1c },

 { 0x00, 0x1d, 0x1d },

 { 0x00, 0x1e, 0x1e },

 { 0x00, 0x1f, 0x1f },

 { 0x00, 0x20, 0x20 },

 { 0x00, 0x21, 0x21 },

 { 0x00, 0x22, 0x22 },

 { 0x00, 0x23, 0x23 },

 { 0x00, 0x24, 0x24 },

 { 0x00, 0x25, 0x25 },

 { 0x00, 0x26, 0x26 },

 { 0x00, 0x27, 0x27 },

 { 0x00, 0x28, 0x28 },

 { 0x00, 0x29, 0x29 },

 { 0x00, 0x2a, 0x2a },

 { 0x00, 0x2b, 0x2b },

 { 0x00, 0x2c, 0x2c },

 { 0x00, 0x2d, 0x2d },

 { 0x00, 0x2e, 0x2e },

 { 0x00, 0x2f, 0x2f },

 { 0x00, 0x30, 0x30 },

 { 0x00, 0x31, 0x31 },

 { 0x00, 0x32, 0x32 },

 { 0x00, 0x33, 0x33 },

 { 0x00, 0x34, 0x34 },

 { 0x00, 0x35, 0x35 },

 { 0x00, 0x36, 0x36 },

 { 0x00, 0x37, 0x37 },

 { 0x00, 0x38, 0x38 },

 { 0x00, 0x39, 0x39 },

 { 0x00, 0x3a, 0x3a },

 { 0x00, 0x3b, 0x3b },

 { 0x00, 0x3c, 0x3c },

 { 0x00, 0x3d, 0x3d },

 { 0x00, 0x3e, 0x3e },

 { 0x00, 0x3f, 0x3f },

 { 0x00, 0x40, 0x40 },

 { 0x01, 0x61, 0x41 },

 { 0x01, 0x62, 0x42 },

 { 0x01, 0x63, 0x43 },

 { 0x01, 0x64, 0x44 },

 { 0x01, 0x65, 0x45 },

 { 0x01, 0x66, 0x46 },

 { 0x01, 0x67, 0x47 },

 { 0x01, 0x68, 0x48 },

 { 0x01, 0x69, 0x49 },

 { 0x01, 0x6a, 0x4a },

 { 0x01, 0x6b, 0x4b },

 { 0x01, 0x6c, 0x4c },

 { 0x01, 0x6d, 0x4d },

 { 0x01, 0x6e, 0x4e },

 { 0x01, 0x6f, 0x4f },

 { 0x01, 0x70, 0x50 },

 { 0x01, 0x71, 0x51 },

 { 0x01, 0x72, 0x52 },

 { 0x01, 0x73, 0x53 },

 { 0x01, 0x74, 0x54 },

 { 0x01, 0x75, 0x55 },

 { 0x01, 0x76, 0x56 },

 { 0x01, 0x77, 0x57 },

 { 0x01, 0x78, 0x58 },

 { 0x01, 0x79, 0x59 },

 { 0x01, 0x7a, 0x5a },

 { 0x00, 0x5b, 0x5b },

 { 0x00, 0x5c, 0x5c },

 { 0x00, 0x5d, 0x5d },

 { 0x00, 0x5e, 0x5e },

 { 0x00, 0x5f, 0x5f },

 { 0x00, 0x60, 0x60 },

 { 0x00, 0x61, 0x41 },

 { 0x00, 0x62, 0x42 },

 { 0x00, 0x63, 0x43 },

 { 0x00, 0x64, 0x44 },

 { 0x00, 0x65, 0x45 },

 { 0x00, 0x66, 0x46 },

 { 0x00, 0x67, 0x47 },

 { 0x00, 0x68, 0x48 },

 { 0x00, 0x69, 0x49 },

 { 0x00, 0x6a, 0x4a },

 { 0x00, 0x6b, 0x4b },

 { 0x00, 0x6c, 0x4c },

 { 0x00, 0x6d, 0x4d },

 { 0x00, 0x6e, 0x4e },

 { 0x00, 0x6f, 0x4f },

 { 0x00, 0x70, 0x50 },

 { 0x00, 0x71, 0x51 },

 { 0x00, 0x72, 0x52 },

 { 0x00, 0x73, 0x53 },

 { 0x00, 0x74, 0x54 },

 { 0x00, 0x75, 0x55 },

 { 0x00, 0x76, 0x56 },

 { 0x00, 0x77, 0x57 },

 { 0x00, 0x78, 0x58 },

 { 0x00, 0x79, 0x59 },

 { 0x00, 0x7a, 0x5a },

 { 0x00, 0x7b, 0x7b },

 { 0x00, 0x7c, 0x7c },

 { 0x00, 0x7d, 0x7d },

 { 0x00, 0x7e, 0x7e },

 { 0x00, 0x7f, 0x7f },

 { 0x00, 0x80, 0x80 },

 { 0x00, 0x81, 0x81 },

 { 0x00, 0x82, 0x82 },

 { 0x00, 0x83, 0x83 },

 { 0x00, 0x84, 0x84 },

 { 0x00, 0x85, 0x85 },

 { 0x00, 0x86, 0x86 },

 { 0x00, 0x87, 0x87 },

 { 0x00, 0x88, 0x88 },

 { 0x00, 0x89, 0x89 },

 { 0x00, 0x8a, 0x8a },

 { 0x00, 0x8b, 0x8b },

 { 0x00, 0x8c, 0x8c },

 { 0x00, 0x8d, 0x8d },

 { 0x00, 0x8e, 0x8e },

 { 0x00, 0x8f, 0x8f },

 { 0x00, 0x90, 0x90 },

 { 0x00, 0x91, 0x91 },

 { 0x00, 0x92, 0x92 },

 { 0x00, 0x93, 0x93 },

 { 0x00, 0x94, 0x94 },

 { 0x00, 0x95, 0x95 },

 { 0x00, 0x96, 0x96 },

 { 0x00, 0x97, 0x97 },

 { 0x00, 0x98, 0x98 },

 { 0x00, 0x99, 0x99 },

 { 0x00, 0x9a, 0x9a },

 { 0x00, 0x9b, 0x9b },

 { 0x00, 0x9c, 0x9c },

 { 0x00, 0x9d, 0x9d },

 { 0x00, 0x9e, 0x9e },

 { 0x00, 0x9f, 0x9f },

 { 0x00, 0xa0, 0xa0 },

 { 0x00, 0xa1, 0xa1 },

 { 0x00, 0xa2, 0xa2 },

 { 0x00, 0xa3, 0xa3 },

 { 0x00, 0xa4, 0xa4 },

 { 0x00, 0xa5, 0xa5 },

 { 0x00, 0xa6, 0xa6 },

 { 0x00, 0xa7, 0xa7 },

 { 0x00, 0xa8, 0xa8 },

 { 0x00, 0xa9, 0xa9 },

 { 0x00, 0xaa, 0xaa },

 { 0x00, 0xab, 0xab },

 { 0x00, 0xac, 0xac },

 { 0x00, 0xad, 0xad },

 { 0x00, 0xae, 0xae },

 { 0x00, 0xaf, 0xaf },

 { 0x00, 0xb0, 0xb0 },

 { 0x00, 0xb1, 0xb1 },

 { 0x00, 0xb2, 0xb2 },

 { 0x00, 0xb3, 0xb3 },

 { 0x00, 0xb4, 0xb4 },

 { 0x00, 0xb5, 0xb5 },

 { 0x00, 0xb6, 0xb6 },

 { 0x00, 0xb7, 0xb7 },

 { 0x00, 0xb8, 0xb8 },

 { 0x00, 0xb9, 0xb9 },

 { 0x00, 0xba, 0xba },

 { 0x00, 0xbb, 0xbb },

 { 0x00, 0xbc, 0xbc },

 { 0x00, 0xbd, 0xbd },

 { 0x00, 0xbe, 0xbe },

 { 0x00, 0xbf, 0xbf },

 { 0x00, 0xc0, 0xc0 },

 { 0x00, 0xc1, 0xc1 },

 { 0x00, 0xc2, 0xc2 },

 { 0x00, 0xc3, 0xc3 },

 { 0x00, 0xc4, 0xc4 },

 { 0x00, 0xc5, 0xc5 },

 { 0x00, 0xc6, 0xc6 },

 { 0x00, 0xc7, 0xc7 },

 { 0x00, 0xc8, 0xc8 },

 { 0x00, 0xc9, 0xc9 },

 { 0x00, 0xca, 0xca },

 { 0x00, 0xcb, 0xcb },

 { 0x00, 0xcc, 0xcc },

 { 0x00, 0xcd, 0xcd },

 { 0x00, 0xce, 0xce },

 { 0x00, 0xcf, 0xcf },

 { 0x00, 0xd0, 0xd0 },

 { 0x00, 0xd1, 0xd1 },

 { 0x00, 0xd2, 0xd2 },

 { 0x00, 0xd3, 0xd3 },

 { 0x00, 0xd4, 0xd4 },

 { 0x00, 0xd5, 0xd5 },

 { 0x00, 0xd6, 0xd6 },

 { 0x00, 0xd7, 0xd7 },

 { 0x00, 0xd8, 0xd8 },

 { 0x00, 0xd9, 0xd9 },

 { 0x00, 0xda, 0xda },

 { 0x00, 0xdb, 0xdb },

 { 0x00, 0xdc, 0xdc },

 { 0x00, 0xdd, 0xdd },

 { 0x00, 0xde, 0xde },

 { 0x00, 0xdf, 0xdf },

 { 0x00, 0xe0, 0xe0 },

 { 0x00, 0xe1, 0xe1 },

 { 0x00, 0xe2, 0xe2 },

 { 0x00, 0xe3, 0xe3 },

 { 0x00, 0xe4, 0xe4 },

 { 0x00, 0xe5, 0xe5 },

 { 0x00, 0xe6, 0xe6 },

 { 0x00, 0xe7, 0xe7 },

 { 0x00, 0xe8, 0xe8 },

 { 0x00, 0xe9, 0xe9 },

 { 0x00, 0xea, 0xea },

 { 0x00, 0xeb, 0xeb },

 { 0x00, 0xec, 0xec },

 { 0x00, 0xed, 0xed },

 { 0x00, 0xee, 0xee },

 { 0x00, 0xef, 0xef },

 { 0x00, 0xf0, 0xf0 },

 { 0x00, 0xf1, 0xf1 },

 { 0x00, 0xf2, 0xf2 },

 { 0x00, 0xf3, 0xf3 },

 { 0x00, 0xf4, 0xf4 },

 { 0x00, 0xf5, 0xf5 },

 { 0x00, 0xf6, 0xf6 },

 { 0x00, 0xf7, 0xf7 },

 { 0x00, 0xf8, 0xf8 },

 { 0x00, 0xf9, 0xf9 },

 { 0x00, 0xfa, 0xfa },

 { 0x00, 0xfb, 0xfb },

 { 0x00, 0xfc, 0xfc },

 { 0x00, 0xfd, 0xfd },

 { 0x00, 0xfe, 0xfe },

 { 0x00, 0xff, 0xff }

 };

 static struct cs_info iso7_tbl[] = {

 { 0x00, 0x00, 0x00 },

 { 0x00, 0x01, 0x01 },

 { 0x00, 0x02, 0x02 },

 { 0x00, 0x03, 0x03 },

 { 0x00, 0x04, 0x04 },

 { 0x00, 0x05, 0x05 },

 { 0x00, 0x06, 0x06 },

 { 0x00, 0x07, 0x07 },

 { 0x00, 0x08, 0x08 },

 { 0x00, 0x09, 0x09 },

 { 0x00, 0x0a, 0x0a },

 { 0x00, 0x0b, 0x0b },

 { 0x00, 0x0c, 0x0c },

 { 0x00, 0x0d, 0x0d },

 { 0x00, 0x0e, 0x0e },

 { 0x00, 0x0f, 0x0f },

 { 0x00, 0x10, 0x10 },

 { 0x00, 0x11, 0x11 },

 { 0x00, 0x12, 0x12 },

 { 0x00, 0x13, 0x13 },

 { 0x00, 0x14, 0x14 },

 { 0x00, 0x15, 0x15 },

 { 0x00, 0x16, 0x16 },

 { 0x00, 0x17, 0x17 },

 { 0x00, 0x18, 0x18 },

 { 0x00, 0x19, 0x19 },

 { 0x00, 0x1a, 0x1a },

 { 0x00, 0x1b, 0x1b },

 { 0x00, 0x1c, 0x1c },

 { 0x00, 0x1d, 0x1d },

 { 0x00, 0x1e, 0x1e },

 { 0x00, 0x1f, 0x1f },

 { 0x00, 0x20, 0x20 },

 { 0x00, 0x21, 0x21 },

 { 0x00, 0x22, 0x22 },

 { 0x00, 0x23, 0x23 },

 { 0x00, 0x24, 0x24 },

 { 0x00, 0x25, 0x25 },

 { 0x00, 0x26, 0x26 },

 { 0x00, 0x27, 0x27 },

 { 0x00, 0x28, 0x28 },

 { 0x00, 0x29, 0x29 },

 { 0x00, 0x2a, 0x2a },

 { 0x00, 0x2b, 0x2b },

 { 0x00, 0x2c, 0x2c },

 { 0x00, 0x2d, 0x2d },

 { 0x00, 0x2e, 0x2e },

 { 0x00, 0x2f, 0x2f },

 { 0x00, 0x30, 0x30 },

 { 0x00, 0x31, 0x31 },

 { 0x00, 0x32, 0x32 },

 { 0x00, 0x33, 0x33 },

 { 0x00, 0x34, 0x34 },

 { 0x00, 0x35, 0x35 },

 { 0x00, 0x36, 0x36 },

 { 0x00, 0x37, 0x37 },

 { 0x00, 0x38, 0x38 },

 { 0x00, 0x39, 0x39 },

 { 0x00, 0x3a, 0x3a },

 { 0x00, 0x3b, 0x3b },

 { 0x00, 0x3c, 0x3c },

 { 0x00, 0x3d, 0x3d },

 { 0x00, 0x3e, 0x3e },

 { 0x00, 0x3f, 0x3f },

 { 0x00, 0x40, 0x40 },

 { 0x01, 0x61, 0x41 },

 { 0x01, 0x62, 0x42 },

 { 0x01, 0x63, 0x43 },

 { 0x01, 0x64, 0x44 },

 { 0x01, 0x65, 0x45 },

 { 0x01, 0x66, 0x46 },

 { 0x01, 0x67, 0x47 },

 { 0x01, 0x68, 0x48 },

 { 0x01, 0x69, 0x49 },

 { 0x01, 0x6a, 0x4a },

 { 0x01, 0x6b, 0x4b },

 { 0x01, 0x6c, 0x4c },

 { 0x01, 0x6d, 0x4d },

 { 0x01, 0x6e, 0x4e },

 { 0x01, 0x6f, 0x4f },

 { 0x01, 0x70, 0x50 },

 { 0x01, 0x71, 0x51 },

 { 0x01, 0x72, 0x52 },

 { 0x01, 0x73, 0x53 },

 { 0x01, 0x74, 0x54 },

 { 0x01, 0x75, 0x55 },

 { 0x01, 0x76, 0x56 },

 { 0x01, 0x77, 0x57 },

 { 0x01, 0x78, 0x58 },

 { 0x01, 0x79, 0x59 },

 { 0x01, 0x7a, 0x5a },

 { 0x00, 0x5b, 0x5b },

 { 0x00, 0x5c, 0x5c },

 { 0x00, 0x5d, 0x5d },

 { 0x00, 0x5e, 0x5e },

 { 0x00, 0x5f, 0x5f },

 { 0x00, 0x60, 0x60 },

 { 0x00, 0x61, 0x41 },

 { 0x00, 0x62, 0x42 },

 { 0x00, 0x63, 0x43 },

 { 0x00, 0x64, 0x44 },

 { 0x00, 0x65, 0x45 },

 { 0x00, 0x66, 0x46 },

 { 0x00, 0x67, 0x47 },

 { 0x00, 0x68, 0x48 },

 { 0x00, 0x69, 0x49 },

 { 0x00, 0x6a, 0x4a },

 { 0x00, 0x6b, 0x4b },

 { 0x00, 0x6c, 0x4c },

 { 0x00, 0x6d, 0x4d },

 { 0x00, 0x6e, 0x4e },

 { 0x00, 0x6f, 0x4f },

 { 0x00, 0x70, 0x50 },

 { 0x00, 0x71, 0x51 },

 { 0x00, 0x72, 0x52 },

 { 0x00, 0x73, 0x53 },

 { 0x00, 0x74, 0x54 },

 { 0x00, 0x75, 0x55 },

 { 0x00, 0x76, 0x56 },

 { 0x00, 0x77, 0x57 },

 { 0x00, 0x78, 0x58 },

 { 0x00, 0x79, 0x59 },

 { 0x00, 0x7a, 0x5a },

 { 0x00, 0x7b, 0x7b },

 { 0x00, 0x7c, 0x7c },

 { 0x00, 0x7d, 0x7d },

 { 0x00, 0x7e, 0x7e },

 { 0x00, 0x7f, 0x7f },

 { 0x00, 0x80, 0x80 },

 { 0x00, 0x81, 0x81 },

 { 0x00, 0x82, 0x82 },

 { 0x00, 0x83, 0x83 },

 { 0x00, 0x84, 0x84 },

 { 0x00, 0x85, 0x85 },

 { 0x00, 0x86, 0x86 },

 { 0x00, 0x87, 0x87 },

 { 0x00, 0x88, 0x88 },

 { 0x00, 0x89, 0x89 },

 { 0x00, 0x8a, 0x8a },

 { 0x00, 0x8b, 0x8b },

 { 0x00, 0x8c, 0x8c },

 { 0x00, 0x8d, 0x8d },

 { 0x00, 0x8e, 0x8e },

 { 0x00, 0x8f, 0x8f },

 { 0x00, 0x90, 0x90 },

 { 0x00, 0x91, 0x91 },

 { 0x00, 0x92, 0x92 },

 { 0x00, 0x93, 0x93 },

 { 0x00, 0x94, 0x94 },

 { 0x00, 0x95, 0x95 },

 { 0x00, 0x96, 0x96 },

 { 0x00, 0x97, 0x97 },

 { 0x00, 0x98, 0x98 },

 { 0x00, 0x99, 0x99 },

 { 0x00, 0x9a, 0x9a },

 { 0x00, 0x9b, 0x9b },

 { 0x00, 0x9c, 0x9c },

 { 0x00, 0x9d, 0x9d },

 { 0x00, 0x9e, 0x9e },

 { 0x00, 0x9f, 0x9f },

 { 0x00, 0xa0, 0xa0 },

 { 0x00, 0xa1, 0xa1 },

 { 0x00, 0xa2, 0xa2 },

 { 0x00, 0xa3, 0xa3 },

 { 0x00, 0xa4, 0xa4 },

 { 0x00, 0xa5, 0xa5 },

 { 0x00, 0xa6, 0xa6 },

 { 0x00, 0xa7, 0xa7 },

 { 0x00, 0xa8, 0xa8 },

 { 0x00, 0xa9, 0xa9 },

 { 0x00, 0xaa, 0xaa },

 { 0x00, 0xab, 0xab },

 { 0x00, 0xac, 0xac },

 { 0x00, 0xad, 0xad },

 { 0x00, 0xae, 0xae },

 { 0x00, 0xaf, 0xaf },

 { 0x00, 0xb0, 0xb0 },

 { 0x00, 0xb1, 0xb1 },

 { 0x00, 0xb2, 0xb2 },

 { 0x00, 0xb3, 0xb3 },

 { 0x00, 0xb4, 0xb4 },

 { 0x00, 0xb5, 0xb5 },

 { 0x01, 0xdc, 0xb6 },

 { 0x00, 0xb7, 0xb7 },

 { 0x01, 0xdd, 0xb8 },

 { 0x01, 0xde, 0xb9 },

 { 0x01, 0xdf, 0xba },

 { 0x00, 0xbb, 0xbb },

 { 0x01, 0xfc, 0xbc },

 { 0x00, 0xbd, 0xbd },

 { 0x01, 0xfd, 0xbe },

 { 0x01, 0xfe, 0xbf },

 { 0x00, 0xc0, 0xc0 },

 { 0x01, 0xe1, 0xc1 },

 { 0x01, 0xe2, 0xc2 },

 { 0x01, 0xe3, 0xc3 },

 { 0x01, 0xe4, 0xc4 },

 { 0x01, 0xe5, 0xc5 },

 { 0x01, 0xe6, 0xc6 },

 { 0x01, 0xe7, 0xc7 },

 { 0x01, 0xe8, 0xc8 },

 { 0x01, 0xe9, 0xc9 },

 { 0x01, 0xea, 0xca },

 { 0x01, 0xeb, 0xcb },

 { 0x01, 0xec, 0xcc },

 { 0x01, 0xed, 0xcd },

 { 0x01, 0xee, 0xce },

 { 0x01, 0xef, 0xcf },

 { 0x01, 0xf0, 0xd0 },

 { 0x01, 0xf1, 0xd1 },

 { 0x00, 0xd2, 0xd2 },

 { 0x01, 0xf3, 0xd3 },

 { 0x01, 0xf4, 0xd4 },

 { 0x01, 0xf5, 0xd5 },

 { 0x01, 0xf6, 0xd6 },

 { 0x01, 0xf7, 0xd7 },

 { 0x01, 0xf8, 0xd8 },

 { 0x01, 0xf9, 0xd9 },

 { 0x01, 0xfa, 0xda },

 { 0x01, 0xfb, 0xdb },

 { 0x00, 0xdc, 0xb6 },

 { 0x00, 0xdd, 0xb8 },

 { 0x00, 0xde, 0xb9 },

 { 0x00, 0xdf, 0xba },

 { 0x00, 0xe0, 0xe0 },

 { 0x00, 0xe1, 0xc1 },

 { 0x00, 0xe2, 0xc2 },

 { 0x00, 0xe3, 0xc3 },

 { 0x00, 0xe4, 0xc4 },

 { 0x00, 0xe5, 0xc5 },

 { 0x00, 0xe6, 0xc6 },

 { 0x00, 0xe7, 0xc7 },

 { 0x00, 0xe8, 0xc8 },

 { 0x00, 0xe9, 0xc9 },

 { 0x00, 0xea, 0xca },

 { 0x00, 0xeb, 0xcb },

 { 0x00, 0xec, 0xcc },

 { 0x00, 0xed, 0xcd },

 { 0x00, 0xee, 0xce },

 { 0x00, 0xef, 0xcf },

 { 0x00, 0xf0, 0xd0 },

 { 0x00, 0xf1, 0xd1 },

 { 0x00, 0xf2, 0xd3 },

 { 0x00, 0xf3, 0xd3 },

 { 0x00, 0xf4, 0xd4 },

 { 0x00, 0xf5, 0xd5 },

 { 0x00, 0xf6, 0xd6 },

 { 0x00, 0xf7, 0xd7 },

 { 0x00, 0xf8, 0xd8 },

 { 0x00, 0xf9, 0xd9 },

 { 0x00, 0xfa, 0xda },

 { 0x00, 0xfb, 0xdb },

 { 0x00, 0xfc, 0xbc },

 { 0x00, 0xfd, 0xbe },

 { 0x00, 0xfe, 0xbf },

 { 0x00, 0xff, 0xff }

 };

 static struct cs_info iso8_tbl[] = {

 { 0x00, 0x00, 0x00 },

 { 0x00, 0x01, 0x01 },

 { 0x00, 0x02, 0x02 },

 { 0x00, 0x03, 0x03 },

 { 0x00, 0x04, 0x04 },

 { 0x00, 0x05, 0x05 },

 { 0x00, 0x06, 0x06 },

 { 0x00, 0x07, 0x07 },

 { 0x00, 0x08, 0x08 },

 { 0x00, 0x09, 0x09 },

 { 0x00, 0x0a, 0x0a },

 { 0x00, 0x0b, 0x0b },

 { 0x00, 0x0c, 0x0c },

 { 0x00, 0x0d, 0x0d },

 { 0x00, 0x0e, 0x0e },

 { 0x00, 0x0f, 0x0f },

 { 0x00, 0x10, 0x10 },

 { 0x00, 0x11, 0x11 },

 { 0x00, 0x12, 0x12 },

 { 0x00, 0x13, 0x13 },

 { 0x00, 0x14, 0x14 },

 { 0x00, 0x15, 0x15 },

 { 0x00, 0x16, 0x16 },

 { 0x00, 0x17, 0x17 },

 { 0x00, 0x18, 0x18 },

 { 0x00, 0x19, 0x19 },

 { 0x00, 0x1a, 0x1a },

 { 0x00, 0x1b, 0x1b },

 { 0x00, 0x1c, 0x1c },

 { 0x00, 0x1d, 0x1d },

 { 0x00, 0x1e, 0x1e },

 { 0x00, 0x1f, 0x1f },

 { 0x00, 0x20, 0x20 },

 { 0x00, 0x21, 0x21 },

 { 0x00, 0x22, 0x22 },

 { 0x00, 0x23, 0x23 },

 { 0x00, 0x24, 0x24 },

 { 0x00, 0x25, 0x25 },

 { 0x00, 0x26, 0x26 },

 { 0x00, 0x27, 0x27 },

 { 0x00, 0x28, 0x28 },

 { 0x00, 0x29, 0x29 },

 { 0x00, 0x2a, 0x2a },

 { 0x00, 0x2b, 0x2b },

 { 0x00, 0x2c, 0x2c },

 { 0x00, 0x2d, 0x2d },

 { 0x00, 0x2e, 0x2e },

 { 0x00, 0x2f, 0x2f },

 { 0x00, 0x30, 0x30 },

 { 0x00, 0x31, 0x31 },

 { 0x00, 0x32, 0x32 },

 { 0x00, 0x33, 0x33 },

 { 0x00, 0x34, 0x34 },