testData/obfuscated/bd.java

import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.util.Hashtable;
import java.util.Vector;

public class bd {
   private static String a;
   private static String j;
   private static MessageDigest b;
   private static Hashtable c;
   private static Hashtable d;
   private static final boolean e = false;
   private static String f;
   private static Hashtable g;
   private static Hashtable h;
   private static final String x = "";
   private static PrintWriter writer;
   private static final String[] i;

   private static void a(Hashtable var0, MessageDigest var1) {
      var0.put(new BigInteger(i[46], 36), "\uffc0");
      var0.put(new BigInteger(i[17], 36), "ﾏ");
      var0.put(new BigInteger(i[96], 36), "ﾣ");
      var0.put(new BigInteger(i[94], 36), "ￍ");
      var0.put(new BigInteger(i[24], 36), "\t");
      var0.put(new BigInteger(i[82], 36), i[60]);
      var0.put(new BigInteger(i[64], 36), "\uffbf");
      var0.put(new BigInteger(i[36], 36), "ￏ");
      var0.put(new BigInteger(i[56], 36), i[10]);
      var0.put(new BigInteger(i[30], 36), i[70]);
      var0.put(new BigInteger(i[75], 36), i[23]);
      var0.put(new BigInteger(i[47], 36), i[5]);
      var0.put(new BigInteger(i[19], 36), "ﾖ");
      var0.put(new BigInteger(i[2], 36), i[71]);
      var0.put(new BigInteger(i[50], 36), "ￊ");
      var0.put(new BigInteger(i[76], 36), "O");
      var0.put(new BigInteger(i[40], 36), i[15]);
      var0.put(new BigInteger(i[80], 36), i[33]);
      var0.put(new BigInteger(i[95], 36), i[38]);
      var0.put(new BigInteger(i[89], 36), i[69]);
      var0.put(new BigInteger(i[43], 36), ",");
      var0.put(new BigInteger(i[93], 36), i[77]);
      var0.put(new BigInteger(i[62], 36), "ﾊ");
      var0.put(new BigInteger(i[22], 36), i[66]);
      var0.put(new BigInteger(i[14], 36), i[34]);
      var0.put(new BigInteger(i[29], 36), i[49]);
      var0.put(new BigInteger(i[88], 36), i[25]);
      var0.put(new BigInteger(i[42], 36), i[39]);
      var0.put(new BigInteger(i[45], 36), i[11]);
      var0.put(new BigInteger(i[102], 36), i[73]);
      var0.put(new BigInteger(i[86], 36), i[0]);
      var0.put(new BigInteger(i[41], 36), i[100]);
      var0.put(new BigInteger(i[74], 36), i[51]);
      var0.put(new BigInteger(i[103], 36), i[65]);
      var0.put(new BigInteger(i[97], 36), i[85]);
      var0.put(new BigInteger(i[92], 36), i[104]);
      var0.put(new BigInteger(i[13], 36), i[20]);
      var0.put(new BigInteger(i[78], 36), i[90]);
      var0.put(new BigInteger(i[6], 36), ">");
      var0.put(new BigInteger(i[32], 36), "\uffdd");
      var0.put(new BigInteger(i[63], 36), "ￛ");
      var0.put(new BigInteger(i[53], 36), "\uffd0");
      var0.put(new BigInteger(i[7], 36), i[12]);
      var0.put(new BigInteger(i[54], 36), i[67]);
      var0.put(new BigInteger(i[4], 36), "ﾗ");
      var0.put(new BigInteger(i[3], 36), i[57]);
      var0.put(new BigInteger(i[79], 36), "\uffd0");
      var0.put(new BigInteger(i[16], 36), "A");
      var0.put(new BigInteger(i[44], 36), i[18]);
      var0.put(new BigInteger(i[31], 36), i[58]);
      var0.put(new BigInteger(i[21], 36), i[55]);
      var0.put(new BigInteger(i[35], 36), "-");
      var0.put(new BigInteger(i[9], 36), i[87]);
      var0.put(new BigInteger(i[61], 36), i[81]);
      var0.put(new BigInteger(i[72], 36), i[48]);
      var0.put(new BigInteger(i[68], 36), "\u0010");
      var0.put(new BigInteger(i[26], 36), "ﾜ");
      var0.put(new BigInteger(i[91], 36), i[1]);
      var0.put(new BigInteger(i[28], 36), i[101]);
      var0.put(new BigInteger(i[37], 36), "u");
      var0.put(new BigInteger(i[99], 36), i[52]);
      var0.put(new BigInteger(i[105], 36), i[59]);
      var0.put(new BigInteger(i[27], 36), "ﾰ");
      var0.put(new BigInteger(i[8], 36), i[98]);
      var0.put(new BigInteger(i[83], 36), "\uffd0");
      var0.put(new BigInteger(i[84], 36), "\uffde");
   }

   private static void b(Hashtable var0, MessageDigest var1) {
   }

   private static void c(Hashtable var0, MessageDigest var1) {
   }

   private static void d(Hashtable var0, MessageDigest var1) {
   }

   private static void e(Hashtable var0, MessageDigest var1) {
   }

   private static void f(Hashtable var0, MessageDigest var1) {
   }

   private static void g(Hashtable var0, MessageDigest var1) {
   }

   private static void h(Hashtable var0, MessageDigest var1) {
   }

   private static void i(Hashtable var0, MessageDigest var1) {
   }

   private static void j(Hashtable var0, MessageDigest var1) {
   }

   public static String a(String var0) {
      if (b == null) {
         return var0;
      } else {
         try {
            int var1 = var0.lastIndexOf("[") + 1;
            String var2 = var0.substring(var1);
            if (var1 > 0 && var2.length() == 1) {
               return var0;
            } else {
               boolean var3 = false;
               if (var2.charAt(0) == 'L' && var2.charAt(var2.length() - 1) == ';') {
                  var3 = true;
                  var2 = var2.substring(1, var2.length() - 1);
               }

               boolean var4 = var2.indexOf(46) > -1;
               if (var4) {
                  var2 = var2.replace('.', '/');
               }

               var2 = var2 + f;
               String var5 = b(var2);
               if (var5 == null) {
                  return var0;
               } else {
                  if (var4) {
                     var5 = var5.replace('/', '.');
                  }

                  StringBuffer var6 = new StringBuffer();

                  for(int var7 = 0; var7 < var1; ++var7) {
                     var6.append('[');
                  }

                  if (var3) {
                     var6.append('L');
                  }

                  var6.append(var5);
                  if (var3) {
                     var6.append(';');
                  }

                  return var6.toString();
               }
            }
         } catch (Throwable var8) {
            return var0;
         }
      }
   }

   public static String b(String var0, Class var1, Class[] var2) {
      if (b != null && var1 != null) {
         try {
            String var3 = var1.getName();
            String var4 = var3.replace('.', '/');
            StringBuffer var5 = new StringBuffer();
            var5.append(f);
            var5.append(var0);
            var5.append(f);
            if (var2 != null && var2.length > 0) {
               for(int var6 = 0; var6 < var2.length; ++var6) {
                  Class var7 = var2[var6];
                  var5.append(d.containsKey(var7) ? (String)d.get(var7) : var7.getName().replace('.', '/'));
                  var5.append(f);
               }
            }

            String var10 = var5.toString();
            String var11 = var4 + var10;
            String var8 = b(var11);
            if (var8 != null) {
               return var8;
            } else {
               var8 = a(var1, var10);
               return var8 != null ? var8 : var0;
            }
         } catch (Throwable var9) {
            return var0;
         }
      } else {
         return var0;
      }
   }

   public static String c(Class var0, String var1) {
      if (b != null && var0 != null) {
         try {
            String var2 = var0.getName();
            String var3 = var2.replace('.', '/');
            StringBuffer var4 = new StringBuffer();
            var4.append(f);
            var4.append(var1);
            String var5 = var4.toString();
            String var6 = var3 + var5;
            String var7 = b(var6);
            if (var7 != null) {
               return var7;
            } else {
               var7 = a(var0, var5);
               return var7 != null ? var7 : var1;
            }
         } catch (Throwable var8) {
            return var1;
         }
      } else {
         return var1;
      }
   }

   private static String b(String var0) {
      String var1 = (String)g.get(var0);
      if (var1 == null && var1 != "") {
         b.reset();

         try {
            b.update(var0.getBytes(j));
         } catch (UnsupportedEncodingException var4) {
         }

         byte[] var2 = b.digest();
         BigInteger var3 = new BigInteger(var2);
         var1 = (String)c.get(var3);
         if (var1 != null) {
            var1 = a(var0, var1);
            g.put(var0, var1);
         } else {
            g.put(var0, "");
         }
      }

      return var1 == "" ? null : var1;
   }

   private static String a(String var0, String var1) {
      b.reset();
      byte[] var2 = null;

      try {
         var2 = (var0 + a).getBytes(j);
      } catch (UnsupportedEncodingException var9) {
      }

      b.update(var2);
      byte[] var3 = b.digest();
      char[] var4 = var1.toCharArray();
      StringBuffer var5 = new StringBuffer(var4.length);

      for(int var6 = 0; var6 < var4.length; ++var6) {
         char var7 = var4[var6];
         byte var8;
         if (var6 < var3.length - 1) {
            var8 = var3[var6];
         } else {
            var8 = var3[var6 % var3.length];
         }

         var5.append((char)(var7 ^ (char)var8));
      }

      String var10 = var5.toString();
      return var10;
   }

   private static String a(Class var0, String var1) {
      Vector var2 = b(var0);
      int var3 = var2.size();

      for(int var4 = 0; var4 < var3; ++var4) {
         String var5 = (String)var2.elementAt(var4);
         String var6 = var5 + var1;
         String var7 = b(var6);
         if (var7 != null) {
            return var7;
         }
      }

      return null;
   }

   private static String a(Class var0) {
      return d.containsKey(var0) ? (String)d.get(var0) : var0.getName().replace('.', '/');
   }

   private static Vector b(Class var0) {
      String var1 = var0.getName();
      Vector var2 = (Vector)h.get(var1);
      if (var2 != null) {
         return var2;
      } else {
         Vector var3 = new Vector();
         Hashtable var4 = new Hashtable();
         b(var0, var3, var4);
         h.put(var1, var3);
         return var3;
      }
   }

   private static void b(Class var0, Vector var1, Hashtable var2) {
      Class var3 = var0.getSuperclass();
      if (var3 != null && !var2.containsKey(var3)) {
         var1.addElement(var3.getName().replace('.', '/'));
         var2.put(var3, var3);
         b(var3, var1, var2);
      }

      Class[] var4 = var0.getInterfaces();

      for(int var5 = 0; var5 < var4.length; ++var5) {
         Class var6 = var4[var5];
         if (!var2.containsKey(var6)) {
            var1.addElement(var6.getName().replace('.', '/'));
            var2.put(var6, var6);
            b(var6, var1, var2);
         }
      }

   }

   private static String c(Class var0) {
      return var0.getName().replace('.', '/');
   }

   static {
      String[] var10000 = new String[106];
      char[] var10003 = "ￖ\"".toCharArray();
      int var10005 = var10003.length;
      char[] var10004 = var10003;
      int var152 = var10005;

      for(int var2 = 0; var152 > var2; ++var2) {
         char var10007 = var10004[var2];
         byte var10008;
         switch (var2 % 5) {
            case 0:
               var10008 = 40;
               break;
            case 1:
               var10008 = 7;
               break;
            case 2:
               var10008 = 65;
               break;
            case 3:
               var10008 = 119;
               break;
            default:
               var10008 = 49;
         }

         var10004[var2] = (char)(var10007 ^ var10008);
      }

      var10000[0] = (new String(var10004)).intern();
      char[] var154 = "aq".toCharArray();
      var10005 = var154.length;
      var10004 = var154;
      int var155 = var10005;

      for(int var6 = 0; var155 > var6; ++var6) {
         char var1005 = var10004[var6];
         byte var1110;
         switch (var6 % 5) {
            case 0:
               var1110 = 40;
               break;
            case 1:
               var1110 = 7;
               break;
            case 2:
               var1110 = 65;
               break;
            case 3:
               var1110 = 119;
               break;
            default:
               var1110 = 49;
         }

         var10004[var6] = (char)(var1005 ^ var1110);
      }

      var10000[1] = (new String(var10004)).intern();
      char[] var157 = "\u0005c(\u001f_X~+G\u0007\u001000\u0007\u0007\\k%B^K34\u001f@Oa7\u001dY\u001ak.\u001fE\u001dj5N^@?5\u000eBJ6(O\u0006\u001dq5\u0018\u0004\u001efv\u001eEJa0G\tE~#\u0002\u0004^k;\u0018\tIn%@_N08\u0011AOe.\u0014T]09\u0001I\u001ej&\u001a@".toCharArray();
      var10005 = var157.length;
      var10004 = var157;
      int var158 = var10005;

      for(int var7 = 0; var158 > var7; ++var7) {
         char var1006 = var10004[var7];
         byte var1111;
         switch (var7 % 5) {
            case 0:
               var1111 = 40;
               break;
            case 1:
               var1111 = 7;
               break;
            case 2:
               var1111 = 65;
               break;
            case 3:
               var1111 = 119;
               break;
            default:
               var1111 = 49;
         }

         var10004[var7] = (char)(var1006 ^ var1111);
      }

      var10000[2] = (new String(var10004)).intern();
      char[] var160 = "\u000537\u000e\\[b&\u0006Z_cr\u001f\u0006B?-\rK\u001a0p\u0011_AwpFEFvr\u0007D\u0011w3\u0014RPm'\u0018Y\u0011vq\u0015[Ba'AH\u001a?%\u0001\u0004Ca3\r\u0003O?;D[Gh6CV\u001cw3\u0010\u0000YwxC@L}9\u0005C]}4\u0015\u0005^38\u0010\\".toCharArray();
      var10005 = var160.length;
      var10004 = var160;
      int var161 = var10005;

      for(int var8 = 0; var161 > var8; ++var8) {
         char var1007 = var10004[var8];
         byte var1112;
         switch (var8 % 5) {
            case 0:
               var1112 = 40;
               break;
            case 1:
               var1112 = 7;
               break;
            case 2:
               var1112 = 65;
               break;
            case 3:
               var1112 = 119;
               break;
            default:
               var1112 = 49;
         }

         var10004[var8] = (char)(var1007 ^ var1112);
      }

      var10000[3] = (new String(var10004)).intern();
      char[] var163 = "\u000533\u000f\u0004Y0q\u0015WZe7\u000fKYb6NDL\u007f7\u001bPId,NYD0s\u0010@Djw\u0016UM3+\u0019\b\u001b?v@UL`t\u0019^\u001a?&FE\u001db1\u0016V\u001f10\u000f\u0000Nm.ER]q8@R\u001e37A\u0005\u001dfy\u0000@\u0018b)\u000fEJa \u001c".toCharArray();
      var10005 = var163.length;
      var10004 = var163;
      int var164 = var10005;

      for(int var9 = 0; var164 > var9; ++var9) {
         char var1008 = var10004[var9];
         byte var1113;
         switch (var9 % 5) {
            case 0:
               var1113 = 40;
               break;
            case 1:
               var1113 = 7;
               break;
            case 2:
               var1113 = 65;
               break;
            case 3:
               var1113 = 119;
               break;
            default:
               var1113 = 49;
         }

         var10004[var9] = (char)(var1008 ^ var1113);
      }

      var10000[4] = (new String(var10004)).intern();
      char[] var166 = "￥￡".toCharArray();
      var10005 = var166.length;
      var10004 = var166;
      int var167 = var10005;

      for(int var10 = 0; var167 > var10; ++var10) {
         char var1009 = var10004[var10];
         byte var1114;
         switch (var10 % 5) {
            case 0:
               var1114 = 40;
               break;
            case 1:
               var1114 = 7;
               break;
            case 2:
               var1114 = 65;
               break;
            case 3:
               var1114 = 119;
               break;
            default:
               var1114 = 49;
         }

         var10004[var10] = (char)(var1009 ^ var1114);
      }

      var10000[5] = (new String(var10004)).intern();
      char[] var169 = "\u00053w\u0015X\u001e4#\rSK`2\u0003]Cr&\u001fI_b)\u001eDPbxDTO1;OEZq$\u001e\u0006Ojv@T\u0011mx\u001d\u0000\u001cp.\u0007\u0005Ed&\u0006F\u001enp\r\t\u001c?&\u0015XJ?'OT^ev\u0015\u0002F60\u0010RBk&\u0007F_32\u0005W\u001fb8F@".toCharArray();
      var10005 = var169.length;
      var10004 = var169;
      int var170 = var10005;

      for(int var11 = 0; var170 > var11; ++var11) {
         char var1010 = var10004[var11];
         byte var1115;
         switch (var11 % 5) {
            case 0:
               var1115 = 40;
               break;
            case 1:
               var1115 = 7;
               break;
            case 2:
               var1115 = 65;
               break;
            case 3:
               var1115 = 119;
               break;
            default:
               var1115 = 49;
         }

         var10004[var11] = (char)(var1010 ^ var1115);
      }

      var10000[6] = (new String(var10004)).intern();
      char[] var172 = "\u001ev5\u0006P\u001b>&\u0007H@7-GCI>)\u0007S\u001ej;\u0010UMm AYO2#\u000fZ\u001e7s\u001cS\u0010oq\u001fVFu\"DWG?'OZ\u0011`&\u0013\t]fw\u001aH\u0019o$DWG~&@^P7rDK\u0018q$FPL}2A\u0001No \u0018PLjv\u000e".toCharArray();
      var10005 = var172.length;
      var10004 = var172;
      int var173 = var10005;

      for(int var12 = 0; var173 > var12; ++var12) {
         char var1011 = var10004[var12];
         byte var1116;
         switch (var12 % 5) {
            case 0:
               var1116 = 40;
               break;
            case 1:
               var1116 = 7;
               break;
            case 2:
               var1116 = 65;
               break;
            case 3:
               var1116 = 119;
               break;
            default:
               var1116 = 49;
         }

         var10004[var12] = (char)(var1011 ^ var1116);
      }

      var10000[7] = (new String(var10004)).intern();
      char[] var175 = "\u00054r\u0007YI4,\u0018RZ~(\u0001K\u00187x\u001aC]e8\u000e\u0004\u00117/FRMmuNK\u0010k'\u001cP\u0019fp\u001ePK5)@\t_os\u001f\u0003J~/@P\u001cm7\u001fG\u0010`+\u0015\u0005\u0010tx\u0011IPk/\u001f\u0004@isC\t\u001c0rCY\u001auqC\u0000\u0010n7\u001aT".toCharArray();
      var10005 = var175.length;
      var10004 = var175;
      int var176 = var10005;

      for(int var13 = 0; var176 > var13; ++var13) {
         char var1012 = var10004[var13];
         byte var1117;
         switch (var13 % 5) {
            case 0:
               var1117 = 40;
               break;
            case 1:
               var1117 = 7;
               break;
            case 2:
               var1117 = 65;
               break;
            case 3:
               var1117 = 119;
               break;
            default:
               var1117 = 49;
         }

         var10004[var13] = (char)(var1012 ^ var1117);
      }

      var10000[8] = (new String(var10004)).intern();
      char[] var178 = "L3t\u0019ZB30\u0014\bNs6\u0010\u0002Z1$\u001aVI09\u000eU]30F\u0004\\qvN\\_o9BK\u001f\u007fw\u0006DFb-N\u0002[5'B[[00\rZNb O\u0006\u001ew2\u0002[Ltp\u0013\u0003G~qO_Qe)\u001eSLh0\u001a\\\u001bs9\u0013B\u0010ds\u0012".toCharArray();
      var10005 = var178.length;
      var10004 = var178;
      int var179 = var10005;

      for(int var14 = 0; var179 > var14; ++var14) {
         char var1013 = var10004[var14];
         byte var1118;
         switch (var14 % 5) {
            case 0:
               var1118 = 40;
               break;
            case 1:
               var1118 = 7;
               break;
            case 2:
               var1118 = 65;
               break;
            case 3:
               var1118 = 119;
               break;
            default:
               var1118 = 49;
         }

         var10004[var14] = (char)(var1013 ^ var1118);
      }

      var10000[9] = (new String(var10004)).intern();
      char[] var181 = "￡ﾚ".toCharArray();
      var10005 = var181.length;
      var10004 = var181;
      int var182 = var10005;

      for(int var15 = 0; var182 > var15; ++var15) {
         char var1014 = var10004[var15];
         byte var1119;
         switch (var15 % 5) {
            case 0:
               var1119 = 40;
               break;
            case 1:
               var1119 = 7;
               break;
            case 2:
               var1119 = 65;
               break;
            case 3:
               var1119 = 119;
               break;
            default:
               var1119 = 49;
         }

         var10004[var15] = (char)(var1014 ^ var1119);
      }

      var10000[10] = (new String(var10004)).intern();
      char[] var184 = "\ufff0\u0007".toCharArray();
      var10005 = var184.length;
      var10004 = var184;
      int var185 = var10005;

      for(int var16 = 0; var185 > var16; ++var16) {
         char var1015 = var10004[var16];
         byte var1120;
         switch (var16 % 5) {
            case 0:
               var1120 = 40;
               break;
            case 1:
               var1120 = 7;
               break;
            case 2:
               var1120 = 65;
               break;
            case 3:
               var1120 = 119;
               break;
            default:
               var1120 = 49;
         }

         var10004[var16] = (char)(var1015 ^ var1120);
      }

      var10000[11] = (new String(var10004)).intern();
      char[] var187 = "ﾯ>".toCharArray();
      var10005 = var187.length;
      var10004 = var187;
      int var188 = var10005;

      for(int var17 = 0; var188 > var17; ++var17) {
         char var1016 = var10004[var17];
         byte var1121;
         switch (var17 % 5) {
            case 0:
               var1121 = 40;
               break;
            case 1:
               var1121 = 7;
               break;
            case 2:
               var1121 = 65;
               break;
            case 3:
               var1121 = 119;
               break;
            default:
               var1121 = 49;
         }

         var10004[var17] = (char)(var1016 ^ var1121);
      }

      var10000[12] = (new String(var10004)).intern();
      char[] var190 = "\u00052+\u0019\u0000Jrp\u001a]^k6\u0010CJa8\u0015DXbyFY\u0018bx\u001a\u0007O0v\u0005CD0y\u0014[Np1\u0004XKm8\u0012\u0007Ri2\u0018\u0000Rax\u001bH\u0010`#\u0003\u0006Pp6\u001e\u0001Aa%DYG0#\u0001KJmy\u0002WX6p\u0018E\u0010`5\u001c\u0002C}r\u001b\u0002".toCharArray();
      var10005 = var190.length;
      var10004 = var190;
      int var191 = var10005;

      for(int var18 = 0; var191 > var18; ++var18) {
         char var1017 = var10004[var18];
         byte var1122;
         switch (var18 % 5) {
            case 0:
               var1122 = 40;
               break;
            case 1:
               var1122 = 7;
               break;
            case 2:
               var1122 = 65;
               break;
            case 3:
               var1122 = 119;
               break;
            default:
               var1122 = 49;
         }

         var10004[var18] = (char)(var1017 ^ var1122);
      }

      var10000[13] = (new String(var10004)).intern();
      char[] var193 = "\u0005dv\u0000GGl(\u001aE\u00192-\u0014U\u0011t8\u0013\b\u0019c-\u001e]Eq$\u000fV\u001av/CX\u001ev'\u001e\\Q}3\u0012ZCmv\u0002X\u0019b6\u0018RFc)\u0007\u0007\u001c`7\u0003XKiy\u0006BYo0\u0016\u0004@c4\u0010\u0001BhrE\u0004[i\"\u0012C[au\u0000SPsw\u001aW".toCharArray();
      var10005 = var193.length;
      var10004 = var193;
      int var194 = var10005;

      for(int var19 = 0; var194 > var19; ++var19) {
         char var1018 = var10004[var19];
         byte var1123;
         switch (var19 % 5) {
            case 0:
               var1123 = 40;
               break;
            case 1:
               var1123 = 7;
               break;
            case 2:
               var1123 = 65;
               break;
            case 3:
               var1123 = 119;
               break;
            default:
               var1123 = 49;
         }

         var10004[var19] = (char)(var1018 ^ var1123);
      }

      var10000[14] = (new String(var10004)).intern();
      char[] var196 = "\uffc1\ufff4".toCharArray();
      var10005 = var196.length;
      var10004 = var196;
      int var197 = var10005;

      for(int var20 = 0; var197 > var20; ++var20) {
         char var1019 = var10004[var20];
         byte var1124;
         switch (var20 % 5) {
            case 0:
               var1124 = 40;
               break;
            case 1:
               var1124 = 7;
               break;
            case 2:
               var1124 = 65;
               break;
            case 3:
               var1124 = 119;
               break;
            default:
               var1124 = 49;
         }

         var10004[var20] = (char)(var1019 ^ var1124);
      }

      var10000[15] = (new String(var10004)).intern();
      char[] var199 = "It#\u001c\tOa1\u001b[Km4\u0001\u0004Eq6\u0003@\u001bi.\u0005C_n;\u0015[Dfr\u0001\u0005Ri*\u0013\u0004B0*\u0002]Js,\u000fFP25A_D>;\u0012SDju\u0010^\u0011e7GY_k-\u0001Z\u001d>9\rI^?4\u0004DK}4\u001e_Z6#\u0012EX0u\u000e".toCharArray();
      var10005 = var199.length;
      var10004 = var199;
      int var200 = var10005;

      for(int var21 = 0; var200 > var21; ++var21) {
         char var1020 = var10004[var21];
         byte var1125;
         switch (var21 % 5) {
            case 0:
               var1125 = 40;
               break;
            case 1:
               var1125 = 7;
               break;
            case 2:
               var1125 = 65;
               break;
            case 3:
               var1125 = 119;
               break;
            default:
               var1125 = 49;
         }

         var10004[var21] = (char)(var1020 ^ var1125);
      }

      var10000[16] = (new String(var10004)).intern();
      char[] var202 = "\u00051+OT_d$\u0016F\u0019n*\u0006\u0005\u001ae(\u000f_J~wG\u0000\u001ee1@R]>u\u0019\u0004RpwNUJ2t\u0007\u0001Ol,\u0004RAp4\u0006GZ79\u0011F\u0011n7\u0001\u0005^cvB\u0007Ou$\u0002EQ}q\u0007ZOw&\u0007ICo3\u0014[\u001ft,EB\u001bnx\u0002S".toCharArray();
      var10005 = var202.length;
      var10004 = var202;
      int var203 = var10005;

      for(int var22 = 0; var203 > var22; ++var22) {
         char var1021 = var10004[var22];
         byte var1126;
         switch (var22 % 5) {
            case 0:
               var1126 = 40;
               break;
            case 1:
               var1126 = 7;
               break;
            case 2:
               var1126 = 65;
               break;
            case 3:
               var1126 = 119;
               break;
            default:
               var1126 = 49;
         }

         var10004[var22] = (char)(var1021 ^ var1126);
      }

      var10000[17] = (new String(var10004)).intern();
      char[] var205 = "ￃﾾ".toCharArray();
      var10005 = var205.length;
      var10004 = var205;
      int var206 = var10005;

      for(int var23 = 0; var206 > var23; ++var23) {
         char var1022 = var10004[var23];
         byte var1127;
         switch (var23 % 5) {
            case 0:
               var1127 = 40;
               break;
            case 1:
               var1127 = 7;
               break;
            case 2:
               var1127 = 65;
               break;
            case 3:
               var1127 = 119;
               break;
            default:
               var1127 = 49;
         }

         var10004[var23] = (char)(var1022 ^ var1127);
      }

      var10000[18] = (new String(var10004)).intern();
      char[] var208 = "Ah,\r\u0006Qq+\u0018]Gn9\u001eG\u00111p\u0004XBr0O\u0001Fj+CK\\rsCU\u001f4p\u001cSD7r\u0005KL2vDYYi/\u0012\u0002B0s\u0005VYuv\u0000VZ2%\u0007TI3'\u0006V\u001b31\u001aW\u00183+\u0011W\u0011v;\u0002\u0000Jc-\u0015\u0007\u001dn3B".toCharArray();
      var10005 = var208.length;
      var10004 = var208;
      int var209 = var10005;

      for(int var24 = 0; var209 > var24; ++var24) {
         char var1023 = var10004[var24];
         byte var1128;
         switch (var24 % 5) {
            case 0:
               var1128 = 40;
               break;
            case 1:
               var1128 = 7;
               break;
            case 2:
               var1128 = 65;
               break;
            case 3:
               var1128 = 119;
               break;
            default:
               var1128 = 49;
         }

         var10004[var24] = (char)(var1023 ^ var1128);
      }

      var10000[19] = (new String(var10004)).intern();
      char[] var211 = "�\u001e".toCharArray();
      var10005 = var211.length;
      var10004 = var211;
      int var212 = var10005;

      for(int var25 = 0; var212 > var25; ++var25) {
         char var1024 = var10004[var25];
         byte var1129;
         switch (var25 % 5) {
            case 0:
               var1129 = 40;
               break;
            case 1:
               var1129 = 7;
               break;
            case 2:
               var1129 = 65;
               break;
            case 3:
               var1129 = 119;
               break;
            default:
               var1129 = 49;
         }

         var10004[var25] = (char)(var1024 ^ var1129);
      }

      var10000[20] = (new String(var10004)).intern();
      char[] var214 = "\u0005mq\u0014SOt-\u001a\u0003[~p\u001dPD}*\u001e\u0001Fl'\u001aA\u001b58\u0006KOrv\u000fUF\u007f'\u0010_Mj,\u001d\t\u001bs-\u0006\u0004\u001ej3\u0005E_v2\u0002\b\u0011\u007f \u0010@Etw\u0007\\Oet\u001c\u0003\u001dl \u0002CA30\u001a\u0002\\u(EUEn C\u0004\u001f?;O\u0000".toCharArray();
      var10005 = var214.length;
      var10004 = var214;
      int var215 = var10005;

      for(int var26 = 0; var215 > var26; ++var26) {
         char var1025 = var10004[var26];
         byte var1130;
         switch (var26 % 5) {
            case 0:
               var1130 = 40;
               break;
            case 1:
               var1130 = 7;
               break;
            case 2:
               var1130 = 65;
               break;
            case 3:
               var1130 = 119;
               break;
            default:
               var1130 = 49;
         }

         var10004[var26] = (char)(var1025 ^ var1130);
      }

      var10000[21] = (new String(var10004)).intern();
      char[] var217 = "C2/\u0013\u0007Dq1\u0019WY09FWYo7NE\\b3\u001dEXlx\u0003W\u001frw\u001a\u0005Yn/\u0015ZJm.@\u0007\u001fr4E\t\u001e4(\u0013\t\u0010k2\u001fVM0%\u0005PF0(@F\u001f12\u001bPKp9\u001eHYu\"O\u0002\u001c~;@\u0006Rk AW]uy\u0006".toCharArray();
      var10005 = var217.length;
      var10004 = var217;
      int var218 = var10005;

      for(int var27 = 0; var218 > var27; ++var27) {
         char var1026 = var10004[var27];
         byte var1131;
         switch (var27 % 5) {
            case 0:
               var1131 = 40;
               break;
            case 1:
               var1131 = 7;
               break;
            case 2:
               var1131 = 65;
               break;
            case 3:
               var1131 = 119;
               break;
            default:
               var1131 = 49;
         }

         var10004[var27] = (char)(var1026 ^ var1131);
      }

      var10000[22] = (new String(var10004)).intern();
      char[] var220 = "Jￚ".toCharArray();
      var10005 = var220.length;
      var10004 = var220;
      int var221 = var10005;

      for(int var28 = 0; var221 > var28; ++var28) {
         char var1027 = var10004[var28];
         byte var1132;
         switch (var28 % 5) {
            case 0:
               var1132 = 40;
               break;
            case 1:
               var1132 = 7;
               break;
            case 2:
               var1132 = 65;
               break;
            case 3:
               var1132 = 119;
               break;
            default:
               var1132 = 49;
         }

         var10004[var28] = (char)(var1027 ^ var1132);
      }

      var10000[23] = (new String(var10004)).intern();
      char[] var223 = "\u001eq%\u001b\u0004F06N\u0005\\?5FT_n3\u0007\u0003@a%NZ\u001d\u007f1\u0002\u0007IlxN\u0000@>pBILj+\u0018GGu;@R^pp\u0000SC2*\u0004\u0003\\3#\u0007WAa9\r\u0007\u0018m/\u0006\u0000A?+DF\u001bn)\u000fW[74\u001bR\u0011qt\u0015W]\u007fx\u001e".toCharArray();
      var10005 = var223.length;
      var10004 = var223;
      int var224 = var10005;

      for(int var29 = 0; var224 > var29; ++var29) {
         char var1028 = var10004[var29];
         byte var1133;
         switch (var29 % 5) {
            case 0:
               var1133 = 40;
               break;
            case 1:
               var1133 = 7;
               break;
            case 2:
               var1133 = 65;
               break;
            case 3:
               var1133 = 119;
               break;
            default:
               var1133 = 49;
         }

         var10004[var29] = (char)(var1028 ^ var1133);
      }

      var10000[24] = (new String(var10004)).intern();
      char[] var226 = "ﾫﾾ".toCharArray();
      var10005 = var226.length;
      var10004 = var226;
      int var227 = var10005;

      for(int var30 = 0; var227 > var30; ++var30) {
         char var1029 = var10004[var30];
         byte var1134;
         switch (var30 % 5) {
            case 0:
               var1134 = 40;
               break;
            case 1:
               var1134 = 7;
               break;
            case 2:
               var1134 = 65;
               break;
            case 3:
               var1134 = 119;
               break;
            default:
               var1134 = 49;
         }

         var10004[var30] = (char)(var1029 ^ var1134);
      }

      var10000[25] = (new String(var10004)).intern();
      char[] var229 = "\u00050%\u001aU\u001f`+EDFm\"\u001cDXc,\u001aTN\u007f#\u0004\u0001A~ \u0014YAq9\u001dC\u00105r\u0015SNb-E\t]`)\u0002@^>;\u0006XZkr\u0005\\^0\"E^_6)\u0013\u0004X>$\u0001@Eu/\u0003A_r$DIJ\u007f+\u0003\u0001AhrE\u0000E5w\u0014T".toCharArray();
      var10005 = var229.length;
      var10004 = var229;
      int var230 = var10005;

      for(int var31 = 0; var230 > var31; ++var31) {
         char var1030 = var10004[var31];
         byte var1135;
         switch (var31 % 5) {
            case 0:
               var1135 = 40;
               break;
            case 1:
               var1135 = 7;
               break;
            case 2:
               var1135 = 65;
               break;
            case 3:
               var1135 = 119;
               break;
            default:
               var1135 = 49;
         }

         var10004[var31] = (char)(var1030 ^ var1135);
      }

      var10000[26] = (new String(var10004)).intern();
      char[] var232 = "\u000533O\bBa%O[\u0011q'\u0015Z@r(D\t\u001b61\u0013PA?*\u0014_\\d5\u0015HAqu\rFE\u007f4\u001cS^24\u0007\u0003\u00112q\u0014@\u0011l(\u001b\u0007\u001cs5\u0001\bI?$BINs\"\u0010SXv+NZ]d/\u0019EFr$\u000eEKws\u001bB\u001c4 \u0014A".toCharArray();
      var10005 = var232.length;
      var10004 = var232;
      int var233 = var10005;

      for(int var32 = 0; var233 > var32; ++var32) {
         char var1031 = var10004[var32];
         byte var1136;
         switch (var32 % 5) {
            case 0:
               var1136 = 40;
               break;
            case 1:
               var1136 = 7;
               break;
            case 2:
               var1136 = 65;
               break;
            case 3:
               var1136 = 119;
               break;
            default:
               var1136 = 49;
         }

         var10004[var32] = (char)(var1031 ^ var1136);
      }

      var10000[27] = (new String(var10004)).intern();
      char[] var235 = "No*\u0006GG4q\u001b\t\u00116t\u0019RD}p\u0019FO>'GFQ4/\u001bCP`)\u0002[Dk7B\u0003I1uCZD>9\u0003K\u0019i%G@O`.\u001cY\u0011n-\u0004V\u001dpu\u0018WY?+\u0005GG~7\u0002A]c*OFCm,\u0012\u0006\u001c7y\u0006\u0003N40\u0005".toCharArray();
      var10005 = var235.length;
      var10004 = var235;
      int var236 = var10005;

      for(int var33 = 0; var236 > var33; ++var33) {
         char var1032 = var10004[var33];
         byte var1137;
         switch (var33 % 5) {
            case 0:
               var1137 = 40;
               break;
            case 1:
               var1137 = 7;
               break;
            case 2:
               var1137 = 65;
               break;
            case 3:
               var1137 = 119;
               break;
            default:
               var1137 = 49;
         }

         var10004[var33] = (char)(var1032 ^ var1137);
      }

      var10000[28] = (new String(var10004)).intern();
      char[] var238 = "\u001abp\u0019X\u0018a$OT\u001bq)\u0006\u0001Art\u0001FX6 \u0001BX~p\u0014PDd;\u0001XPp5C@Bfy\u000fW\u0018m)\u0000\u0002E`-\u0018WNmx\u0014\\Gu+\u0002S\u001a`&\u0014\u0005\u001bbw\u0010\u0004\u0010a*\u001f\tN5#@ILe(\u0014BOt.\u0018IRi(\u001f".toCharArray();
      var10005 = var238.length;
      var10004 = var238;
      int var239 = var10005;

      for(int var34 = 0; var239 > var34; ++var34) {
         char var1033 = var10004[var34];
         byte var1138;
         switch (var34 % 5) {
            case 0:
               var1138 = 40;
               break;
            case 1:
               var1138 = 7;
               break;
            case 2:
               var1138 = 65;
               break;
            case 3:
               var1138 = 119;
               break;
            default:
               var1138 = 49;
         }

         var10004[var34] = (char)(var1033 ^ var1138);
      }

      var10000[29] = (new String(var10004)).intern();
      char[] var241 = "\u0005?uCSPk&\u0003V\u001fbr\u0019R[nt\u0010CYv%AIMtw\u0005H\u00101)\u0012\u0005\u0019tq\u0000YEp$\u0004\b\u0019jx\u0012I\u001aos\u0010\u0006\u001e3x\u0012PDq'FZCt2\u0019CZi&DX_? \u0014S[p9@\tDaw\u0003AIa-\u001eYFqu\u0010".toCharArray();
      var10005 = var241.length;
      var10004 = var241;
      int var242 = var10005;

      for(int var35 = 0; var242 > var35; ++var35) {
         char var1034 = var10004[var35];
         byte var1139;
         switch (var35 % 5) {
            case 0:
               var1139 = 40;
               break;
            case 1:
               var1139 = 7;
               break;
            case 2:
               var1139 = 65;
               break;
            case 3:
               var1139 = 119;
               break;
            default:
               var1139 = 49;
         }

         var10004[var35] = (char)(var1034 ^ var1139);
      }

      var10000[30] = (new String(var10004)).intern();
      char[] var244 = "\u0005j4N@Ct*GI\u0010c-\u0014UCat\u001eI_5;\u0016^\u001ee2OS\u001eq \u0002XB3,\u0019T\u001cwt\u0002]B7s\u0015\tM?%\u0014[A0.\u0005\u0003Aq%\u001eXQ22@CPa1\u0010\t\u001cl'\u001d\bNu(\u0014SOh7G\u0003X0/\u0003FMh7\u0007".toCharArray();
      var10005 = var244.length;
      var10004 = var244;
      int var245 = var10005;

      for(int var36 = 0; var245 > var36; ++var36) {
         char var1035 = var10004[var36];
         byte var1140;
         switch (var36 % 5) {
            case 0:
               var1140 = 40;
               break;
            case 1:
               var1140 = 7;
               break;
            case 2:
               var1140 = 65;
               break;
            case 3:
               var1140 = 119;
               break;
            default:
               var1140 = 49;
         }

         var10004[var36] = (char)(var1035 ^ var1140);
      }

      var10000[31] = (new String(var10004)).intern();
      char[] var247 = "\u0005`7\u0018ZYo A\u0005X2'\u0007^_s8GR\\>(D@]tr@\u0007@>0\u0018DK2+\u000fBC5q\u0007\u0007\u001epq\u001c\\P30\u0006IEp#\u0001G\u00112-\r\u0001\u001ajw\u001dIL1wNIE~3BXZ?#O@Os0EA\u001em(\u000f\u0005\u00105tN\u0004".toCharArray();
      var10005 = var247.length;
      var10004 = var247;
      int var248 = var10005;

      for(int var37 = 0; var248 > var37; ++var37) {
         char var1036 = var10004[var37];
         byte var1141;
         switch (var37 % 5) {
            case 0:
               var1141 = 40;
               break;
            case 1:
               var1141 = 7;
               break;
            case 2:
               var1141 = 65;
               break;
            case 3:
               var1141 = 119;
               break;
            default:
               var1141 = 49;
         }

         var10004[var37] = (char)(var1036 ^ var1141);
      }

      var10000[32] = (new String(var10004)).intern();
      char[] var250 = "ﾖx".toCharArray();
      var10005 = var250.length;
      var10004 = var250;
      int var251 = var10005;

      for(int var38 = 0; var251 > var38; ++var38) {
         char var1037 = var10004[var38];
         byte var1142;
         switch (var38 % 5) {
            case 0:
               var1142 = 40;
               break;
            case 1:
               var1142 = 7;
               break;
            case 2:
               var1142 = 65;
               break;
            case 3:
               var1142 = 119;
               break;
            default:
               var1142 = 49;
         }

         var10004[var38] = (char)(var1037 ^ var1142);
      }

      var10000[33] = (new String(var10004)).intern();
      char[] var253 = "5ﾸ".toCharArray();
      var10005 = var253.length;
      var10004 = var253;
      int var254 = var10005;

      for(int var39 = 0; var254 > var39; ++var39) {
         char var1038 = var10004[var39];
         byte var1143;
         switch (var39 % 5) {
            case 0:
               var1143 = 40;
               break;
            case 1:
               var1143 = 7;
               break;
            case 2:
               var1143 = 65;
               break;
            case 3:
               var1143 = 119;
               break;
            default:
               var1143 = 49;
         }

         var10004[var39] = (char)(var1038 ^ var1143);
      }

      var10000[34] = (new String(var10004)).intern();
      char[] var256 = "K3sDG\u001av(\u0015\\Mi*\u0014\u0000\\0,\u001dF^s(E\u0005Qp.DK\u001d}5\u000e\u0007Rey\u0006KGe%\u001cHM03CARr(\u0012S@f/\u000fK\u001106@\u0003_i%\u000e\\Rt6\u0004U\u001ab,\u0019\\Xi$@\t\u00115-\u0016\t]31N]\u001d\u007f9\r".toCharArray();
      var10005 = var256.length;
      var10004 = var256;
      int var257 = var10005;

      for(int var40 = 0; var257 > var40; ++var40) {
         char var1039 = var10004[var40];
         byte var1144;
         switch (var40 % 5) {
            case 0:
               var1144 = 40;
               break;
            case 1:
               var1144 = 7;
               break;
            case 2:
               var1144 = 65;
               break;
            case 3:
               var1144 = 119;
               break;
            default:
               var1144 = 49;
         }

         var10004[var40] = (char)(var1039 ^ var1144);
      }

      var10000[35] = (new String(var10004)).intern();
      char[] var259 = "\u0005?t\u0014\u0004\u001fl+\u000f@Gk*\u0005EKa0\u0013T\u001dr*G\bXes\u001e\u0000P}-C^@u6\u001cH\u00116&NG\u0019v+AV\u001c}6\u000f[Cq\"\u001f\t\\68\u0013\t^\u007f%\u0015\u0006Ge'\u0015RErp\u0005ZZ7+\u001cFJm%\u001d\u0003Q67ADIaxO^".toCharArray();
      var10005 = var259.length;
      var10004 = var259;
      int var260 = var10005;

      for(int var41 = 0; var260 > var41; ++var41) {
         char var1040 = var10004[var41];
         byte var1145;
         switch (var41 % 5) {
            case 0:
               var1145 = 40;
               break;
            case 1:
               var1145 = 7;
               break;
            case 2:
               var1145 = 65;
               break;
            case 3:
               var1145 = 119;
               break;
            default:
               var1145 = 49;
         }

         var10004[var41] = (char)(var1040 ^ var1145);
      }

      var10000[36] = (new String(var10004)).intern();
      char[] var262 = "\u001a06\u001cFE0.F[Zq%GHCtq\u0007\u0002\u0011~+\u0006TDf*\u0010\u0001C>#B\u0000^ps\u000fKMc.\u0011DO2r\u0019A_ap\u0011AMw0G\u0000Am5A@A>1\u0016@Ot,\u0002]Lu8\u000e\u0000Rv-\u0019P\u0019h4\u000e^\\4'BVZ\u007fu\u0001".toCharArray();
      var10005 = var262.length;
      var10004 = var262;
      int var263 = var10005;

      for(int var42 = 0; var263 > var42; ++var42) {
         char var1041 = var10004[var42];
         byte var1146;
         switch (var42 % 5) {
            case 0:
               var1146 = 40;
               break;
            case 1:
               var1146 = 7;
               break;
            case 2:
               var1146 = 65;
               break;
            case 3:
               var1146 = 119;
               break;
            default:
               var1146 = 49;
         }

         var10004[var42] = (char)(var1041 ^ var1146);
      }

      var10000[37] = (new String(var10004)).intern();
      char[] var265 = "k￣".toCharArray();
      var10005 = var265.length;
      var10004 = var265;
      int var266 = var10005;

      for(int var43 = 0; var266 > var43; ++var43) {
         char var1042 = var10004[var43];
         byte var1147;
         switch (var43 % 5) {
            case 0:
               var1147 = 40;
               break;
            case 1:
               var1147 = 7;
               break;
            case 2:
               var1147 = 65;
               break;
            case 3:
               var1147 = 119;
               break;
            default:
               var1147 = 49;
         }

         var10004[var43] = (char)(var1042 ^ var1147);
      }

      var10000[38] = (new String(var10004)).intern();
      char[] var268 = "\uffc1ﾡ".toCharArray();
      var10005 = var268.length;
      var10004 = var268;
      int var269 = var10005;

      for(int var44 = 0; var269 > var44; ++var44) {
         char var1043 = var10004[var44];
         byte var1148;
         switch (var44 % 5) {
            case 0:
               var1148 = 40;
               break;
            case 1:
               var1148 = 7;
               break;
            case 2:
               var1148 = 65;
               break;
            case 3:
               var1148 = 119;
               break;
            default:
               var1148 = 49;
         }

         var10004[var44] = (char)(var1043 ^ var1148);
      }

      var10000[39] = (new String(var10004)).intern();
      char[] var271 = "[79\u0019R\u001fd;E\u0004F\u007f @YX06\rWC0x\u001bW_t\"\u0005X\u0011o8\u001fFX6uA\u0004]v\"\u001e\u0004Me3\u001eAM~/DDB41\u0004\u0005@c0EXXh.\u0012B]uw\u0002AA44\u000e_\u0018e(\u0003EF3p\u0006BB41\u0015K\u001048".toCharArray();
      var10005 = var271.length;
      var10004 = var271;
      int var272 = var10005;

      for(int var45 = 0; var272 > var45; ++var45) {
         char var1044 = var10004[var45];
         byte var1149;
         switch (var45 % 5) {
            case 0:
               var1149 = 40;
               break;
            case 1:
               var1149 = 7;
               break;
            case 2:
               var1149 = 65;
               break;
            case 3:
               var1149 = 119;
               break;
            default:
               var1149 = 49;
         }

         var10004[var45] = (char)(var1044 ^ var1149);
      }

      var10000[40] = (new String(var10004)).intern();
      char[] var274 = "\u0005>p\u001fPA7+\u001fK\u001c0*\u0010\u0000\u0011k \u0014H\\cxNWNs*\u0000C\u001c6.@]]m,OBZv0\u0007\u0002Fsu\u001fWF3rOXE?x\u000e\u0005Pj,F\\C0p\u0002[O42\u001a\u0001Qm0BU\u001f`8\u0018\\E}1E\u0000\u0010lv\r\t\u00100;\u0015\u0004".toCharArray();
      var10005 = var274.length;
      var10004 = var274;
      int var275 = var10005;

      for(int var46 = 0; var275 > var46; ++var46) {
         char var1045 = var10004[var46];
         byte var1150;
         switch (var46 % 5) {
            case 0:
               var1150 = 40;
               break;
            case 1:
               var1150 = 7;
               break;
            case 2:
               var1150 = 65;
               break;
            case 3:
               var1150 = 119;
               break;
            default:
               var1150 = 49;
         }

         var10004[var46] = (char)(var1045 ^ var1150);
      }

      var10000[41] = (new String(var10004)).intern();
      char[] var277 = "\u0005o3\u0018FA37\u0012AM6w\u001cXCk+\u0013\u0000^my\u0015UOnw\u0003SYj1\u0010AZ5'\u0014X\u001ap5\u001dFEmr\u0003]@qvF\u0002Z~xOXR72E\u0001\\v/AH\u001bv$CC@v+\u0015BB08\u0007\u0004Qi;\u0013W\u001ddw\u0000S\u0010j;\u0000B".toCharArray();
      var10005 = var277.length;
      var10004 = var277;
      int var278 = var10005;

      for(int var47 = 0; var278 > var47; ++var47) {
         char var1046 = var10004[var47];
         byte var1151;
         switch (var47 % 5) {
            case 0:
               var1151 = 40;
               break;
            case 1:
               var1151 = 7;
               break;
            case 2:
               var1151 = 65;
               break;
            case 3:
               var1151 = 119;
               break;
            default:
               var1151 = 49;
         }

         var10004[var47] = (char)(var1046 ^ var1151);
      }

      var10000[42] = (new String(var10004)).intern();
      char[] var280 = "\u0005>pB\u0004Q1w\u0019WI?\"\u0012\u0005On+\u0007IJf)\u0013FYe,\u0014\u0003Ad%\u0013KL2'\u001f@C0#\u0012\u0000[sy\u0018W[t'\u0012ZR0r\u0011A\u0018ew\u0011AGp)\u001aTL}vC__up\u001f\u0001M>\"A\u0004P},GKBu3D\t\u001928\u0011\u0005".toCharArray();
      var10005 = var280.length;
      var10004 = var280;
      int var281 = var10005;

      for(int var48 = 0; var281 > var48; ++var48) {
         char var1047 = var10004[var48];
         byte var1152;
         switch (var48 % 5) {
            case 0:
               var1152 = 40;
               break;
            case 1:
               var1152 = 7;
               break;
            case 2:
               var1152 = 65;
               break;
            case 3:
               var1152 = 119;
               break;
            default:
               var1152 = 49;
         }

         var10004[var48] = (char)(var1047 ^ var1152);
      }

      var10000[43] = (new String(var10004)).intern();
      char[] var283 = "Mep\u0005BNh)FT\u0018d6NIKa4\u0003W\u001d`(\u0004[Pb7\u001dWLd*\u0004FKo.\u001aZOh1\u0013[Zt*FK_m;\u001e\u0000\u001fe6\u0003\u0000C\u007f&\u000eUG2p\u0016UR3vO\u0006Dd3\u0005[Yl$DC^~t\u0003\bQb2\u000fCD?5\u0007".toCharArray();
      var10005 = var283.length;
      var10004 = var283;
      int var284 = var10005;

      for(int var49 = 0; var284 > var49; ++var49) {
         char var1048 = var10004[var49];
         byte var1153;
         switch (var49 % 5) {
            case 0:
               var1153 = 40;
               break;
            case 1:
               var1153 = 7;
               break;
            case 2:
               var1153 = 65;
               break;
            case 3:
               var1153 = 119;
               break;
            default:
               var1153 = 49;
         }

         var10004[var49] = (char)(var1048 ^ var1153);
      }

      var10000[44] = (new String(var10004)).intern();
      char[] var286 = "\u001c2,\u0003@EqqOP\u0010mt\u0003WQ}8\u0014\u0001L4*\u0004AK50\u0012XI}w\u0015\t@0)FH^q\"\u0018V\u0019r#N\u0003R7q\u000fV]ft\u0004H\u001d?$\u0014\\J~/\u0005\u0002G0v\u0006RIw'\u001d_\u001c7.\u001e\u0003Y>9\u001aTYh7\rC_m8\u001d".toCharArray();
      var10005 = var286.length;
      var10004 = var286;
      int var287 = var10005;

      for(int var50 = 0; var287 > var50; ++var50) {
         char var1049 = var10004[var50];
         byte var1154;
         switch (var50 % 5) {
            case 0:
               var1154 = 40;
               break;
            case 1:
               var1154 = 7;
               break;
            case 2:
               var1154 = 65;
               break;
            case 3:
               var1154 = 119;
               break;
            default:
               var1154 = 49;
         }

         var10004[var50] = (char)(var1049 ^ var1154);
      }

      var10000[45] = (new String(var10004)).intern();
      char[] var289 = "\u000506DG\u001dk\"\u000f\u0000Fl \u0011[\u001d>$N^@ht\u0000]Gv\"\u0006[Ev;\u0013HMr\"\u0003\bA71\u0012_Ci*\u001fE\u001e}.\u001dVC6r\u0007K\u0011?\"G\u0007I?tA_\u001awq\u0013RRtu\u0001\u0002D02DFL>3\u0015F\u001d3t\u0014P\u001fh9\u001f\\".toCharArray();
      var10005 = var289.length;
      var10004 = var289;
      int var290 = var10005;

      for(int var51 = 0; var290 > var51; ++var51) {
         char var1050 = var10004[var51];
         byte var1155;
         switch (var51 % 5) {
            case 0:
               var1155 = 40;
               break;
            case 1:
               var1155 = 7;
               break;
            case 2:
               var1155 = 65;
               break;
            case 3:
               var1155 = 119;
               break;
            default:
               var1155 = 49;
         }

         var10004[var51] = (char)(var1050 ^ var1155);
      }

      var10000[46] = (new String(var10004)).intern();
      char[] var292 = "Je8\u0000^\u0018fp\u0000[F5uAT\u001auqN^Il3OKDm6\u001bEZu+\u001e\tB7v\u0010\bEuw\u0010\u0006\u001cmw\u000e\u0006Kru\u001c\u0001N\u007f(@W\\6.\u0011G\u0018hv\u001aCJw(\u000eT@f'\u0007WOu4C\u0003Njq\u001d\t\\h;\u0004W\u001da\"A".toCharArray();
      var10005 = var292.length;
      var10004 = var292;
      int var293 = var10005;

      for(int var52 = 0; var293 > var52; ++var52) {
         char var1051 = var10004[var52];
         byte var1156;
         switch (var52 % 5) {
            case 0:
               var1156 = 40;
               break;
            case 1:
               var1156 = 7;
               break;
            case 2:
               var1156 = 65;
               break;
            case 3:
               var1156 = 119;
               break;
            default:
               var1156 = 49;
         }

         var10004[var52] = (char)(var1051 ^ var1156);
      }

      var10000[47] = (new String(var10004)).intern();
      char[] var295 = "?\uffc8".toCharArray();
      var10005 = var295.length;
      var10004 = var295;
      int var296 = var10005;

      for(int var53 = 0; var296 > var53; ++var53) {
         char var1052 = var10004[var53];
         byte var1157;
         switch (var53 % 5) {
            case 0:
               var1157 = 40;
               break;
            case 1:
               var1157 = 7;
               break;
            case 2:
               var1157 = 65;
               break;
            case 3:
               var1157 = 119;
               break;
            default:
               var1157 = 49;
         }

         var10004[var53] = (char)(var1052 ^ var1157);
      }

      var10000[48] = (new String(var10004)).intern();
      char[] var298 = "L￡".toCharArray();
      var10005 = var298.length;
      var10004 = var298;
      int var299 = var10005;

      for(int var54 = 0; var299 > var54; ++var54) {
         char var1053 = var10004[var54];
         byte var1158;
         switch (var54 % 5) {
            case 0:
               var1158 = 40;
               break;
            case 1:
               var1158 = 7;
               break;
            case 2:
               var1158 = 65;
               break;
            case 3:
               var1158 = 119;
               break;
            default:
               var1158 = 49;
         }

         var10004[var54] = (char)(var1053 ^ var1158);
      }

      var10000[49] = (new String(var10004)).intern();
      char[] var301 = "Id)GI\u001b5&\u0006TY1y\u000fPDh7\u001a@R29\u0016[Ae*\u000fWL7t\u0013T\u001fp6E\u0005\u0019ayG\u0006\u001abq\u0001]Kv.\u001fTF5/\u0003\u0001Rb4\u0011FDv\"ES^}q\u0016TOr2\u0019\u0006\\v(\u0002F]}(\u001aFQ>+\u001dXPl)\u0004".toCharArray();
      var10005 = var301.length;
      var10004 = var301;
      int var302 = var10005;

      for(int var55 = 0; var302 > var55; ++var55) {
         char var1054 = var10004[var55];
         byte var1159;
         switch (var55 % 5) {
            case 0:
               var1159 = 40;
               break;
            case 1:
               var1159 = 7;
               break;
            case 2:
               var1159 = 65;
               break;
            case 3:
               var1159 = 119;
               break;
            default:
               var1159 = 49;
         }

         var10004[var55] = (char)(var1054 ^ var1159);
      }

      var10000[50] = (new String(var10004)).intern();
      char[] var304 = "mc".toCharArray();
      var10005 = var304.length;
      var10004 = var304;
      int var305 = var10005;

      for(int var56 = 0; var305 > var56; ++var56) {
         char var1055 = var10004[var56];
         byte var1160;
         switch (var56 % 5) {
            case 0:
               var1160 = 40;
               break;
            case 1:
               var1160 = 7;
               break;
            case 2:
               var1160 = 65;
               break;
            case 3:
               var1160 = 119;
               break;
            default:
               var1160 = 49;
         }

         var10004[var56] = (char)(var1055 ^ var1160);
      }

      var10000[51] = (new String(var10004)).intern();
      char[] var307 = "ￂ￥".toCharArray();
      var10005 = var307.length;
      var10004 = var307;
      int var308 = var10005;

      for(int var57 = 0; var308 > var57; ++var57) {
         char var1056 = var10004[var57];
         byte var1161;
         switch (var57 % 5) {
            case 0:
               var1161 = 40;
               break;
            case 1:
               var1161 = 7;
               break;
            case 2:
               var1161 = 65;
               break;
            case 3:
               var1161 = 119;
               break;
            default:
               var1161 = 49;
         }

         var10004[var57] = (char)(var1056 ^ var1161);
      }

      var10000[52] = (new String(var10004)).intern();
      char[] var310 = "\u0005o9\u0005\u0000_h4\u0016RK1y\u000e@_\u007f0\u0006\u0007\u0019n+OHN~*A\u0004Ap/\u001cUZ\u007f.EICc4\u0019IXa2\u0000WL};\u0019BCa0\u0001\u0006\u001a\u007fp\u0010A\\?v\u0001\u0001Frw\u0010I\u001fmuF\u0004\u001d`%\u0007G^j)\u0003\u0001E\u007f+\u0002EBi5N\u0006".toCharArray();
      var10005 = var310.length;
      var10004 = var310;
      int var311 = var10005;

      for(int var58 = 0; var311 > var58; ++var58) {
         char var1057 = var10004[var58];
         byte var1162;
         switch (var58 % 5) {
            case 0:
               var1162 = 40;
               break;
            case 1:
               var1162 = 7;
               break;
            case 2:
               var1162 = 65;
               break;
            case 3:
               var1162 = 119;
               break;
            default:
               var1162 = 49;
         }

         var10004[var58] = (char)(var1057 ^ var1162);
      }

      var10000[53] = (new String(var10004)).intern();
      char[] var313 = "@68\u001cE_3(D\u0001\u0010k%\u0002\u0001\u001erq\u000eVA~0EHKw0\u0018@Af9\u000eFPep\u0007_\u0010h0\u0005\\Inr\u0014\u0007^b0\u0013\\\u001c54\u0006\u0005\u001e~%\u001eU@nx\u000e[\u001de'\u0013@]w#D\u0005\u0010jx\u001fK\u001bi;\u0007AR24\u0011\u0006OvtD".toCharArray();
      var10005 = var313.length;
      var10004 = var313;
      int var314 = var10005;

      for(int var59 = 0; var314 > var59; ++var59) {
         char var1058 = var10004[var59];
         byte var1163;
         switch (var59 % 5) {
            case 0:
               var1163 = 40;
               break;
            case 1:
               var1163 = 7;
               break;
            case 2:
               var1163 = 65;
               break;
            case 3:
               var1163 = 119;
               break;
            default:
               var1163 = 49;
         }

         var10004[var59] = (char)(var1058 ^ var1163);
      }

      var10000[54] = (new String(var10004)).intern();
      char[] var316 = "9-".toCharArray();
      var10005 = var316.length;
      var10004 = var316;
      int var317 = var10005;

      for(int var60 = 0; var317 > var60; ++var60) {
         char var1059 = var10004[var60];
         byte var1164;
         switch (var60 % 5) {
            case 0:
               var1164 = 40;
               break;
            case 1:
               var1164 = 7;
               break;
            case 2:
               var1164 = 65;
               break;
            case 3:
               var1164 = 119;
               break;
            default:
               var1164 = 49;
         }

         var10004[var60] = (char)(var1059 ^ var1164);
      }

      var10000[55] = (new String(var10004)).intern();
      char[] var319 = "N77\u0014\u0003Na#E\u0006FmuA\\\u0011?v\u0004DYu\"\u0011KK>+\u000e\u0007\\iv\u0015K\u001fsp\u0007[E07\u0019POu.\u0003EBvvF[\u00113w\u0005\\Lr#DTC\u007f1\u0007\u0005Qv/\u0014\u0002Kr%\u0014P\u0019pv\u0002FG60DS\u001d`1E\u0003\u001a7q@".toCharArray();
      var10005 = var319.length;
      var10004 = var319;
      int var320 = var10005;

      for(int var61 = 0; var320 > var61; ++var61) {
         char var1060 = var10004[var61];
         byte var1165;
         switch (var61 % 5) {
            case 0:
               var1165 = 40;
               break;
            case 1:
               var1165 = 7;
               break;
            case 2:
               var1165 = 65;
               break;
            case 3:
               var1165 = 119;
               break;
            default:
               var1165 = 49;
         }

         var10004[var61] = (char)(var1060 ^ var1165);
      }

      var10000[56] = (new String(var10004)).intern();
      char[] var322 = "\u0017\uffdf".toCharArray();
      var10005 = var322.length;
      var10004 = var322;
      int var323 = var10005;

      for(int var62 = 0; var323 > var62; ++var62) {
         char var1061 = var10004[var62];
         byte var1166;
         switch (var62 % 5) {
            case 0:
               var1166 = 40;
               break;
            case 1:
               var1166 = 7;
               break;
            case 2:
               var1166 = 65;
               break;
            case 3:
               var1166 = 119;
               break;
            default:
               var1166 = 49;
         }

         var10004[var62] = (char)(var1061 ^ var1166);
      }

      var10000[57] = (new String(var10004)).intern();
      char[] var325 = "|ﾇ".toCharArray();
      var10005 = var325.length;
      var10004 = var325;
      int var326 = var10005;

      for(int var63 = 0; var326 > var63; ++var63) {
         char var1062 = var10004[var63];
         byte var1167;
         switch (var63 % 5) {
            case 0:
               var1167 = 40;
               break;
            case 1:
               var1167 = 7;
               break;
            case 2:
               var1167 = 65;
               break;
            case 3:
               var1167 = 119;
               break;
            default:
               var1167 = 49;
         }

         var10004[var63] = (char)(var1062 ^ var1167);
      }

      var10000[58] = (new String(var10004)).intern();
      char[] var328 = "\b\u0002".toCharArray();
      var10005 = var328.length;
      var10004 = var328;
      int var329 = var10005;

      for(int var64 = 0; var329 > var64; ++var64) {
         char var1063 = var10004[var64];
         byte var1168;
         switch (var64 % 5) {
            case 0:
               var1168 = 40;
               break;
            case 1:
               var1168 = 7;
               break;
            case 2:
               var1168 = 65;
               break;
            case 3:
               var1168 = 119;
               break;
            default:
               var1168 = 49;
         }

         var10004[var64] = (char)(var1063 ^ var1168);
      }

      var10000[59] = (new String(var10004)).intern();
      char[] var331 = "ￍﾭ".toCharArray();
      var10005 = var331.length;
      var10004 = var331;
      int var332 = var10005;

      for(int var65 = 0; var332 > var65; ++var65) {
         char var1064 = var10004[var65];
         byte var1169;
         switch (var65 % 5) {
            case 0:
               var1169 = 40;
               break;
            case 1:
               var1169 = 7;
               break;
            case 2:
               var1169 = 65;
               break;
            case 3:
               var1169 = 119;
               break;
            default:
               var1169 = 49;
         }

         var10004[var65] = (char)(var1064 ^ var1169);
      }

      var10000[60] = (new String(var10004)).intern();
      char[] var334 = "A3%\u0001^\u001eo9\u001aX^k0CDIt7\u0006^C6p\u0012KQks\u000e_]r(D]Ko#\u0014G_a8\u0016CO7.AV]57\u0015\b\u0018?;\u000e_\u00184rEI\u001bh5\u0005IL02\u001aSMs(FYAkt\u0010PMo&EB\u001921\u0000^C?(E".toCharArray();
      var10005 = var334.length;
      var10004 = var334;
      int var335 = var10005;

      for(int var66 = 0; var335 > var66; ++var66) {
         char var1065 = var10004[var66];
         byte var1170;
         switch (var66 % 5) {
            case 0:
               var1170 = 40;
               break;
            case 1:
               var1170 = 7;
               break;
            case 2:
               var1170 = 65;
               break;
            case 3:
               var1170 = 119;
               break;
            default:
               var1170 = 49;
         }

         var10004[var66] = (char)(var1065 ^ var1170);
      }

      var10000[61] = (new String(var10004)).intern();
      char[] var337 = "\u0005et\u001d\t\u001a}%E\u0005\u001eoq\rE\u001fwp\u0006_I3)\u0010\u0001N`1\u0007U_4w\u0004X\u001b72\u0007PA~v\u0006EDwv\u001fR@>7\u001dXLv$\u0003C\u0019dx\u0012\u0007\u001dw-\u0015\\@1#\u0002EQj2GWM\u007f9\u0006E@k7\u0005\u0004]l4\u0019K\u001ctw\r\u0001".toCharArray();
      var10005 = var337.length;
      var10004 = var337;
      int var338 = var10005;

      for(int var67 = 0; var338 > var67; ++var67) {
         char var1066 = var10004[var67];
         byte var1171;
         switch (var67 % 5) {
            case 0:
               var1171 = 40;
               break;
            case 1:
               var1171 = 7;
               break;
            case 2:
               var1171 = 65;
               break;
            case 3:
               var1171 = 119;
               break;
            default:
               var1171 = 49;
         }

         var10004[var67] = (char)(var1066 ^ var1171);
      }

      var10000[62] = (new String(var10004)).intern();
      char[] var340 = "Lrx\u0010W]o \u0000@P~6\u0011\u0000[j3\u001cCZ\u007f%\u0007FZt \u001b\u0005\\>(A\t\\~tNH\u001ft/\u0015REp6\u0002FMq9FIDu*\u0015P\u001cl#@[O?5\u0003\u0004\\e(\u001dR\u001dl8\u0005UJs7\u0018FFe;\u001cDD?8\u0006\u0007Cl%\u001f".toCharArray();
      var10005 = var340.length;
      var10004 = var340;
      int var341 = var10005;

      for(int var68 = 0; var341 > var68; ++var68) {
         char var1067 = var10004[var68];
         byte var1172;
         switch (var68 % 5) {
            case 0:
               var1172 = 40;
               break;
            case 1:
               var1172 = 7;
               break;
            case 2:
               var1172 = 65;
               break;
            case 3:
               var1172 = 119;
               break;
            default:
               var1172 = 49;
         }

         var10004[var68] = (char)(var1067 ^ var1172);
      }

      var10000[63] = (new String(var10004)).intern();
      char[] var343 = "\u0011k6GA[30\r_B>y\u001aEDtu\u001aCK73\u001fTEj/\u0001]Fs4\u001b^G~(CD\u001cv*BD\u001ab1\u001bB\u0019dx\u0010\bE3rCXLw;\u0013H_k%\u0000H\u0011p;\u0015\u0005Jf(\u0019IK6q\u001bS\u001bktFW^e\"\u0007EXh&\u001f".toCharArray();
      var10005 = var343.length;
      var10004 = var343;
      int var344 = var10005;

      for(int var69 = 0; var344 > var69; ++var69) {
         char var1068 = var10004[var69];
         byte var1173;
         switch (var69 % 5) {
            case 0:
               var1173 = 40;
               break;
            case 1:
               var1173 = 7;
               break;
            case 2:
               var1173 = 65;
               break;
            case 3:
               var1173 = 119;
               break;
            default:
               var1173 = 49;
         }

         var10004[var69] = (char)(var1068 ^ var1173);
      }

      var10000[64] = (new String(var10004)).intern();
      char[] var346 = "￡￫".toCharArray();
      var10005 = var346.length;
      var10004 = var346;
      int var347 = var10005;

      for(int var70 = 0; var347 > var70; ++var70) {
         char var1069 = var10004[var70];
         byte var1174;
         switch (var70 % 5) {
            case 0:
               var1174 = 40;
               break;
            case 1:
               var1174 = 7;
               break;
            case 2:
               var1174 = 65;
               break;
            case 3:
               var1174 = 119;
               break;
            default:
               var1174 = 49;
         }

         var10004[var70] = (char)(var1069 ^ var1174);
      }

      var10000[65] = (new String(var10004)).intern();
      char[] var349 = "\u0014\t".toCharArray();
      var10005 = var349.length;
      var10004 = var349;
      int var350 = var10005;

      for(int var71 = 0; var350 > var71; ++var71) {
         char var1070 = var10004[var71];
         byte var1175;
         switch (var71 % 5) {
            case 0:
               var1175 = 40;
               break;
            case 1:
               var1175 = 7;
               break;
            case 2:
               var1175 = 65;
               break;
            case 3:
               var1175 = 119;
               break;
            default:
               var1175 = 49;
         }

         var10004[var71] = (char)(var1070 ^ var1175);
      }

      var10000[66] = (new String(var10004)).intern();
      char[] var352 = "],".toCharArray();
      var10005 = var352.length;
      var10004 = var352;
      int var353 = var10005;

      for(int var72 = 0; var353 > var72; ++var72) {
         char var1071 = var10004[var72];
         byte var1176;
         switch (var72 % 5) {
            case 0:
               var1176 = 40;
               break;
            case 1:
               var1176 = 7;
               break;
            case 2:
               var1176 = 65;
               break;
            case 3:
               var1176 = 119;
               break;
            default:
               var1176 = 49;
         }

         var10004[var72] = (char)(var1071 ^ var1176);
      }

      var10000[67] = (new String(var10004)).intern();
      char[] var355 = "L09\u0004PE76DEF\u007fr\u0019^\u001a3+\u001f\u0000\u001bm+\u000fYOr(E\bMay\u000eZ_qs\u001dSK3;A\\Ptt\u0001RZi-N^Zt\"D[Kr6\u0002\u0003\u001bm6G[^a#\u000eSF\u007f#\u0012VN}2DSM32\rC]1;\u0007H\u001dhu\u000e".toCharArray();
      var10005 = var355.length;
      var10004 = var355;
      int var356 = var10005;

      for(int var73 = 0; var356 > var73; ++var73) {
         char var1072 = var10004[var73];
         byte var1177;
         switch (var73 % 5) {
            case 0:
               var1177 = 40;
               break;
            case 1:
               var1177 = 7;
               break;
            case 2:
               var1177 = 65;
               break;
            case 3:
               var1177 = 119;
               break;
            default:
               var1177 = 49;
         }

         var10004[var73] = (char)(var1072 ^ var1177);
      }

      var10000[68] = (new String(var10004)).intern();
      char[] var358 = "ﾈﾯ".toCharArray();
      var10005 = var358.length;
      var10004 = var358;
      int var359 = var10005;

      for(int var74 = 0; var359 > var74; ++var74) {
         char var1073 = var10004[var74];
         byte var1178;
         switch (var74 % 5) {
            case 0:
               var1178 = 40;
               break;
            case 1:
               var1178 = 7;
               break;
            case 2:
               var1178 = 65;
               break;
            case 3:
               var1178 = 119;
               break;
            default:
               var1178 = 49;
         }

         var10004[var74] = (char)(var1073 ^ var1178);
      }

      var10000[69] = (new String(var10004)).intern();
      char[] var361 = "ﾧ(".toCharArray();
      var10005 = var361.length;
      var10004 = var361;
      int var362 = var10005;

      for(int var75 = 0; var362 > var75; ++var75) {
         char var1074 = var10004[var75];
         byte var1179;
         switch (var75 % 5) {
            case 0:
               var1179 = 40;
               break;
            case 1:
               var1179 = 7;
               break;
            case 2:
               var1179 = 65;
               break;
            case 3:
               var1179 = 119;
               break;
            default:
               var1179 = 49;
         }

         var10004[var75] = (char)(var1074 ^ var1179);
      }

      var10000[70] = (new String(var10004)).intern();
      char[] var364 = "ﾺ3".toCharArray();
      var10005 = var364.length;
      var10004 = var364;
      int var365 = var10005;

      for(int var76 = 0; var365 > var76; ++var76) {
         char var1075 = var10004[var76];
         byte var1180;
         switch (var76 % 5) {
            case 0:
               var1180 = 40;
               break;
            case 1:
               var1180 = 7;
               break;
            case 2:
               var1180 = 65;
               break;
            case 3:
               var1180 = 119;
               break;
            default:
               var1180 = 49;
         }

         var10004[var76] = (char)(var1075 ^ var1180);
      }

      var10000[71] = (new String(var10004)).intern();
      char[] var367 = "Ii&\u0018\u0001Ywp\u0004CYdv\u0006\u0004^n1\u000eU\u001ajw\u0000[\\tuNS\u001app\r\u0003^l4@]G1vBGLs8\u0014DN7u\u001e_\u0018tp\u0000\\Oq-GS\u0019n.\u000f\u0006Xk\"\u0011Z\u0018>w\u001a[\u0010hr@IE~5\u0001\u0007\u001brw\u001eBD75\u0011".toCharArray();
      var10005 = var367.length;
      var10004 = var367;
      int var368 = var10005;

      for(int var77 = 0; var368 > var77; ++var77) {
         char var1076 = var10004[var77];
         byte var1181;
         switch (var77 % 5) {
            case 0:
               var1181 = 40;
               break;
            case 1:
               var1181 = 7;
               break;
            case 2:
               var1181 = 65;
               break;
            case 3:
               var1181 = 119;
               break;
            default:
               var1181 = 49;
         }

         var10004[var77] = (char)(var1076 ^ var1181);
      }

      var10000[72] = (new String(var10004)).intern();
      char[] var370 = "ￏￅ".toCharArray();
      var10005 = var370.length;
      var10004 = var370;
      int var371 = var10005;

      for(int var78 = 0; var371 > var78; ++var78) {
         char var1077 = var10004[var78];
         byte var1182;
         switch (var78 % 5) {
            case 0:
               var1182 = 40;
               break;
            case 1:
               var1182 = 7;
               break;
            case 2:
               var1182 = 65;
               break;
            case 3:
               var1182 = 119;
               break;
            default:
               var1182 = 49;
         }

         var10004[var78] = (char)(var1077 ^ var1182);
      }

      var10000[73] = (new String(var10004)).intern();
      char[] var373 = "I75OZMr.\u000eB^f-\u0015\u0004]m'\u0015\u0001Ei0\u0018_E01EKQw-\u0002\tG`1\u0007\u0001\u001ah/\u0007^NauB_\u0018d#FXBhv\u0011CEsu\u001aSE18@AF0#C\u0002@70\u0007[Al&\u001cT\u001fwv\u0010Z_os\u0018ZC}yE".toCharArray();
      var10005 = var373.length;
      var10004 = var373;
      int var374 = var10005;

      for(int var79 = 0; var374 > var79; ++var79) {
         char var1078 = var10004[var79];
         byte var1183;
         switch (var79 % 5) {
            case 0:
               var1183 = 40;
               break;
            case 1:
               var1183 = 7;
               break;
            case 2:
               var1183 = 65;
               break;
            case 3:
               var1183 = 119;
               break;
            default:
               var1183 = 49;
         }

         var10004[var79] = (char)(var1078 ^ var1183);
      }

      var10000[74] = (new String(var10004)).intern();
      char[] var376 = "\u0005b/N\b\u0018q.\u001d\u0002\u0019e.C\\]r$OBP>2A\b\u001de#\u001fT\u001b59\u0002G\\2p\u001d\bN`/\u0016\u0000Pp8\u0018PBo0\u000e\u0006Xa'\rE^d2\u0013R\u001cr&CC\u001ckv\u0004IAd6\u001dCAl-\u0015VNs8\u001a\u0007P`(\u0015\u0000Nj&\u001b^".toCharArray();
      var10005 = var376.length;
      var10004 = var376;
      int var377 = var10005;

      for(int var80 = 0; var377 > var80; ++var80) {
         char var1079 = var10004[var80];
         byte var1184;
         switch (var80 % 5) {
            case 0:
               var1184 = 40;
               break;
            case 1:
               var1184 = 7;
               break;
            case 2:
               var1184 = 65;
               break;
            case 3:
               var1184 = 119;
               break;
            default:
               var1184 = 49;
         }

         var10004[var80] = (char)(var1079 ^ var1184);
      }

      var10000[75] = (new String(var10004)).intern();
      char[] var379 = "Lk8\u0001@\u001eby\r^Ao,\u000fV\u001ewq\u0015EJ3&@\u0003Yq\"FP\u0010t\"\u0018F^0qAVO~+\u0000VY`s\u000fI\u001ei3OKMrs\u0006^Lj5\u0002\\\\f\"\u000e\u0000Kc0\u0004\u0001McxOKM?p\u000e@^w&\u0002Y\u001bdyGGDcq\u0001".toCharArray();
      var10005 = var379.length;
      var10004 = var379;
      int var380 = var10005;

      for(int var81 = 0; var380 > var81; ++var81) {
         char var1080 = var10004[var81];
         byte var1185;
         switch (var81 % 5) {
            case 0:
               var1185 = 40;
               break;
            case 1:
               var1185 = 7;
               break;
            case 2:
               var1185 = 65;
               break;
            case 3:
               var1185 = 119;
               break;
            default:
               var1185 = 49;
         }

         var10004[var81] = (char)(var1080 ^ var1185);
      }

      var10000[76] = (new String(var10004)).intern();
      char[] var382 = "$\u0007".toCharArray();
      var10005 = var382.length;
      var10004 = var382;
      int var383 = var10005;

      for(int var82 = 0; var383 > var82; ++var82) {
         char var1081 = var10004[var82];
         byte var1186;
         switch (var82 % 5) {
            case 0:
               var1186 = 40;
               break;
            case 1:
               var1186 = 7;
               break;
            case 2:
               var1186 = 65;
               break;
            case 3:
               var1186 = 119;
               break;
            default:
               var1186 = 49;
         }

         var10004[var82] = (char)(var1081 ^ var1186);
      }

      var10000[77] = (new String(var10004)).intern();
      char[] var385 = "\u00054,\u001cD\u0018m,\u001dX\u0018dy\u0010[P7.\u0012P[n8\u000f@Gj4\u0019\u0002\\o0\u0005]Y49\u0016\t\u0018o&\u001dR\u0019q(\u0011K\u001er7GX\u001bd/\u001bT\u00185x\u0010PKl.F[D6/\u0011\u0003O>)\u001e\u0006\u0011cyNZPc,\u000e^\u001fj*G_Xd \u0011G".toCharArray();
      var10005 = var385.length;
      var10004 = var385;
      int var386 = var10005;

      for(int var83 = 0; var386 > var83; ++var83) {
         char var1082 = var10004[var83];
         byte var1187;
         switch (var83 % 5) {
            case 0:
               var1187 = 40;
               break;
            case 1:
               var1187 = 7;
               break;
            case 2:
               var1187 = 65;
               break;
            case 3:
               var1187 = 119;
               break;
            default:
               var1187 = 49;
         }

         var10004[var83] = (char)(var1082 ^ var1187);
      }

      var10000[78] = (new String(var10004)).intern();
      char[] var388 = "\u0019j;\u000e\u0006\u001cq2\u001e\u0004Q?q\u0000A\u001eu FU\u001csw\u0007R\u001ff4\u0014\u0004\u0011r$\u000eW\u0010a)\u0018C[\u007fxG^B0%ED]59OSRkrA\u0001Jh0\u0012Z\u0010u;\u0019A\u001cqs\u0000\\\u001f50\u0014\u0005\\v/\u0000\u0007\u001ampC\u0002Is&\u0013\u0005X>5\u0016".toCharArray();
      var10005 = var388.length;
      var10004 = var388;
      int var389 = var10005;

      for(int var84 = 0; var389 > var84; ++var84) {
         char var1083 = var10004[var84];
         byte var1188;
         switch (var84 % 5) {
            case 0:
               var1188 = 40;
               break;
            case 1:
               var1188 = 7;
               break;
            case 2:
               var1188 = 65;
               break;
            case 3:
               var1188 = 119;
               break;
            default:
               var1188 = 49;
         }

         var10004[var84] = (char)(var1083 ^ var1188);
      }

      var10000[79] = (new String(var10004)).intern();
      char[] var391 = "\u000511\u0019]\u0019l)@X^ku\u000eAQv(\u0003]Ylp\u001fSN?\"C\t_b#DII`s\u0014DMdp\u0012R\u001bh*\u001b\u0000G>\"\u0018KGr-\u001a_Gnv\u0014W\u001af*\u001e\u0000\\j/\u0002V^04\u0005IO~.@D\u0010`.CH\u00182/\u0005XL53\r\t".toCharArray();
      var10005 = var391.length;
      var10004 = var391;
      int var392 = var10005;

      for(int var85 = 0; var392 > var85; ++var85) {
         char var1084 = var10004[var85];
         byte var1189;
         switch (var85 % 5) {
            case 0:
               var1189 = 40;
               break;
            case 1:
               var1189 = 7;
               break;
            case 2:
               var1189 = 65;
               break;
            case 3:
               var1189 = 119;
               break;
            default:
               var1189 = 49;
         }

         var10004[var85] = (char)(var1084 ^ var1189);
      }

      var10000[80] = (new String(var10004)).intern();
      char[] var394 = "~x".toCharArray();
      var10005 = var394.length;
      var10004 = var394;
      int var395 = var10005;

      for(int var86 = 0; var395 > var86; ++var86) {
         char var1085 = var10004[var86];
         byte var1190;
         switch (var86 % 5) {
            case 0:
               var1190 = 40;
               break;
            case 1:
               var1190 = 7;
               break;
            case 2:
               var1190 = 65;
               break;
            case 3:
               var1190 = 119;
               break;
            default:
               var1190 = 49;
         }

         var10004[var86] = (char)(var1085 ^ var1190);
      }

      var10000[81] = (new String(var10004)).intern();
      char[] var397 = "\u001c1'\u0019YQj/\u0002A\u001b2 D\u0000Q`6\u000fP\u001bf/\r\u0004Cf3CZ^2.OVN5vAPMt \u001fX\u001e},\u0015\u0003\u001en4\u001e\u0004El1\u0014B\u0010r(\u0005FLsqCKAr.@\tNl1\u0013XDsx\u0010Z\\71@\tL0wFRY3v\u0002".toCharArray();
      var10005 = var397.length;
      var10004 = var397;
      int var398 = var10005;

      for(int var87 = 0; var398 > var87; ++var87) {
         char var1086 = var10004[var87];
         byte var1191;
         switch (var87 % 5) {
            case 0:
               var1191 = 40;
               break;
            case 1:
               var1191 = 7;
               break;
            case 2:
               var1191 = 65;
               break;
            case 3:
               var1191 = 119;
               break;
            default:
               var1191 = 49;
         }

         var10004[var87] = (char)(var1086 ^ var1191);
      }

      var10000[82] = (new String(var10004)).intern();
      char[] var400 = "\u00053*\u0012\u0004Rn+\u0018IM\u007f*\u0003\u0001Lsu\u0004T\u001fnp\u001b\u0006N} \u0016HPw4C\bAaw\u0018\u0003Asp\u0010\u0006\u0010}r\u001f_C24\u000fAN3qD\u0000Nms\u0006\u0001Rv\"@@Z4(\u001d\u0002\u00185;\u0003\u0000X7.A\u0005L63\u001a[Ke%\u0010Y\u001dd.GG".toCharArray();
      var10005 = var400.length;
      var10004 = var400;
      int var401 = var10005;

      for(int var88 = 0; var401 > var88; ++var88) {
         char var1087 = var10004[var88];
         byte var1192;
         switch (var88 % 5) {
            case 0:
               var1192 = 40;
               break;
            case 1:
               var1192 = 7;
               break;
            case 2:
               var1192 = 65;
               break;
            case 3:
               var1192 = 119;
               break;
            default:
               var1192 = 49;
         }

         var10004[var88] = (char)(var1087 ^ var1192);
      }

      var10000[83] = (new String(var10004)).intern();
      char[] var403 = "\u0005n6\u000fR\u00196q\u0007^]a \u0000_K4q\u0015[Ybu\u0015V\u0019s\"\u0010WM67\u0005KPf0\u001dVKuu\u001cZI\u007f7EB\u001a7+\u001bK^50OPGa+\u0003SPd$GWJm%\u0019VJdv\u0019\u0003@0r\u001c@\u00184vD^\u0011k3\u0012[@6#\u0015\u0006".toCharArray();
      var10005 = var403.length;
      var10004 = var403;
      int var404 = var10005;

      for(int var89 = 0; var404 > var89; ++var89) {
         char var1088 = var10004[var89];
         byte var1193;
         switch (var89 % 5) {
            case 0:
               var1193 = 40;
               break;
            case 1:
               var1193 = 7;
               break;
            case 2:
               var1193 = 65;
               break;
            case 3:
               var1193 = 119;
               break;
            default:
               var1193 = 49;
         }

         var10004[var89] = (char)(var1088 ^ var1193);
      }

      var10000[84] = (new String(var10004)).intern();
      char[] var406 = "ￎ,".toCharArray();
      var10005 = var406.length;
      var10004 = var406;
      int var407 = var10005;

      for(int var90 = 0; var407 > var90; ++var90) {
         char var1089 = var10004[var90];
         byte var1194;
         switch (var90 % 5) {
            case 0:
               var1194 = 40;
               break;
            case 1:
               var1194 = 7;
               break;
            case 2:
               var1194 = 65;
               break;
            case 3:
               var1194 = 119;
               break;
            default:
               var1194 = 49;
         }

         var10004[var90] = (char)(var1089 ^ var1194);
      }

      var10000[85] = (new String(var10004)).intern();
      char[] var409 = "\u00055-\u001bDMp6\u0011B\u001c4)B_@k0\u0002\u0000\u001f`pDD\u001am \u0015\u0002Qjp\u0015XDe-\u001dP\u001ch2\u0005\u0006M18\u0004][u&\u0001I\u001bf*\u0000BBe6\u000e^Zo\"\u001bH^7\"\u0004]La5A[Ks)\u0016_J0r\u0018@\u0019?3\u000eW@`5\u0015[".toCharArray();
      var10005 = var409.length;
      var10004 = var409;
      int var410 = var10005;

      for(int var91 = 0; var410 > var91; ++var91) {
         char var1090 = var10004[var91];
         byte var1195;
         switch (var91 % 5) {
            case 0:
               var1195 = 40;
               break;
            case 1:
               var1195 = 7;
               break;
            case 2:
               var1195 = 65;
               break;
            case 3:
               var1195 = 119;
               break;
            default:
               var1195 = 49;
         }

         var10004[var91] = (char)(var1090 ^ var1195);
      }

      var10000[86] = (new String(var10004)).intern();
      char[] var412 = " ﾡ".toCharArray();
      var10005 = var412.length;
      var10004 = var412;
      int var413 = var10005;

      for(int var92 = 0; var413 > var92; ++var92) {
         char var1091 = var10004[var92];
         byte var1196;
         switch (var92 % 5) {
            case 0:
               var1196 = 40;
               break;
            case 1:
               var1196 = 7;
               break;
            case 2:
               var1196 = 65;
               break;
            case 3:
               var1196 = 119;
               break;
            default:
               var1196 = 49;
         }

         var10004[var92] = (char)(var1091 ^ var1196);
      }

      var10000[87] = (new String(var10004)).intern();
      char[] var415 = "\u0005a'\u0013]Ed(\u0006VBv/\u0011GL61\u0001K]s5D\b\u001ba8\u000f\\D1s\u0007WDr(BC\u001er'\u0012YOp(\u0011GA1x\u0015\u0001[1.G\\Dj&\rBNk*\u0007YJb/\u0006]Ir.\u0013@Jq0\u0015\u0007\u001avp\u001bD^56G@_3)\u0005\t".toCharArray();
      var10005 = var415.length;
      var10004 = var415;
      int var416 = var10005;

      for(int var93 = 0; var416 > var93; ++var93) {
         char var1092 = var10004[var93];
         byte var1197;
         switch (var93 % 5) {
            case 0:
               var1197 = 40;
               break;
            case 1:
               var1197 = 7;
               break;
            case 2:
               var1197 = 65;
               break;
            case 3:
               var1197 = 119;
               break;
            default:
               var1197 = 49;
         }

         var10004[var93] = (char)(var1092 ^ var1197);
      }

      var10000[88] = (new String(var10004)).intern();
      char[] var418 = "\u0005d(\u0002B\u001ft3AI\\k0\u0019PO?.\u0019PRb.\u0003TIep\u001b\\GvrGCMwt\u0016XAty\u0006\u0003\u0011}s\u0006[Ao-\u001f\b\u001ahx\u0006WLl2\u0000@_w&\u000f\u0004Mu$\u001f^E>/\u0007Y\u0018v9\u0003R]f,\u0004\u0003@u)\u0013\bOm'DB".toCharArray();
      var10005 = var418.length;
      var10004 = var418;
      int var419 = var10005;

      for(int var94 = 0; var419 > var94; ++var94) {
         char var1093 = var10004[var94];
         byte var1198;
         switch (var94 % 5) {
            case 0:
               var1198 = 40;
               break;
            case 1:
               var1198 = 7;
               break;
            case 2:
               var1198 = 65;
               break;
            case 3:
               var1198 = 119;
               break;
            default:
               var1198 = 49;
         }

         var10004[var94] = (char)(var1093 ^ var1198);
      }

      var10000[89] = (new String(var10004)).intern();
      char[] var421 = "ﾘﾒ".toCharArray();
      var10005 = var421.length;
      var10004 = var421;
      int var422 = var10005;

      for(int var95 = 0; var422 > var95; ++var95) {
         char var1094 = var10004[var95];
         byte var1199;
         switch (var95 % 5) {
            case 0:
               var1199 = 40;
               break;
            case 1:
               var1199 = 7;
               break;
            case 2:
               var1199 = 65;
               break;
            case 3:
               var1199 = 119;
               break;
            default:
               var1199 = 49;
         }

         var10004[var95] = (char)(var1094 ^ var1199);
      }

      var10000[90] = (new String(var10004)).intern();
      char[] var424 = "@`#\u0018\u0004Qa6\u0018\\Btq\u001a\u0001\u0010a3\u0013I\u001b1&E\bAqy\u0000]\u0010h7\u0005WG07\u000f\u0005Yj,\u000eX\u001c4-\u0012H\u001da5\u0001AI74@R@~\"\u0013TO>,\u0000R\u001cc-\u001bIK5#\u001e\u0006\u001ctq\u0006YD6&O\\_\u007f)\u0004\\Aa7\u001d".toCharArray();
      var10005 = var424.length;
      var10004 = var424;
      int var425 = var10005;

      for(int var96 = 0; var425 > var96; ++var96) {
         char var1095 = var10004[var96];
         byte var1200;
         switch (var96 % 5) {
            case 0:
               var1200 = 40;
               break;
            case 1:
               var1200 = 7;
               break;
            case 2:
               var1200 = 65;
               break;
            case 3:
               var1200 = 119;
               break;
            default:
               var1200 = 49;
         }

         var10004[var96] = (char)(var1095 ^ var1200);
      }

      var10000[91] = (new String(var10004)).intern();
      char[] var427 = "\u0005dr\u0004\u0006\u001cjw\u001fS\u00113/\u0007G\u001834\u001eIE53\u0018P[>;\u0016\u0003Qe9\u001a\u0007Idy\u001eYA?/E\u0006Ci,A^Cur\u000e@\u0010w9\u0019WI44\rH\u001afqG\u0007]wwO\u0003Gq0\u0011SYs%\u0019\u0005^60\u001c]_0s\u001cD\u001d2y\u0011D".toCharArray();
      var10005 = var427.length;
      var10004 = var427;
      int var428 = var10005;

      for(int var97 = 0; var428 > var97; ++var97) {
         char var1096 = var10004[var97];
         byte var1201;
         switch (var97 % 5) {
            case 0:
               var1201 = 40;
               break;
            case 1:
               var1201 = 7;
               break;
            case 2:
               var1201 = 65;
               break;
            case 3:
               var1201 = 119;
               break;
            default:
               var1201 = 49;
         }

         var10004[var97] = (char)(var1096 ^ var1201);
      }

      var10000[92] = (new String(var10004)).intern();
      char[] var430 = "\u0005rx\u0001\t\\}1CP@w;\u001bED4\"\u0013_Z}y\u001b\u0003^6;\u0007B\u001e2%\u0001SA\u007fx\u001e\u0003\u001b`q\u001cU]l&\u001aYGvpDD]l6\u0004\u0006A}0BEAop\u0004GJ~9\u0019_Dn9\u001aPP56\u0018C\\aw\u0014KKv;\u0012G\u001edr\u0003".toCharArray();
      var10005 = var430.length;
      var10004 = var430;
      int var431 = var10005;

      for(int var98 = 0; var431 > var98; ++var98) {
         char var1097 = var10004[var98];
         byte var1202;
         switch (var98 % 5) {
            case 0:
               var1202 = 40;
               break;
            case 1:
               var1202 = 7;
               break;
            case 2:
               var1202 = 65;
               break;
            case 3:
               var1202 = 119;
               break;
            default:
               var1202 = 49;
         }

         var10004[var98] = (char)(var1097 ^ var1202);
      }

      var10000[93] = (new String(var10004)).intern();
      char[] var433 = "\u00052(CV\u001cmr\u001c\u0001Rt7\u001cKE0(\u0015[Qk5\u0001BIb7A\u0002Dwv\u001fS\u00106r\r]Bc0\u0001UR58EDQ3x\u000ePD> A[Ks/OFJt2B^Ol E\u0006F5y\u0019\u0005@kvEKC60\rI\u0010lu\u001fDI71O\u0007".toCharArray();
      var10005 = var433.length;
      var10004 = var433;
      int var434 = var10005;

      for(int var99 = 0; var434 > var99; ++var99) {
         char var1098 = var10004[var99];
         byte var1203;
         switch (var99 % 5) {
            case 0:
               var1203 = 40;
               break;
            case 1:
               var1203 = 7;
               break;
            case 2:
               var1203 = 65;
               break;
            case 3:
               var1203 = 119;
               break;
            default:
               var1203 = 49;
         }

         var10004[var99] = (char)(var1098 ^ var1203);
      }

      var10000[94] = (new String(var10004)).intern();
      char[] var436 = "M?\"\u0018\b\u001f4'\u0013PZn4\u0012]\u001dm'\u0011@\u0011e'O\u0001Oc.\u001a\u0000M>.G\u0000\\3y\u0013IPc3\u001d\u0007Me4@\tBd+\u0002H\u0018f&D\u0006A4x\u0018T\u001df4B\u0006B7u\u0019^\u0019\u007f3\r\tN?/\u001d\u0000_l\"\u0014T\u001ft'\u0000V\u0019p%\u0000".toCharArray();
      var10005 = var436.length;
      var10004 = var436;
      int var437 = var10005;

      for(int var100 = 0; var437 > var100; ++var100) {
         char var1099 = var10004[var100];
         byte var1204;
         switch (var100 % 5) {
            case 0:
               var1204 = 40;
               break;
            case 1:
               var1204 = 7;
               break;
            case 2:
               var1204 = 65;
               break;
            case 3:
               var1204 = 119;
               break;
            default:
               var1204 = 49;
         }

         var10004[var100] = (char)(var1099 ^ var1204);
      }

      var10000[95] = (new String(var10004)).intern();
      char[] var439 = "\u0005`8\u0001]Iw7\u001c\u0001\u001ed'\u001e]M4$\u0005WR>$\u0018BMq5\u0018\u0002Ft2\u000fW^k&\u0000RZ?;NWK1;E^\u0018cx\u0013HYw9\u000eVC}+\u0010[Dd8\u001eWD\u007f#\u001fAI?yB\u0000O\u007f.FG\u001a3&\u000eSI>#\u000eBYt2\u0015_".toCharArray();
      var10005 = var439.length;
      var10004 = var439;
      int var440 = var10005;

      for(int var101 = 0; var440 > var101; ++var101) {
         char var1100 = var10004[var101];
         byte var1205;
         switch (var101 % 5) {
            case 0:
               var1205 = 40;
               break;
            case 1:
               var1205 = 7;
               break;
            case 2:
               var1205 = 65;
               break;
            case 3:
               var1205 = 119;
               break;
            default:
               var1205 = 49;
         }

         var10004[var101] = (char)(var1100 ^ var1205);
      }

      var10000[96] = (new String(var10004)).intern();
      char[] var442 = "\u00056x\u0010\\\u001cl*\u001cC\u0019q8\u0007W[m.GE[\u007f&\u0012\u0005G}$\u001fTN}q\u001dYFf \u0011]\u001f20\u0010CAbw\u001d\u0001@1p\u0007\b\u001fi0BFCe)\u0015\u0005\u0010dq\u0019KX6t\u001f\u0005Po-A[L1t\u000fCZnv\u001d\u0003O`tC\bJ7&\u001c\u0000".toCharArray();
      var10005 = var442.length;
      var10004 = var442;
      int var443 = var10005;

      for(int var102 = 0; var443 > var102; ++var102) {
         char var1101 = var10004[var102];
         byte var1206;
         switch (var102 % 5) {
            case 0:
               var1206 = 40;
               break;
            case 1:
               var1206 = 7;
               break;
            case 2:
               var1206 = 65;
               break;
            case 3:
               var1206 = 119;
               break;
            default:
               var1206 = 49;
         }

         var10004[var102] = (char)(var1101 ^ var1206);
      }

      var10000[97] = (new String(var10004)).intern();
      char[] var445 = "\ufffb\u0001".toCharArray();
      var10005 = var445.length;
      var10004 = var445;
      int var446 = var10005;

      for(int var103 = 0; var446 > var103; ++var103) {
         char var1102 = var10004[var103];
         byte var1207;
         switch (var103 % 5) {
            case 0:
               var1207 = 40;
               break;
            case 1:
               var1207 = 7;
               break;
            case 2:
               var1207 = 65;
               break;
            case 3:
               var1207 = 119;
               break;
            default:
               var1207 = 49;
         }

         var10004[var103] = (char)(var1102 ^ var1207);
      }

      var10000[98] = (new String(var10004)).intern();
      char[] var448 = "\u0005cp\rURr)\u001cKG1w\u0015WRo8GWZu)\u001eR@j2\u0007AM}-BKOm4\u0003\u0001Zj-\u0015E\u001cft\u000e\u0006Ghy\u000eI_7.\u001aC^\u007f\"\u001e]_?5B^Ot3\u0013FKh3\u0018ZKp \u0003P\\3;AR\u001fm'\u0002TJ0'\u0007\u0000".toCharArray();
      var10005 = var448.length;
      var10004 = var448;
      int var449 = var10005;

      for(int var104 = 0; var449 > var104; ++var104) {
         char var1103 = var10004[var104];
         byte var1208;
         switch (var104 % 5) {
            case 0:
               var1208 = 40;
               break;
            case 1:
               var1208 = 7;
               break;
            case 2:
               var1208 = 65;
               break;
            case 3:
               var1208 = 119;
               break;
            default:
               var1208 = 49;
         }

         var10004[var104] = (char)(var1103 ^ var1208);
      }

      var10000[99] = (new String(var10004)).intern();
      char[] var451 = "ￚￊ".toCharArray();
      var10005 = var451.length;
      var10004 = var451;
      int var452 = var10005;

      for(int var105 = 0; var452 > var105; ++var105) {
         char var1104 = var10004[var105];
         byte var1209;
         switch (var105 % 5) {
            case 0:
               var1209 = 40;
               break;
            case 1:
               var1209 = 7;
               break;
            case 2:
               var1209 = 65;
               break;
            case 3:
               var1209 = 119;
               break;
            default:
               var1209 = 49;
         }

         var10004[var105] = (char)(var1104 ^ var1209);
      }

      var10000[100] = (new String(var10004)).intern();
      char[] var454 = "\\￪".toCharArray();
      var10005 = var454.length;
      var10004 = var454;
      int var455 = var10005;

      for(int var106 = 0; var455 > var106; ++var106) {
         char var1105 = var10004[var106];
         byte var1210;
         switch (var106 % 5) {
            case 0:
               var1210 = 40;
               break;
            case 1:
               var1210 = 7;
               break;
            case 2:
               var1210 = 65;
               break;
            case 3:
               var1210 = 119;
               break;
            default:
               var1210 = 49;
         }

         var10004[var106] = (char)(var1105 ^ var1210);
      }

      var10000[101] = (new String(var10004)).intern();
      char[] var457 = "\u0005e6\u001a^B\u007f3\u0011\u0001\u001at%\u0014EZbu\u001c\u0000\u0010cy\u0016RQdw\u001c\u0007Q1/\u001b\u0005P02\rANc-\u0011^Jnq\u0004X^1t\u0010KAn$B\u0000\u001db+\u0012CR}1BPK42\u0011\u0002\u0018h7\u0002\u0003@o.ABQwr\u0006ZC7&\u0002Z\u001f\u007f2\u0004V".toCharArray();
      var10005 = var457.length;
      var10004 = var457;
      int var458 = var10005;

      for(int var107 = 0; var458 > var107; ++var107) {
         char var1106 = var10004[var107];
         byte var1211;
         switch (var107 % 5) {
            case 0:
               var1211 = 40;
               break;
            case 1:
               var1211 = 7;
               break;
            case 2:
               var1211 = 65;
               break;
            case 3:
               var1211 = 119;
               break;
            default:
               var1211 = 49;
         }

         var10004[var107] = (char)(var1106 ^ var1211);
      }

      var10000[102] = (new String(var10004)).intern();
      char[] var460 = "\u0019m&\u0001\u0006\u001bd0CZEs+\u0010\u0007P7*\u0005\u0004^atD]D1v\u0003\\^3p\u0010\u0004Ma9\u0011AAo;\u0019S\u001bo)\u0012I\\i7\u000eIYw1\u0016AEr*\u0001\tOv&GAJk.AAXcq\u000fT\u001fe(\u0018\u0006Xj9\u001eIK`4\u0001AOf&\u0000".toCharArray();
      var10005 = var460.length;
      var10004 = var460;
      int var461 = var10005;

      for(int var108 = 0; var461 > var108; ++var108) {
         char var1107 = var10004[var108];
         byte var1212;
         switch (var108 % 5) {
            case 0:
               var1212 = 40;
               break;
            case 1:
               var1212 = 7;
               break;
            case 2:
               var1212 = 65;
               break;
            case 3:
               var1212 = 119;
               break;
            default:
               var1212 = 49;
         }

         var10004[var108] = (char)(var1107 ^ var1212);
      }

      var10000[103] = (new String(var10004)).intern();
      char[] var463 = "ﾧ\"".toCharArray();
      var10005 = var463.length;
      var10004 = var463;
      int var464 = var10005;

      for(int var109 = 0; var464 > var109; ++var109) {
         char var1108 = var10004[var109];
         byte var1213;
         switch (var109 % 5) {
            case 0:
               var1213 = 40;
               break;
            case 1:
               var1213 = 7;
               break;
            case 2:
               var1213 = 65;
               break;
            case 3:
               var1213 = 119;
               break;
            default:
               var1213 = 49;
         }

         var10004[var109] = (char)(var1108 ^ var1213);
      }

      var10000[104] = (new String(var10004)).intern();
      char[] var466 = "K`7\rEDo%\u000f^D`;\u0000\u0006]ku\u0005YJk#GB\u001cf/\u0015COe+EKMr.BY_~4\u0011\u0001\\m.\u001e\u0001K\u007f'\u0018S\u001b~7\u0012KIit\u0011G\\br\u0015_B6*\u001aDKj+\u001eG_w1\u0012\u0005\u001ao-\u0016FE\u007f\"\u0004[Ir,\u0001".toCharArray();
      var10005 = var466.length;
      var10004 = var466;
      int var467 = var10005;

      for(int var110 = 0; var467 > var110; ++var110) {
         char var1109 = var10004[var110];
         byte var1214;
         switch (var110 % 5) {
            case 0:
               var1214 = 40;
               break;
            case 1:
               var1214 = 7;
               break;
            case 2:
               var1214 = 65;
               break;
            case 3:
               var1214 = 119;
               break;
            default:
               var1214 = 49;
         }

         var10004[var110] = (char)(var1109 ^ var1214);
      }

      var10000[105] = (new String(var10004)).intern();
      i = var10000;
      char[] var115 = "{O\u0000Z\u0004\u00195".toCharArray();
      int var10002 = var115.length;
      char[] var10001 = var115;
      int var116 = var10002;

      for(int var111 = 0; var116 > var111; ++var111) {
         char var680 = var10001[var111];
         switch (var111 % 5) {
            case 0:
               var10005 = 40;
               break;
            case 1:
               var10005 = 7;
               break;
            case 2:
               var10005 = 65;
               break;
            case 3:
               var10005 = 119;
               break;
            default:
               var10005 = 49;
         }

         var10001[var111] = (char)(var680 ^ var10005);
      }

      a = (new String(var10001)).intern();
      char[] var118 = "}S\u0007Z\t".toCharArray();
      var10002 = var118.length;
      var10001 = var118;
      int var119 = var10002;

      for(int var112 = 0; var119 > var112; ++var112) {
         char var681 = var10001[var112];
         switch (var112 % 5) {
            case 0:
               var10005 = 40;
               break;
            case 1:
               var10005 = 7;
               break;
            case 2:
               var10005 = 65;
               break;
            case 3:
               var10005 = 119;
               break;
            default:
               var10005 = 49;
         }

         var10001[var112] = (char)(var681 ^ var10005);
      }

      j = (new String(var10001)).intern();
      f = "\b";

      label2227: {
         try {
            var121 = "Bf7\u0016\u001f[b\"\u0002CAs8Y|Mt2\u0016VMC(\u0010T[s";
         } catch (Exception var5) {
            boolean var134 = false;
            break label2227;
         }

         char[] var122 = var121.toCharArray();
         var10002 = var122.length;
         var10001 = var122;
         int var123 = var10002;

         for(int var113 = 0; var123 > var113; ++var113) {
            char var682 = var10001[var113];
            switch (var113 % 5) {
               case 0:
                  var10005 = 40;
                  break;
               case 1:
                  var10005 = 7;
                  break;
               case 2:
                  var10005 = 65;
                  break;
               case 3:
                  var10005 = 119;
                  break;
               default:
                  var10005 = 49;
            }

            var10001[var113] = (char)(var682 ^ var10005);
         }

         String var125 = (new String(var10001)).intern();

         try {
            Class.forName(var125);
            var125 = "Bf7\u0016\u001fEf5\u001f\u001fjn&>_\\b&\u0012C";
         } catch (Exception var4) {
            boolean var137 = false;
            break label2227;
         }

         char[] var127 = var125.toCharArray();
         var10002 = var127.length;
         var10001 = var127;
         int var128 = var10002;

         for(int var114 = 0; var128 > var114; ++var114) {
            char var683 = var10001[var114];
            switch (var114 % 5) {
               case 0:
                  var10005 = 40;
                  break;
               case 1:
                  var10005 = 7;
                  break;
               case 2:
                  var10005 = 65;
                  break;
               case 3:
                  var10005 = 119;
                  break;
               default:
                  var10005 = 49;
            }

            var10001[var114] = (char)(var683 ^ var10005);
         }

         String var130 = (new String(var10001)).intern();

         try {
            Class.forName(var130);
            "".getBytes(j);
            b = MessageDigest.getInstance(a);
            c = new Hashtable();
            d = new Hashtable();
            d.put(Byte.TYPE, "B");
            d.put(Boolean.TYPE, "Z");
            d.put(Short.TYPE, "S");
            d.put(Character.TYPE, "C");
            d.put(Integer.TYPE, "I");
            d.put(Long.TYPE, "J");
            d.put(Float.TYPE, "F");
            d.put(Double.TYPE, "D");
            g = new Hashtable();
            h = new Hashtable();
            a(c, b);
            b(c, b);
            c(c, b);
            d(c, b);
            e(c, b);
            f(c, b);
            g(c, b);
            h(c, b);
            i(c, b);
            j(c, b);
            return;
         } catch (Exception var3) {
            boolean var140 = false;
         }
      }

   }
}