home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 25 / CDROM25.iso / Share / prog / VJ11 / VJTRIAL.EXE / IE30Java.exe / classd.exe / java / lang / Character.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-01-27  |  10.6 KB  |  615 lines
  1. package java.lang;
  2.  
  3. public final class Character {
  4.    public static final int MIN_RADIX = 2;
  5.    public static final int MAX_RADIX = 36;
  6.    public static final char MIN_VALUE = '\u0000';
  7.    public static final char MAX_VALUE = '\uffff';
  8.    private static long[] isLowerCaseTable = new long[]{0L, 576460743713488896L, 0L, -36028799166447616L, 6172933889249159850L, -3122495741643543723L, 2761033308231184681L, -6329340151129091520L, 11184810L, -22522413363298304L, 2170637221884L, 0L, 0L, 0L, -17592185978880L, 1032063467880447L, -281474976710656L, -6148914690341797889L, -6148914691236560894L, 156089602710049044L, 0L, -8589934592L, 255L, 0L, -6148914691236517206L, -6148914691236517206L, -6148914693967009110L, 192153584101141162L, 71777214282006783L, 4611405638684049471L, 62770015039848703L, 61925590106570972L};
  9.    private static long[] isUpperCaseTable = new long[]{0L, 134217726L, 0L, 2139095039L, -6172933889249159851L, 3122495741643543722L, 1274187284968361686L, 6057998273580016784L, 5592405L, 0L, 0L, 0L, 0L, 0L, 17575006099264L, 93819265613824L, 281474976702462L, 6148914689804861440L, 6148914691236495361L, 78044801355024522L, -562949953421312L, 8388607L, 0L, 0L, 6148914691236517205L, 6148914691236517205L, 6148914689806259541L, 96076792050570581L, -71777217515815168L, 280378317225728L, 2234065794919104256L, 2233819500287893248L};
  10.    private static long[] isDefinedTable01C0through06FF = new long[]{-270215977642229761L, 16777215L, -65536L, -279275953455105L, 4395899027455L, -1L, 4913427206346113087L, -17179879440L, 4503588160110591L, -8194L, -536936449L, -65409L, 234134404065073567L, -562949953421312L, -4320133121L, -288511851128421633L, 8734520370987023L, 576460745995194368L, -211110526976001L, 9007199254740991999L, 288019269919145983L};
  11.    private static long[] isDefinedTable0900through0EFF = new long[]{-864691128455135250L, 562949938692095L, -3186861885341720594L, 576460544811219359L, -3211631683292264476L, 9006925953907079L, -869759877059465234L, 281204393851839L, -878767076314341394L, 562690925803919L, -4341532606274353172L, 2251250066275783L, -4327961440926441490L, 281212990012895L, -4327961440926441492L, 281214063754719L, -4323457841299070996L, 281212992110031L, 0L, 0L, -8646911284551352322L, 268435455L, 4323434403644581270L, 872365919L};
  12.    private static long[] isDefinedTable1080through11FF = new long[]{-4294967296L, 612489549322321983L, -1L, -2080374785L, -1065151889409L, 288230376151711743L};
  13.    private static long[] isDefinedTable1E00through27BF = new long[]{-1L, -1L, -4160749569L, 288230376151711743L, -3233808385L, 4611686017001275199L, -9007199254740993L, 9213520412398321631L, -140737488355329L, -3945047720460161L, 8791798087679L, 17179803648L, 144115188075855871L, -524288L, -65529L, 8796093022207L, -1L, -1L, -1L, 1125899906842623L, -3L, 576460752303423487L, 0L, 0L, 137438953471L, -4294965249L, -1L, 8796093022207L, -1L, -1L, -4290772993L, 281474976710655L, -66060289L, 281474976710655L, 0L, 0L, -1099511630882L, -18013305452384257L, 9223090561863385087L};
  14.    private static long[] isDefinedTable3000through33FF = new long[]{-9151314442816847873L, -2L, -6473908225L, Long.MAX_VALUE, -527765581332512L, -1L, 4294934527L, 0L, -3758096385L, -8070450536542896113L, 562949953421311L, 9223372036854714367L, -1L, -540431955284459521L, -1L, 9223372033633550335L};
  15.    private static long[] isDefinedTableFB00throughFFFF = new long[]{6881500229564629119L, -37L, 1125899906842623L, -524288L, -1L, -1L, -1L, -1L, -1L, -65536L, -196609L, 1152640029630136575L, -281410552201216L, -11523431615431137L, -1L, -6917529027641081857L, -2L, -6442450945L, Long.MAX_VALUE, 2305983193137609980L};
  16.    private static long[] isLetterTable0000through06FF = new long[]{0L, 576460743847706622L, 0L, -36028797027352577L, -1L, -1L, -1L, -270215977642229761L, 16777215L, -65536L, -279275953455105L, 4395899027455L, -1L, 4913427206346113087L, -17179879440L, 4503588160110591L, -8194L, -536936449L, -65409L, 234134404065073567L, -562949953421312L, -4320133121L, -288511851128421633L, 8734520370987023L, 576460745995194368L, -215504278519809L, 9007199254740991999L, 70368744144895L};
  17.    private static long[] isLetterTable0900through0EFF = new long[]{-864691128455135250L, 281749839888383L, -3186861885341720594L, 576179344712415647L, -3211631683292264476L, 8725725855103367L, -869759877059465234L, 4295048127L, -878767076314341394L, 281490827000207L, -4341532606274353172L, 1970324845379015L, -4327961440926441490L, 12891209183L, -4327961440926441492L, 13964951007L, -4323457841299070996L, 12893306319L, 0L, 0L, -8646911284551352322L, 201392127L, 4323434403644581270L, 805322591L};
  18.    private static long[] isLetterTable1080through11FF;
  19.    private static long[] isLetterTable1E00through1FFF;
  20.    private static long[] isLetterTable3000through33FF;
  21.    private static long[] isLetterTableFB00throughFFFF;
  22.    private static long[] isLDTable0000through06FF;
  23.    private static long[] isLDTable0900through0EFF;
  24.    private static long[] isLDTable1080through11FF;
  25.    private static long[] isLDTable1E00through1FFF;
  26.    private static long[] isLDTable3000through33FF;
  27.    private static long[] isLDTableFB00throughFFFF;
  28.    private static long[] toLowerCaseTable;
  29.    private static long[] toUpperCaseTable;
  30.    private char value;
  31.  
  32.    public String toString() {
  33.       char[] var1 = new char[]{this.value};
  34.       return String.valueOf(var1);
  35.    }
  36.  
  37.    public static boolean isJavaLetterOrDigit(char var0) {
  38.       return isLetterOrDigit(var0) || var0 == '$' || var0 == '_';
  39.    }
  40.  
  41.    public static boolean isLowerCase(char var0) {
  42.       return ((var0 < 1536 ? isLowerCaseTable[var0 >> 6] : ((var0 & '∩╕Ç') == 7680 ? isLowerCaseTable[var0 - 6144 >> 6] : ((var0 & '\uffc0') == 64256 ? 16253055L : ((var0 & '\uffc0') == 65344 ? 134217726L : 0L)))) >> (var0 & 63) & 1L) != 0L;
  43.    }
  44.  
  45.    public static boolean isUpperCase(char var0) {
  46.       return ((var0 < 1536 ? isUpperCaseTable[var0 >> 6] : ((var0 & '∩╕Ç') == 7680 ? isUpperCaseTable[var0 - 6144 >> 6] : (var0 >= 4256 && var0 <= 4303 ? -4294967233L : ((var0 & '\uffc0') == 65280 ? 576460743713488896L : 0L)))) >> (var0 & 63) & 1L) != 0L;
  47.    }
  48.  
  49.    public static boolean isTitleCase(char var0) {
  50.       return var0 == 453 || var0 == 456 || var0 == 459 || var0 == 498;
  51.    }
  52.  
  53.    public static char toLowerCase(char var0) {
  54.       if (var0 >= 65 && var0 <= 90) {
  55.          return (char)(var0 + 32);
  56.       } else if (var0 < 192) {
  57.          return (char)var0;
  58.       } else if (var0 < 256) {
  59.          if (var0 >= 223) {
  60.             return (char)var0;
  61.          } else {
  62.             return (char)(var0 == 215 ? var0 : (char)(var0 + 32));
  63.          }
  64.       } else {
  65.          if (((var0 < 1536 ? toLowerCaseTable[var0 - 256 >> 6] : ((var0 & '∩╕Ç') == 7680 ? toLowerCaseTable[var0 - 6400 >> 6] : (var0 >= 4256 && var0 <= 4293 ? -4294967233L : ((var0 & '\uffc0') == 8512 ? 281470681743360L : (var0 >= 9398 && var0 <= 9423 ? -18014398509416449L : ((var0 & '\uffc0') == 65280 ? 576460743713488896L : 0L)))))) >> (var0 & 63) & 1L) != 0L) {
  66.             switch (var0 >> 8) {
  67.                case 1:
  68.                   switch (var0 & 255) {
  69.                      case 120:
  70.                         return '├┐';
  71.                      case 129:
  72.                         return '╔ô';
  73.                      case 134:
  74.                         return '╔ö';
  75.                      case 138:
  76.                         return '╔ù';
  77.                      case 142:
  78.                         return '╔ÿ';
  79.                      case 143:
  80.                         return '╔Ö';
  81.                      case 144:
  82.                         return '╔¢';
  83.                      case 147:
  84.                         return '╔á';
  85.                      case 148:
  86.                         return '╔ú';
  87.                      case 150:
  88.                         return '╔⌐';
  89.                      case 151:
  90.                         return '╔¿';
  91.                      case 156:
  92.                         return '╔»';
  93.                      case 157:
  94.                         return '╔▓';
  95.                      case 169:
  96.                         return '╩â';
  97.                      case 174:
  98.                         return '╩ê';
  99.                      case 177:
  100.                         return '╩è';
  101.                      case 178:
  102.                         return '╩ï';
  103.                      case 183:
  104.                         return '╩Æ';
  105.                      case 196:
  106.                         return '╟å';
  107.                      case 199:
  108.                         return '╟ë';
  109.                      case 202:
  110.                         return '╟î';
  111.                      case 241:
  112.                         return '╟│';
  113.                      default:
  114.                         return (char)(var0 + 1);
  115.                   }
  116.                case 2:
  117.                   return (char)(var0 + 1);
  118.                case 3:
  119.                   switch (var0 & 255) {
  120.                      case 134:
  121.                         return '╬¼';
  122.                      case 135:
  123.                      case 139:
  124.                      case 141:
  125.                      default:
  126.                         if (var0 < 944) {
  127.                            return (char)(var0 + 32);
  128.                         }
  129.  
  130.                         return (char)(var0 + 1);
  131.                      case 136:
  132.                         return '╬¡';
  133.                      case 137:
  134.                         return '╬«';
  135.                      case 138:
  136.                         return '╬»';
  137.                      case 140:
  138.                         return '╧î';
  139.                      case 142:
  140.                         return '╧ì';
  141.                      case 143:
  142.                         return '╧Ä';
  143.                   }
  144.                case 4:
  145.                   if (var0 < 1040) {
  146.                      return (char)(var0 + 80);
  147.                   }
  148.  
  149.                   if (var0 < 1120) {
  150.                      return (char)(var0 + 32);
  151.                   }
  152.  
  153.                   return (char)(var0 + 1);
  154.                case 5:
  155.                case 16:
  156.                   return (char)(var0 + 48);
  157.                case 30:
  158.                   return (char)(var0 + 1);
  159.                case 31:
  160.                   switch (var0 & 255) {
  161.                      case 186:
  162.                         return 'ß╜░';
  163.                      case 187:
  164.                         return 'ß╜▒';
  165.                      case 188:
  166.                         return 'ß╛│';
  167.                      case 200:
  168.                         return 'ß╜▓';
  169.                      case 201:
  170.                         return 'ß╜│';
  171.                      case 202:
  172.                         return 'ß╜┤';
  173.                      case 203:
  174.                         return 'ß╜╡';
  175.                      case 204:
  176.                         return 'ß┐â';
  177.                      case 218:
  178.                         return 'ß╜╢';
  179.                      case 219:
  180.                         return 'ß╜╖';
  181.                      case 234:
  182.                         return 'ß╜║';
  183.                      case 235:
  184.                         return 'ß╜╗';
  185.                      case 236:
  186.                         return 'ß┐Ñ';
  187.                      case 248:
  188.                         return 'ß╜╕';
  189.                      case 249:
  190.                         return 'ß╜╣';
  191.                      case 250:
  192.                         return 'ß╜╝';
  193.                      case 251:
  194.                         return 'ß╜╜';
  195.                      case 252:
  196.                         return 'ß┐│';
  197.                      default:
  198.                         return (char)(var0 - 8);
  199.                   }
  200.                case 33:
  201.                   return (char)(var0 + 16);
  202.                case 36:
  203.                   return (char)(var0 + 26);
  204.                case 255:
  205.                   return (char)(var0 + 32);
  206.             }
  207.          }
  208.  
  209.          return (char)var0;
  210.       }
  211.    }
  212.  
  213.    public static char toUpperCase(char var0) {
  214.       if (var0 >= 97 && var0 <= 122) {
  215.          return (char)(var0 + -32);
  216.       } else if (var0 < 224) {
  217.          return (char)var0;
  218.       } else if (var0 < 256) {
  219.          if (var0 == 247) {
  220.             return (char)var0;
  221.          } else {
  222.             return var0 == 255 ? '┼╕' : (char)(var0 - 32);
  223.          }
  224.       } else {
  225.          if (((var0 < 1536 ? toUpperCaseTable[var0 - 256 >> 6] : ((var0 & '∩╕Ç') == 7680 ? toUpperCaseTable[var0 - 6400 >> 6] : ((var0 & '\uffc0') == 8512 ? -281474976710656L : ((var0 & '\uffc0') == 9408 ? 4398046445568L : ((var0 & '\uffc0') == 65344 ? 134217726L : 0L))))) >> (var0 & 63) & 1L) != 0L) {
  226.             switch (var0 >> 8) {
  227.                case 1:
  228.                   if (var0 == 383) {
  229.                      return 'S';
  230.                   }
  231.  
  232.                   if (var0 != 454 && var0 != 457 && var0 != 460 && var0 != 499) {
  233.                      return (char)(var0 - 1);
  234.                   }
  235.  
  236.                   return (char)(var0 - 2);
  237.                case 2:
  238.                   if (var0 < 576) {
  239.                      return (char)(var0 - 1);
  240.                   }
  241.  
  242.                   switch (var0 & 255) {
  243.                      case 83:
  244.                         return '╞ü';
  245.                      case 84:
  246.                         return '╞å';
  247.                      case 87:
  248.                         return '╞è';
  249.                      case 88:
  250.                         return '╞Ä';
  251.                      case 89:
  252.                         return '╞Å';
  253.                      case 91:
  254.                         return '╞É';
  255.                      case 96:
  256.                         return '╞ô';
  257.                      case 99:
  258.                         return '╞ö';
  259.                      case 104:
  260.                         return '╞ù';
  261.                      case 105:
  262.                         return '╞û';
  263.                      case 111:
  264.                         return '╞£';
  265.                      case 114:
  266.                         return '╞¥';
  267.                      case 131:
  268.                         return '╞⌐';
  269.                      case 136:
  270.                         return '╞«';
  271.                      case 138:
  272.                         return '╞▒';
  273.                      case 139:
  274.                         return '╞▓';
  275.                      case 146:
  276.                         return '╞╖';
  277.                      default:
  278.                         return (char)var0;
  279.                   }
  280.                case 3:
  281.                   switch (var0 & 255) {
  282.                      case 172:
  283.                         return '╬å';
  284.                      case 173:
  285.                         return '╬ê';
  286.                      case 174:
  287.                         return '╬ë';
  288.                      case 175:
  289.                         return '╬è';
  290.                      case 194:
  291.                         return '╬ú';
  292.                      case 204:
  293.                         return '╬î';
  294.                      case 205:
  295.                         return '╬Ä';
  296.                      case 206:
  297.                         return '╬Å';
  298.                      case 208:
  299.                         return '╬Æ';
  300.                      case 209:
  301.                         return '╬ÿ';
  302.                      case 213:
  303.                         return '╬ª';
  304.                      case 214:
  305.                         return '╬á';
  306.                      case 240:
  307.                         return '╬Ü';
  308.                      case 241:
  309.                         return '╬í';
  310.                      default:
  311.                         if (var0 < 992) {
  312.                            return (char)(var0 - 32);
  313.                         }
  314.  
  315.                         return (char)(var0 - 1);
  316.                   }
  317.                case 4:
  318.                   if (var0 < 1104) {
  319.                      return (char)(var0 - 32);
  320.                   }
  321.  
  322.                   if (var0 < 1120) {
  323.                      return (char)(var0 - 80);
  324.                   }
  325.  
  326.                   return (char)(var0 - 1);
  327.                case 5:
  328.                   return (char)(var0 - 48);
  329.                case 30:
  330.                   return (char)(var0 - 1);
  331.                case 31:
  332.                   switch (var0 & 255) {
  333.                      case 112:
  334.                         return 'ß╛║';
  335.                      case 113:
  336.                         return 'ß╛╗';
  337.                      case 114:
  338.                         return 'ß┐ê';
  339.                      case 115:
  340.                         return 'ß┐ë';
  341.                      case 116:
  342.                         return 'ß┐è';
  343.                      case 117:
  344.                         return 'ß┐ï';
  345.                      case 118:
  346.                         return 'ß┐Ü';
  347.                      case 119:
  348.                         return 'ß┐¢';
  349.                      case 120:
  350.                         return 'ß┐╕';
  351.                      case 121:
  352.                         return 'ß┐╣';
  353.                      case 122:
  354.                         return 'ß┐¬';
  355.                      case 123:
  356.                         return 'ß┐½';
  357.                      case 124:
  358.                         return 'ß┐║';
  359.                      case 125:
  360.                         return 'ß┐╗';
  361.                      case 179:
  362.                         return 'ß╛╝';
  363.                      case 195:
  364.                         return 'ß┐î';
  365.                      case 229:
  366.                         return 'ß┐¼';
  367.                      case 243:
  368.                         return 'ß┐╝';
  369.                      default:
  370.                         return (char)(var0 + 8);
  371.                   }
  372.                case 33:
  373.                   return (char)(var0 - 16);
  374.                case 36:
  375.                   return (char)(var0 - 26);
  376.                case 255:
  377.                   return (char)(var0 - 32);
  378.             }
  379.          }
  380.  
  381.          return (char)var0;
  382.       }
  383.    }
  384.  
  385.    public static char toTitleCase(char var0) {
  386.       if ((var0 & '\uffc0') != 448) {
  387.          return toUpperCase(var0);
  388.       } else if (var0 >= 452 && var0 <= 454) {
  389.          return '╟à';
  390.       } else if (var0 >= 455 && var0 <= 457) {
  391.          return '╟ê';
  392.       } else if (var0 >= 458 && var0 <= 460) {
  393.          return '╟ï';
  394.       } else {
  395.          return var0 >= 497 && var0 <= 499 ? '╟▓' : toUpperCase(var0);
  396.       }
  397.    }
  398.  
  399.    public boolean equals(Object var1) {
  400.       if (var1 != null && var1 instanceof Character) {
  401.          return this.value == (Character)var1;
  402.       } else {
  403.          return false;
  404.       }
  405.    }
  406.  
  407.    static {
  408.       isLetterTable1080through11FF = isDefinedTable1080through11FF;
  409.       isLetterTable1E00through1FFF = isDefinedTable1E00through27BF;
  410.       isLetterTable3000through33FF = isDefinedTable3000through33FF;
  411.       isLetterTableFB00throughFFFF = new long[]{6881500229564629119L, -37L, 1125899906842623L, -524288L, -1L, -1L, -1L, -1L, -1L, -65536L, -196609L, 1152640029630136575L, 0L, -11540474045136896L, -1L, 2305843009213693951L, 576460743713488896L, -274743689218L, Long.MAX_VALUE, 486341884L};
  412.       isLDTable0000through06FF = new long[]{287948901175001088L, 576460743847706622L, 0L, -36028797027352577L, -1L, -1L, -1L, -270215977642229761L, 16777215L, -65536L, -279275953455105L, 4395899027455L, -1L, 4913427206346113087L, -17179879440L, 4503588160110591L, -8194L, -536936449L, -65409L, 234134404065073567L, -562949953421312L, -4320133121L, -288511851128421633L, 8734520370987023L, 576460745995194368L, -211110526976001L, 9007199254740991999L, 288019269919145983L};
  413.       isLDTable0900through0EFF = new long[]{-864691128455135250L, 562949938692095L, -3186861885341720594L, 576460544811219359L, -3211631683292264476L, 9006925953907079L, -869759877059465234L, 281204393851839L, -878767076314341394L, 562690925803919L, -4341532606274353172L, 2251250066275783L, -4327961440926441490L, 281212990012895L, -4327961440926441492L, 281214063754719L, -4323457841299070996L, 281212992110031L, 0L, 0L, -8646911284551352322L, 268435455L, 4323434403644581270L, 872365919L};
  414.       isLDTable1080through11FF = isDefinedTable1080through11FF;
  415.       isLDTable1E00through1FFF = isDefinedTable1E00through27BF;
  416.       isLDTable3000through33FF = isDefinedTable3000through33FF;
  417.       isLDTableFB00throughFFFF = new long[]{6881500229564629119L, -37L, 1125899906842623L, -524288L, -1L, -1L, -1L, -1L, -1L, -65536L, -196609L, 1152640029630136575L, 0L, -11540474045136896L, -1L, 2305843009213693951L, 576460743780532224L, -274743689218L, Long.MAX_VALUE, 486341884L};
  418.       toLowerCaseTable = new long[]{-6173215364225870507L, 3122495741643543722L, 1274187282820877526L, 6059124173486861744L, 5592405L, 0L, 0L, 0L, 0L, 0L, 17575006099264L, 93819265613824L, 281474976702462L, 6148914689804861440L, 6148914691236495361L, 78044801355024522L, -562949953421312L, 8388607L, 0L, 0L, 6148914691236517205L, 6148914691236517205L, 6148914689806259541L, 96076792050570581L, -71777217515815168L, 280378317225728L, 2234065794919104256L, 2233819500287893248L};
  419.       toUpperCaseTable = new long[]{6100313345257810602L, -3122495741643544235L, 2472794134709276968L, -6328495726735828128L, 11184810L, 1269983369232384L, 265480L, 0L, 0L, 0L, -299067162755072L, 1032063467880447L, -281474976710656L, -6148914690341797889L, -6148914691236560894L, 156089602710049044L, 0L, -8589934592L, 127L, 0L, -6148914691236517206L, -6148914691236517206L, -6148914694097032534L, 192153584101141162L, 71777214282006783L, 4611405638678478911L, 3097319977189631L, 2251950137737224L};
  420.    }
  421.  
  422.    public static boolean isLetter(char var0) {
  423.       if (var0 < 1792) {
  424.          return (isLetterTable0000through06FF[var0 >> 6] >> (var0 & 63) & 1L) != 0L;
  425.       } else if (var0 >= 2304 && var0 <= 3839) {
  426.          return (isLetterTable0900through0EFF[var0 - 2304 >> 6] >> (var0 & 63) & 1L) != 0L;
  427.       } else if (var0 >= 4224 && var0 <= 4607) {
  428.          return (isLetterTable1080through11FF[var0 - 4224 >> 6] >> (var0 & 63) & 1L) != 0L;
  429.       } else if (var0 >= 7680 && var0 <= 8191) {
  430.          return (isLetterTable1E00through1FFF[var0 - 7680 >> 6] >> (var0 & 63) & 1L) != 0L;
  431.       } else if (var0 >= 12352 && var0 <= 13311) {
  432.          return (isLetterTable3000through33FF[var0 - 12288 >> 6] >> (var0 & 63) & 1L) != 0L;
  433.       } else if (var0 >= '∩¼Ç') {
  434.          return (isLetterTableFB00throughFFFF[var0 - '∩¼Ç' >> 6] >> (var0 & 63) & 1L) != 0L;
  435.       } else {
  436.          return var0 >= 13312 && var0 <= 'Θ╛Ñ' || var0 >= '∩ñÇ' && var0 <= '∩¿¡';
  437.       }
  438.    }
  439.  
  440.    public static boolean isLetterOrDigit(char var0) {
  441.       if (var0 < 1792) {
  442.          return (isLDTable0000through06FF[var0 >> 6] >> (var0 & 63) & 1L) != 0L;
  443.       } else if (var0 >= 2304 && var0 <= 3839) {
  444.          return (isLDTable0900through0EFF[var0 - 2304 >> 6] >> (var0 & 63) & 1L) != 0L;
  445.       } else if (var0 >= 4224 && var0 <= 4607) {
  446.          return (isLDTable1080through11FF[var0 - 4224 >> 6] >> (var0 & 63) & 1L) != 0L;
  447.       } else if (var0 >= 7680 && var0 <= 8191) {
  448.          return (isLDTable1E00through1FFF[var0 - 7680 >> 6] >> (var0 & 63) & 1L) != 0L;
  449.       } else if (var0 >= 12352 && var0 <= 13311) {
  450.          return (isLDTable3000through33FF[var0 - 12288 >> 6] >> (var0 & 63) & 1L) != 0L;
  451.       } else if (var0 >= '∩¼Ç') {
  452.          return (isLDTableFB00throughFFFF[var0 - '∩¼Ç' >> 6] >> (var0 & 63) & 1L) != 0L;
  453.       } else {
  454.          return var0 >= 13312 && var0 <= 'Θ╛Ñ' || var0 >= '∩ñÇ' && var0 <= '∩¿¡';
  455.       }
  456.    }
  457.  
  458.    public Character(char var1) {
  459.       this.value = var1;
  460.    }
  461.  
  462.    public char charValue() {
  463.       return this.value;
  464.    }
  465.  
  466.    public int hashCode() {
  467.       return this.value;
  468.    }
  469.  
  470.    public static boolean isSpace(char var0) {
  471.       switch (var0) {
  472.          case '\t':
  473.          case '\n':
  474.          case '\f':
  475.          case '\r':
  476.          case ' ':
  477.             return true;
  478.          default:
  479.             return false;
  480.       }
  481.    }
  482.  
  483.    public static boolean isDigit(char var0) {
  484.       if (var0 >= '0' && var0 <= '9') {
  485.          return true;
  486.       } else {
  487.          switch (var0 >> 8) {
  488.             case 6:
  489.                return var0 >= 1632 && var0 <= 1641 || var0 >= 1776 && var0 <= 1785;
  490.             case 9:
  491.                return var0 >= 2406 && var0 <= 2415 || var0 >= 2534 && var0 <= 2543;
  492.             case 10:
  493.                return var0 >= 2662 && var0 <= 2671 || var0 >= 2790 && var0 <= 2799;
  494.             case 11:
  495.                return var0 >= 2918 && var0 <= 2927 || var0 >= 3047 && var0 <= 3055;
  496.             case 12:
  497.                return var0 >= 3174 && var0 <= 3183 || var0 >= 3302 && var0 <= 3311;
  498.             case 13:
  499.                return var0 >= 3430 && var0 <= 3439;
  500.             case 14:
  501.                return var0 >= 3664 && var0 <= 3673 || var0 >= 3792 && var0 <= 3801;
  502.             case 255:
  503.                return var0 >= '∩╝É' && var0 <= '∩╝Ö';
  504.             default:
  505.                return false;
  506.          }
  507.       }
  508.    }
  509.  
  510.    public static boolean isDefined(char var0) {
  511.       if (var0 < 502) {
  512.          return true;
  513.       } else if (var0 < 1792) {
  514.          return (isDefinedTable01C0through06FF[var0 - 448 >> 6] >> (var0 & 63) & 1L) != 0L;
  515.       } else if (var0 >= 2304 && var0 <= 3839) {
  516.          return (isDefinedTable0900through0EFF[var0 - 2304 >> 6] >> (var0 & 63) & 1L) != 0L;
  517.       } else if (var0 >= 4224 && var0 <= 4607) {
  518.          return (isDefinedTable1080through11FF[var0 - 4224 >> 6] >> (var0 & 63) & 1L) != 0L;
  519.       } else if (var0 >= 7680 && var0 <= 10175) {
  520.          return (isDefinedTable1E00through27BF[var0 - 7680 >> 6] >> (var0 & 63) & 1L) != 0L;
  521.       } else if (var0 >= 12288 && var0 <= 13311) {
  522.          return (isDefinedTable3000through33FF[var0 - 12288 >> 6] >> (var0 & 63) & 1L) != 0L;
  523.       } else if (var0 >= '∩¼Ç') {
  524.          return (isDefinedTableFB00throughFFFF[var0 - '∩¼Ç' >> 6] >> (var0 & 63) & 1L) != 0L;
  525.       } else {
  526.          return var0 >= 13312 && var0 <= 'Θ╛Ñ' || var0 >= '∩ñÇ' && var0 <= '∩¿¡';
  527.       }
  528.    }
  529.  
  530.    public static int digit(char var0, int var1) {
  531.       int var2 = -1;
  532.       if (var1 >= 2 && var1 <= 36) {
  533.          if (var0 >= '0' && var0 <= '9') {
  534.             var2 = var0 - 48;
  535.          } else if (var0 >= 'A' && var0 <= 'Z') {
  536.             var2 = var0 + -55;
  537.          } else if (var0 >= 'a' && var0 <= 'z') {
  538.             var2 = var0 + -87;
  539.          } else {
  540.             switch (var0 >> 8) {
  541.                case 6:
  542.                   if (var0 >= 1632 && var0 <= 1641) {
  543.                      var2 = var0 - 1632;
  544.                   } else if (var0 >= 1776 && var0 <= 1785) {
  545.                      var2 = var0 - 1776;
  546.                   }
  547.                   break;
  548.                case 9:
  549.                   if (var0 >= 2406 && var0 <= 2415) {
  550.                      var2 = var0 - 2406;
  551.                   } else if (var0 >= 2534 && var0 <= 2543) {
  552.                      var2 = var0 - 2534;
  553.                   }
  554.                   break;
  555.                case 10:
  556.                   if (var0 >= 2662 && var0 <= 2671) {
  557.                      var2 = var0 - 2662;
  558.                   } else if (var0 >= 2790 && var0 <= 2799) {
  559.                      var2 = var0 - 2790;
  560.                   }
  561.                   break;
  562.                case 11:
  563.                   if (var0 >= 2918 && var0 <= 2927) {
  564.                      var2 = var0 - 2918;
  565.                   } else if (var0 >= 3047 && var0 <= 3055) {
  566.                      var2 = var0 - 3046;
  567.                   }
  568.                   break;
  569.                case 12:
  570.                   if (var0 >= 3174 && var0 <= 3183) {
  571.                      var2 = var0 - 3174;
  572.                   } else if (var0 >= 3302 && var0 <= 3311) {
  573.                      var2 = var0 - 3302;
  574.                   }
  575.                   break;
  576.                case 13:
  577.                   if (var0 >= 3430 && var0 <= 3439) {
  578.                      var2 = var0 - 3430;
  579.                   }
  580.                   break;
  581.                case 14:
  582.                   if (var0 >= 3664 && var0 <= 3673) {
  583.                      var2 = var0 - 3664;
  584.                   } else if (var0 >= 3792 && var0 <= 3801) {
  585.                      var2 = var0 - 3792;
  586.                   }
  587.                   break;
  588.                case 255:
  589.                   if (var0 >= '∩╝É' && var0 <= '∩╝Ö') {
  590.                      var2 = var0 - '∩╝É';
  591.                   }
  592.             }
  593.          }
  594.       }
  595.  
  596.       return var2 < var1 ? var2 : -1;
  597.    }
  598.  
  599.    public static char forDigit(int var0, int var1) {
  600.       if (var0 < var1 && var0 >= 0) {
  601.          if (var1 >= 2 && var1 <= 36) {
  602.             return var0 < 10 ? (char)(48 + var0) : (char)(97 + var0 - 10);
  603.          } else {
  604.             return '\u0000';
  605.          }
  606.       } else {
  607.          return '\u0000';
  608.       }
  609.    }
  610.  
  611.    public static boolean isJavaLetter(char var0) {
  612.       return isLetter(var0) || var0 == '$' || var0 == '_';
  613.    }
  614. }
  615.