API tools faq
paste
Advertisement
Guest User

459 RSString

a guest
Feb 23rd, 2018
117
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 30.60 KB | None | 0 0
raw download clone embed print report
  1. // Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov.
  2. // Jad home page: http://www.kpdus.com/jad.html
  3. // Decompiler options: packimports(3)
  4.  
  5. import java.awt.*;
  6. import java.io.UnsupportedEncodingException;
  7. import java.net.MalformedURLException;
  8. import java.net.URL;
  9.  
  10. public class RSString
  11.     implements Interface2
  12. {
  13.  
  14.     public boolean method1026(int i)
  15.     {
  16.         if(i != 30350)
  17.         {
  18.             return true;
  19.         } else
  20.         {
  21.             anInt1858++;
  22.             return method1035(10, (byte)103);
  23.         }
  24.     }
  25.  
  26.     public RSString method1027(byte byte0)
  27.     {
  28.         anInt1892++;
  29.         int i;
  30.         for(i = 0; anInt1893 > i && (~aByteArray1894[i] <= -1 && ~aByteArray1894[i] >= -33 || (0xff & aByteArray1894[i]) == 160); i++);
  31.         int j = anInt1893;
  32.         int k = 1 % ((byte0 - -59) / 60);
  33.         for(; ~j < ~i && (aByteArray1894[j + -1] >= 0 && aByteArray1894[j - 1] <= 32 || (0xff & aByteArray1894[j + -1]) == 160); j--);
  34.         if(~i == -1 && anInt1893 == j)
  35.             return this;
  36.         RSString class58 = new RSString();
  37.         class58.anInt1893 = j - i;
  38.         class58.aByteArray1894 = new byte[class58.anInt1893];
  39.         for(int l = 0; class58.anInt1893 > l; l++)
  40.             class58.aByteArray1894[l] = aByteArray1894[i + l];
  41.  
  42.         return class58;
  43.     }
  44.  
  45.     public RSString method1028(byte byte0, int i)
  46.     {
  47.         anInt1870++;
  48.         if(~i >= -1 || ~i < -256)
  49.             throw new IllegalArgumentException("invalid char:" + i);
  50.         if(!aBoolean1896)
  51.             throw new IllegalArgumentException();
  52.         anInt1872 = 0;
  53.         if(byte0 != -32)
  54.             hashCode();
  55.         if(~aByteArray1894.length == ~anInt1893)
  56.         {
  57.             int j;
  58.             for(j = 1; ~j >= ~anInt1893; j += j);
  59.             byte abyte0[] = new byte[j];
  60.             ArrayUtils.arraycopy(aByteArray1894, 0, abyte0, 0, anInt1893);
  61.             aByteArray1894 = abyte0;
  62.         }
  63.         aByteArray1894[anInt1893++] = (byte)i;
  64.         return this;
  65.     }
  66.  
  67.     public RSString method1029(int i, byte byte0)
  68.     {
  69.         anInt1860++;
  70.         if(byte0 != 120)
  71.             method1046(false);
  72.         return substring(i, (byte)123, anInt1893);
  73.     }
  74.  
  75.     public RSString method1030(RSString class58, int i)
  76.     {
  77.         if(i != -12860)
  78.             substring(112, (byte)-112, -100);
  79.         anInt1866++;
  80.         if(!aBoolean1896)
  81.             throw new IllegalArgumentException();
  82.         anInt1872 = 0;
  83.         if(~aByteArray1894.length > ~(anInt1893 - -class58.anInt1893))
  84.         {
  85.             int j;
  86.             for(j = 1; j < anInt1893 + class58.anInt1893; j += j);
  87.             byte abyte0[] = new byte[j];
  88.             ArrayUtils.arraycopy(aByteArray1894, 0, abyte0, 0, anInt1893);
  89.             aByteArray1894 = abyte0;
  90.         }
  91.         ArrayUtils.arraycopy(class58.aByteArray1894, 0, aByteArray1894, anInt1893, class58.anInt1893);
  92.         anInt1893 += class58.anInt1893;
  93.         return this;
  94.     }
  95.  
  96.     public static void method1031(Component component, int i, CachedRequest class30, CachedRequest class30_1)
  97.     {
  98.         try
  99.         {
  100.             anInt1901++;
  101.             if(CanvasWrapper.aBoolean74)
  102.                 return;
  103.             CanvasWrapper.aClass15_64 = Class33_Sub6_Sub8.method513((byte)-112, component, 765, 503);
  104.             CanvasWrapper.aClass15_64.method136(8);
  105.             DrawingArea.method418();
  106.             byte abyte0[] = class30_1.method222(5, SpotAnimLoader.aClass58_1346, NPCDefLoader.title);
  107.             Class33_Sub16.aClass33_Sub6_Sub7_Sub3_2487 = new Sprite(abyte0, component);
  108.             Class36.aClass33_Sub6_Sub7_Sub3_787 = Class33_Sub16.aClass33_Sub6_Sub7_Sub3_2487.method485();
  109.             NPCDef.aClass33_Sub6_Sub7_Sub4_3116 = Class32.method259(SpotAnimLoader.aClass58_1346, -4236, Class21.logo, class30);
  110.             Class33_Sub18.aClass33_Sub6_Sub7_Sub4_2523 = Class32.method259(SpotAnimLoader.aClass58_1346, -4236, Class21.titlebox, class30);
  111.             Class43.aClass33_Sub6_Sub7_Sub4_931 = Class32.method259(SpotAnimLoader.aClass58_1346, -4236, Class33_Sub3.titlebutton, class30);
  112.             Class33_Sub6_Sub15.aClass33_Sub6_Sub7_Sub4Array3065 = Class33_Sub6_Sub10.method527(true, class30, Class36.runes, SpotAnimLoader.aClass58_1346);
  113.             CacheRequester.aClass33_Sub6_Sub7_Sub4Array1476 = Class33_Sub6_Sub10.method527(true, class30, Class33_Sub7.title_mute, SpotAnimLoader.aClass58_1346);
  114.             Class59.anIntArray1269 = new int[256];
  115.             for(int j = 0; j < 64; j++)
  116.                 Class59.anIntArray1269[j] = 0x40000 * j;
  117.  
  118.             for(int k = 0; ~k > -65; k++)
  119.                 Class59.anIntArray1269[64 + k] = 0xff0000 + 1024 * k;
  120.  
  121.             for(int l = 0; l < 64; l++)
  122.                 Class59.anIntArray1269[l + 128] = l * 4 + 0xffff00;
  123.  
  124.             for(int i1 = 0; i1 < 64; i1++)
  125.                 Class59.anIntArray1269[i1 - -192] = 0xffffff;
  126.  
  127.             NPCDef.anIntArray3093 = new int[256];
  128.             for(int j1 = 0; j1 < 64; j1++)
  129.                 NPCDef.anIntArray3093[j1] = 1024 * j1;
  130.  
  131.             for(int k1 = 0; ~k1 > -65; k1++)
  132.                 NPCDef.anIntArray3093[k1 - -64] = 65280 - -(4 * k1);
  133.  
  134.             for(int l1 = 0; ~l1 > -65; l1++)
  135.                 NPCDef.anIntArray3093[l1 + 128] = 65535 + 0x40000 * l1;
  136.  
  137.             for(int i2 = 0; i2 < 64; i2++)
  138.                 NPCDef.anIntArray3093[i2 - -192] = 0xffffff;
  139.  
  140.             Class82.anIntArray1786 = new int[256];
  141.             for(int j2 = 0; ~j2 > -65; j2++)
  142.                 Class82.anIntArray1786[j2] = 4 * j2;
  143.  
  144.             for(int k2 = 0; k2 < 64; k2++)
  145.                 Class82.anIntArray1786[k2 - -64] = 255 + k2 * 0x40000;
  146.  
  147.             for(int l2 = 0; l2 < 64; l2++)
  148.                 Class82.anIntArray1786[128 + l2] = 0xff00ff + l2 * 1024;
  149.  
  150.             if(i < 6)
  151.                 aClass58_1906 = null;
  152.             for(int i3 = 0; ~i3 > -65; i3++)
  153.                 Class82.anIntArray1786[i3 + 192] = 0xffffff;
  154.  
  155.             Class38.anIntArray837 = new int[256];
  156.             Class34.anIntArray1827 = new int[32768];
  157.             NPCDef.anIntArray3067 = new int[32768];
  158.             Class11.method108(null, -1);
  159.             Class33_Sub6_Sub4_Sub6.anIntArray3596 = new int[32768];
  160.             BufferedRequest.aBoolean2683 = false;
  161.             SpotAnimLoader.currentUsername = SpotAnimLoader.aClass58_1346;
  162.             Class31.anInt696 = 0;
  163.             SpotAnimLoader.currentPassword = SpotAnimLoader.aClass58_1346;
  164.             MapRegion.anIntArray1488 = new int[32768];
  165.             if(~Class33_Sub6_Sub6.anInt2790 == -1)
  166.                 RSInterface.aBoolean2375 = true;
  167.             else
  168.                 RSInterface.aBoolean2375 = false;
  169.             if(RSInterface.aBoolean2375)
  170.                 Class31.method258(-27742, 2);
  171.             else
  172.                 Animation.method568(Class30_Sub1.aClass30_Sub1_1990, 255, false, Class54.aClass58_1158, SpotAnimLoader.aClass58_1346, 2, false);
  173.             FileRequest.method1154(false, 68);
  174.             OpcodeHandler.aBoolean2752 = true;
  175.             CanvasWrapper.aBoolean74 = true;
  176.             Class33_Sub16.aClass33_Sub6_Sub7_Sub3_2487.method495(0, 0);
  177.             Class36.aClass33_Sub6_Sub7_Sub3_787.method495(382, 0);
  178.             NPCDef.aClass33_Sub6_Sub7_Sub4_3116.method503(382 - NPCDef.aClass33_Sub6_Sub7_Sub4_3116.anInt3734 / 2, 18);
  179.             return;
  180.         }
  181.         catch(RuntimeException runtimeexception)
  182.         {
  183.             throw Class33.method264(runtimeexception, "qf.RA(" + (component == null ? "null" : "{...}") + ',' + i + ',' + (class30 == null ? "null" : "{...}") + ',' + (class30_1 == null ? "null" : "{...}") + ')');
  184.         }
  185.     }
  186.  
  187.     public int method1032(boolean flag, int i)
  188.     {
  189.         anInt1895++;
  190.         if(flag)
  191.             return -6;
  192.         else
  193.             return 0xff & aByteArray1894[i];
  194.     }
  195.  
  196.     public int method1033(int i)
  197.     {
  198.         anInt1867++;
  199.         if(i < 105)
  200.             length(-90);
  201.         return method1045(10, (byte)-99);
  202.     }
  203.  
  204.     public String toString()
  205.     {
  206.         anInt1888++;
  207.         //throw new RuntimeException();
  208.         return new String(aByteArray1894);
  209.     }
  210.  
  211.     public RSString method1034(boolean flag)
  212.     {
  213.         anInt1881++;
  214.         RSString class58 = new RSString();
  215.         class58.anInt1893 = anInt1893;
  216.         class58.aByteArray1894 = new byte[anInt1893];
  217.         for(int i = 0; anInt1893 > i; i++)
  218.             class58.aByteArray1894[i] = 42;
  219.  
  220.         if(flag)
  221.             anInt1872 = -91;
  222.         return class58;
  223.     }
  224.  
  225.     public boolean method1035(int i, byte byte0)
  226.     {
  227.         anInt1861++;
  228.         boolean flag = false;
  229.         boolean flag1 = false;
  230.         if(~i > -2 || i > 36)
  231.             i = 10;
  232.         int j = 0;
  233.         if(byte0 != 103)
  234.             aBoolean1896 = false;
  235.         for(int k = 0; ~k > ~anInt1893; k++)
  236.         {
  237.             int l = aByteArray1894[k] & 0xff;
  238.             if(k == 0)
  239.             {
  240.                 if(l == 45)
  241.                 {
  242.                     flag = true;
  243.                     continue;
  244.                 }
  245.                 if(l == 43)
  246.                     continue;
  247.             }
  248.             if(~l <= -49 && ~l >= -58)
  249.                 l -= 48;
  250.             else
  251.             if(l < 65 || ~l < -91)
  252.             {
  253.                 if(l >= 97 && ~l >= -123)
  254.                     l -= 87;
  255.                 else
  256.                     return false;
  257.             } else
  258.             {
  259.                 l -= 55;
  260.             }
  261.             if(i <= l)
  262.                 return false;
  263.             if(flag)
  264.                 l = -l;
  265.             int i1 = i * j - -l;
  266.             if(i1 / i != j)
  267.                 return false;
  268.             j = i1;
  269.             flag1 = true;
  270.         }
  271.  
  272.         return flag1;
  273.     }
  274.  
  275.     public int length(int i)
  276.     {
  277.         if(i != 27)
  278.             aBoolean1896 = true;
  279.         anInt1875++;
  280.         return anInt1893;
  281.     }
  282.  
  283.     public URL method1037(int i)
  284.         throws MalformedURLException
  285.     {
  286.         if(i != 24861)
  287.             aClass58_1914 = null;
  288.         anInt1889++;
  289.         return new URL(new String(aByteArray1894, 0, anInt1893));
  290.     }
  291.  
  292.     public static void method1038(boolean flag)
  293.     {
  294.         aClass58_1914 = null;
  295.         aClass33_Sub6_Sub7_Sub4Array1919 = null;
  296.         aClass16_1900 = null;
  297.         aClass33_Sub6_Sub7_Sub4_1920 = null;
  298.         aClass58_1918 = null;
  299.         aClass58_1905 = null;
  300.         aClass58_1909 = null;
  301.         aClass58_1917 = null;
  302.         aClass58_1912 = null;
  303.         aClass58_1910 = null;
  304.         aClass58_1916 = null;
  305.         aClass58_1915 = null;
  306.         aClass58_1903 = null;
  307.         aClass58_1906 = null;
  308.         if(flag)
  309.         {
  310.             return;
  311.         } else
  312.         {
  313.             aClass58_1921 = null;
  314.             aClass33_Sub6_Sub7_Sub3Array1904 = null;
  315.             aClass58_1908 = null;
  316.             aClass30_Sub1_1911 = null;
  317.             return;
  318.         }
  319.     }
  320.  
  321.     public int hashCode()
  322.     {
  323.         anInt1885++;
  324.         return method1055(true);
  325.     }
  326.  
  327.     public boolean method1039(RSString class58, int i)
  328.     {
  329.         anInt1864++;
  330.         int j = -21 / ((i - -11) / 53);
  331.         if(class58 == null)
  332.             return false;
  333.         if(class58.anInt1893 != anInt1893)
  334.             return false;
  335.         if(!aBoolean1896 || !class58.aBoolean1896)
  336.         {
  337.             if(~anInt1872 == -1)
  338.             {
  339.                 anInt1872 = method1055(true);
  340.                 if(~anInt1872 == -1)
  341.                     anInt1872 = 1;
  342.             }
  343.             if(~class58.anInt1872 == -1)
  344.             {
  345.                 class58.anInt1872 = class58.method1055(true);
  346.                 if(~class58.anInt1872 == -1)
  347.                     class58.anInt1872 = 1;
  348.             }
  349.             if(anInt1872 != class58.anInt1872)
  350.                 return false;
  351.         }
  352.         for(int k = 0; k < anInt1893; k++)
  353.             if(~class58.aByteArray1894[k] != ~aByteArray1894[k])
  354.                 return false;
  355.  
  356.         return true;
  357.     }
  358.  
  359.     public RSString add(int i, byte byte0)
  360.     {
  361.         anInt1880++;
  362.         int j = -70 % ((-70 - byte0) / 42);
  363.         if(~i >= -1 || ~i < -256)
  364.         {
  365.             throw new IllegalArgumentException("invalid char");
  366.         } else
  367.         {
  368.             RSString class58 = new RSString();
  369.             class58.aByteArray1894 = new byte[1 + anInt1893];
  370.             class58.anInt1893 = 1 + anInt1893;
  371.             ArrayUtils.arraycopy(aByteArray1894, 0, class58.aByteArray1894, 0, anInt1893);
  372.             class58.aByteArray1894[anInt1893] = (byte)i;
  373.             return class58;
  374.         }
  375.     }
  376.  
  377.     public int method1041(int i, int j)
  378.     {
  379.         anInt1887++;
  380.         if(i != 0)
  381.             aClass58_1905 = null;
  382.         return method1050(0, j, -75);
  383.     }
  384.  
  385.     public int method1042(RSString class58, int i)
  386.     {
  387.         int j;
  388.         if(anInt1893 <= class58.anInt1893)
  389.             j = anInt1893;
  390.         else
  391.             j = class58.anInt1893;
  392.         anInt1899++;
  393.         if(i <= 105)
  394.             method1058(12);
  395.         for(int k = 0; j > k; k++)
  396.         {
  397.             if(~Class33_Sub6_Sub13.anIntArray3006[0xff & aByteArray1894[k]] > ~Class33_Sub6_Sub13.anIntArray3006[0xff & class58.aByteArray1894[k]])
  398.                 return -1;
  399.             if(Class33_Sub6_Sub13.anIntArray3006[aByteArray1894[k] & 0xff] > Class33_Sub6_Sub13.anIntArray3006[0xff & class58.aByteArray1894[k]])
  400.                 return 1;
  401.         }
  402.  
  403.         if(~anInt1893 > ~class58.anInt1893)
  404.             return -1;
  405.         return anInt1893 <= class58.anInt1893 ? 0 : 1;
  406.     }
  407.  
  408.     public long method1043(int i)
  409.     {
  410.         long l = 0L;
  411.         anInt1859++;
  412.         for(int j = 0; j < anInt1893; j++)
  413.             l = (long)(aByteArray1894[j] & 0xff) + ((l << 0xd645fa05) + -l);
  414.  
  415.         int k = 60 / ((i - 49) / 41);
  416.         return l;
  417.     }
  418.  
  419.     public int method1044(RSString class58, boolean flag)
  420.     {
  421.         anInt1882++;
  422.         int i;
  423.         if(~class58.anInt1893 <= ~anInt1893)
  424.             i = anInt1893;
  425.         else
  426.             i = class58.anInt1893;
  427.         for(int j = 0; j < i; j++)
  428.         {
  429.             if(~(aByteArray1894[j] & 0xff) > ~(0xff & class58.aByteArray1894[j]))
  430.                 return -1;
  431.             if((0xff & aByteArray1894[j]) > (0xff & class58.aByteArray1894[j]))
  432.                 return 1;
  433.         }
  434.  
  435.         if(flag)
  436.             aClass58_1905 = null;
  437.         if(class58.anInt1893 > anInt1893)
  438.             return -1;
  439.         return class58.anInt1893 >= anInt1893 ? 0 : 1;
  440.     }
  441.  
  442.     public int method1045(int i, byte byte0)
  443.     {
  444.         if(i < 1 || ~i < -37)
  445.             i = 10;
  446.         boolean flag1 = false;
  447.         boolean flag = false;
  448.         anInt1913++;
  449.         int j = 0;
  450.         int k = 0;
  451.         if(byte0 != -99)
  452.             aClass58_1921 = null;
  453.         for(; k < anInt1893; k++)
  454.         {
  455.             int l = 0xff & aByteArray1894[k];
  456.             if(~k == -1)
  457.             {
  458.                 if(l == 45)
  459.                 {
  460.                     flag = true;
  461.                     continue;
  462.                 }
  463.                 if(l == 43)
  464.                     continue;
  465.             }
  466.             if(~l > -49 || l > 57)
  467.             {
  468.                 if(~l > -66 || l > 90)
  469.                 {
  470.                     if(l >= 97 && ~l >= -123)
  471.                         l -= 87;
  472.                     else
  473.                         throw new NumberFormatException();
  474.                 } else
  475.                 {
  476.                     l -= 55;
  477.                 }
  478.             } else
  479.             {
  480.                 l -= 48;
  481.             }
  482.             if(i <= l)
  483.                 throw new NumberFormatException();
  484.             if(flag)
  485.                 l = -l;
  486.             int i1 = l + j * i;
  487.             if(~j != ~(i1 / i))
  488.                 throw new NumberFormatException();
  489.             j = i1;
  490.             flag1 = true;
  491.         }
  492.  
  493.         if(!flag1)
  494.             throw new NumberFormatException();
  495.         else
  496.             return j;
  497.     }
  498.  
  499.     public RSString method1046(boolean flag)
  500.     {
  501.         anInt1902++;
  502.         if(!flag)
  503.             method1031(null, -6, null, null);
  504.         RSString class58 = new RSString();
  505.         class58.anInt1893 = anInt1893;
  506.         class58.aByteArray1894 = new byte[anInt1893];
  507.         for(int i = 0; ~i > ~anInt1893; i++)
  508.         {
  509.             byte byte0 = aByteArray1894[i];
  510.             if(~byte0 <= -66 && ~byte0 >= -91 || byte0 >= -64 && byte0 <= -34 && byte0 != -41)
  511.                 byte0 += 32;
  512.             class58.aByteArray1894[i] = byte0;
  513.         }
  514.  
  515.         return class58;
  516.     }
  517.  
  518.     public boolean equals(Object obj)
  519.     {
  520.         anInt1878++;
  521.         if(obj instanceof RSString)
  522.             return method1039((RSString)obj, -94);
  523.         else
  524.             throw new IllegalArgumentException();
  525.     }
  526.  
  527.     public int method1047(byte byte0, RSString class58)
  528.     {
  529.         if(byte0 > -58)
  530.         {
  531.             return -107;
  532.         } else
  533.         {
  534.             anInt1876++;
  535.             return method1052(true, class58, 0);
  536.         }
  537.     }
  538.  
  539.     public boolean method1048(RSString class58, byte byte0)
  540.     {
  541.         anInt1856++;
  542.         if(class58.anInt1893 > anInt1893)
  543.             return false;
  544.         int i = anInt1893 - class58.anInt1893;
  545.         for(int j = 0; ~class58.anInt1893 < ~j; j++)
  546.             if(aByteArray1894[j - -i] != class58.aByteArray1894[j])
  547.                 return false;
  548.  
  549.         return byte0 == -8 ? true : true;
  550.     }
  551.  
  552.     public RSString method1049(int i)
  553.     {
  554.         anInt1891++;
  555.         if(i != 57)
  556.             aClass58_1905 = null;
  557.         if(!aBoolean1896)
  558.             throw new IllegalArgumentException();
  559.         anInt1872 = 0;
  560.         if(anInt1893 != aByteArray1894.length)
  561.         {
  562.             byte abyte0[] = new byte[anInt1893];
  563.             ArrayUtils.arraycopy(aByteArray1894, 0, abyte0, 0, anInt1893);
  564.             aByteArray1894 = abyte0;
  565.         }
  566.         return this;
  567.     }
  568.  
  569.     public int method1050(int i, int j, int k)
  570.     {
  571.         anInt1869++;
  572.         if(k > -50)
  573.             method1042(null, -102);
  574.         byte byte0 = (byte)j;
  575.         for(int l = i; anInt1893 > l; l++)
  576.             if(byte0 == aByteArray1894[l])
  577.                 return l;
  578.  
  579.         return -1;
  580.     }
  581.  
  582.     public static void method1051(Screen applet_sub1, int i)
  583.     {
  584.         anInt1890++;
  585.         if(BufferedRequest.aBoolean2683)
  586.         {
  587.             Class40.method886(applet_sub1, true);
  588.             return;
  589.         }
  590.         if(~CacheRequester.anInt1464 == -2 && ~Class82.anInt1794 <= -716 && Class48.anInt1055 >= 453)
  591.         {
  592.             RSInterface.aBoolean2375 = !RSInterface.aBoolean2375;
  593.             if(RSInterface.aBoolean2375)
  594.                 Class78.method1186(3);
  595.             else
  596.                 CacheFile.method118(Class54.aClass58_1158, SpotAnimLoader.aClass58_1346, false, 10500, Class30_Sub1.aClass30_Sub1_1990, 255);
  597.         }
  598.         if(Class23.gameState == 5)
  599.             return;
  600.         ItemDefLoader.anInt287++;
  601.         if(~Class23.gameState != -11)
  602.             return;
  603.         if(~Class33_Sub2.anInt2023 != -3 && BZip2BlockEntry.anInt1617 == 0)
  604.         {
  605.             if(CacheRequester.anInt1464 == 1)
  606.             {
  607.                 char c = '\u01CF';
  608.                 byte byte1 = 100;
  609.                 byte byte2 = 35;
  610.                 byte byte0 = 5;
  611.                 if(byte0 <= Class82.anInt1794 && ~Class82.anInt1794 >= ~(byte0 + byte1) && c <= Class48.anInt1055 && ~Class48.anInt1055 >= ~(c + byte2))
  612.                 {
  613.                     Class33_Sub19.method819((byte)110);
  614.                     return;
  615.                 }
  616.             }
  617.             if(Class33_Sub6_Sub10.aClass36_2881 != null)
  618.                 Class33_Sub19.method819((byte)110);
  619.         }
  620.         int j = CacheRequester.anInt1464;
  621.         int k = Class82.anInt1794;
  622.         int l = Class48.anInt1055;
  623.         int i1 = -64 / ((38 - i) / 40);
  624.         if(Class31.anInt696 == 0)
  625.         {
  626.             char c3 = '\u0123';
  627.             char c1 = '\u012E';
  628.             if(~j == -2 && ~(c1 - 75) >= ~k && c1 - -75 >= k && ~l <= ~(c3 + -20) && c3 + 20 >= l)
  629.             {
  630.                 Class31.anInt701 = 0;
  631.                 Class31.anInt696 = 3;
  632.             }
  633.             c1 = '\u01CE';
  634.             if(~j == -2 && k >= c1 - 75 && ~k >= ~(c1 - -75) && l >= c3 - 20 && l <= 20 + c3)
  635.             {
  636.                 SpotAnimLoader.aClass58_1356 = Class23.aClass58_453;
  637.                 SpotAnimLoader.aClass58_1334 = Class57.aClass58_1250;
  638.                 Class31.anInt701 = 0;
  639.                 Class31.anInt696 = 2;
  640.                 SpotAnimLoader.aClass58_1343 = Class23.aClass58_435;
  641.                 return;
  642.             }
  643.         } else
  644.         {
  645.             if(~Class31.anInt696 == -3)
  646.             {
  647.                 int j1 = 231;
  648.                 j1 += 30;
  649.                 if(j == 1 && ~l <= ~(j1 - 15) && l < j1)
  650.                     Class31.anInt701 = 0;
  651.                 j1 += 15;
  652.                 if(j == 1 && ~l <= ~(-15 + j1) && ~l > ~j1)
  653.                     Class31.anInt701 = 1;
  654.                 char c6 = '\u0141';
  655.                 j1 += 15;
  656.                 char c4 = '\u012E';
  657.                 if(~j == -2 && k >= -75 + c4 && ~k >= ~(c4 + 75) && ~l <= ~(-20 + c6) && ~(20 + c6) <= ~l)
  658.                 {
  659.                     SpotAnimLoader.currentUsername = SpotAnimLoader.currentUsername.method1054(true).method1066(-119);
  660.                     if(~SpotAnimLoader.currentUsername.length(27) == -1)
  661.                     {
  662.                         Class19.method167(Class23.aClass58_471, false, Class23.aClass58_479, Class33_Sub6_Sub4_Sub5.aClass58_3568);
  663.                         return;
  664.                     }
  665.                     if(~SpotAnimLoader.currentPassword.length(27) == -1)
  666.                     {
  667.                         Class19.method167(Class23.aClass58_439, false, Class23.aClass58_478, Class33_Sub6_Sub4_Sub1.aClass58_3359);
  668.                         return;
  669.                     } else
  670.                     {
  671.                         Class19.method167(Class23.aClass58_434, false, Class23.aClass58_463, Class33_Sub20.aClass58_2573);
  672.                         Class29.method216(20, (byte)-47);
  673.                         return;
  674.                     }
  675.                 }
  676.                 c4 = '\u01CE';
  677.                 if(j == 1 && ~k <= ~(-75 + c4) && k <= c4 - -75 && l >= c6 - 20 && l <= c6 + 20)
  678.                 {
  679.                     SpotAnimLoader.currentPassword = SpotAnimLoader.aClass58_1346;
  680.                     SpotAnimLoader.currentUsername = SpotAnimLoader.aClass58_1346;
  681.                     Class31.anInt696 = 0;
  682.                 }
  683.                 while(Class39.method878((byte)107))
  684.                 {
  685.                     boolean flag = false;
  686.                     for(int k1 = 0; ~k1 > ~Class51.aClass58_1107.length(27); k1++)
  687.                     {
  688.                         if(~Class41.keyChar != ~Class51.aClass58_1107.method1032(false, k1))
  689.                             continue;
  690.                         flag = true;
  691.                         break;
  692.                     }
  693.  
  694.                     if(~Class31.anInt701 != -1)
  695.                     {
  696.                         if(Class31.anInt701 == 1)
  697.                         {
  698.                             if(~Class49.keyCode == -86 && ~SpotAnimLoader.currentPassword.length(27) < -1)
  699.                                 SpotAnimLoader.currentPassword = SpotAnimLoader.currentPassword.substring(0, (byte)126, SpotAnimLoader.currentPassword.length(27) + -1);
  700.                             if(Class49.keyCode == 84 || Class49.keyCode == 80)
  701.                                 Class31.anInt701 = 0;
  702.                             if(flag && SpotAnimLoader.currentPassword.length(27) < 20)
  703.                                 SpotAnimLoader.currentPassword = SpotAnimLoader.currentPassword.add(Class41.keyChar, (byte)-122);
  704.                         }
  705.                     } else
  706.                     {
  707.                         if(~Class49.keyCode == -86 && ~SpotAnimLoader.currentUsername.length(27) < -1)
  708.                             SpotAnimLoader.currentUsername = SpotAnimLoader.currentUsername.substring(0, (byte)120, -1 + SpotAnimLoader.currentUsername.length(27));
  709.                         if(Class49.keyCode == 84 || ~Class49.keyCode == -81)
  710.                             Class31.anInt701 = 1;
  711.                         if(flag && SpotAnimLoader.currentUsername.length(27) < 12)
  712.                             SpotAnimLoader.currentUsername = SpotAnimLoader.currentUsername.add(Class41.keyChar, (byte)66);
  713.                     }
  714.                 }
  715.                 return;
  716.             }
  717.             if(~Class31.anInt696 == -4)
  718.             {
  719.                 char c2 = '\u017E';
  720.                 char c5 = '\u0141';
  721.                 if(j == 1 && k >= c2 + -75 && k <= c2 - -75 && c5 - 20 <= l && 20 + c5 >= l)
  722.                     Class31.anInt696 = 0;
  723.             }
  724.         }
  725.     }
  726.  
  727.     public int method1052(boolean flag, RSString class58, int i)
  728.     {
  729.         anInt1883++;
  730.         int ai[] = new int[class58.anInt1893];
  731.         int ai1[] = new int[256];
  732.         int ai2[] = new int[class58.anInt1893];
  733.         for(int j = 0; ~j > ~ai1.length; j++)
  734.             ai1[j] = class58.anInt1893;
  735.  
  736.         for(int k = 1; class58.anInt1893 >= k; k++)
  737.         {
  738.             ai[k + -1] = -k + (class58.anInt1893 << 0xd4ddc281);
  739.             ai1[CacheFile.method111(255, class58.aByteArray1894[-1 + k])] = -k + class58.anInt1893;
  740.         }
  741.  
  742.         int l = class58.anInt1893 - -1;
  743.         for(int i1 = class58.anInt1893; i1 > 0; i1--)
  744.         {
  745.             ai2[-1 + i1] = l;
  746.             for(; l <= class58.anInt1893 && class58.aByteArray1894[i1 - 1] != class58.aByteArray1894[l - 1]; l = ai2[l + -1])
  747.                 if(~ai[l + -1] <= ~(-i1 + class58.anInt1893))
  748.                     ai[l - 1] = class58.anInt1893 + -i1;
  749.  
  750.             l--;
  751.         }
  752.  
  753.         if(!flag)
  754.             method1052(false, null, 90);
  755.         int j1 = l;
  756.         int k1 = 1;
  757.         l = -j1 + 1 + class58.anInt1893;
  758.         int l1 = 0;
  759.         for(int i2 = 1; ~l <= ~i2;)
  760.         {
  761.             ai2[i2 - 1] = l1;
  762.             for(; l1 >= 1 && ~class58.aByteArray1894[-1 + l1] != ~class58.aByteArray1894[i2 - 1]; l1 = ai2[-1 + l1]);
  763.             i2++;
  764.             l1++;
  765.         }
  766.  
  767.         while(j1 < class58.anInt1893)
  768.         {
  769.             for(int j2 = k1; ~j2 >= ~j1; j2++)
  770.                 if(~ai[-1 + j2] <= ~(j1 + (class58.anInt1893 + -j2)))
  771.                     ai[j2 + -1] = j1 + (class58.anInt1893 - j2);
  772.  
  773.             k1 = 1 + j1;
  774.             j1 -= -l - -ai2[-1 + l];
  775.             l = ai2[-1 + l];
  776.         }
  777.         int l2;
  778.         for(int k2 = -1 + (i - -class58.anInt1893); anInt1893 > k2; k2 += Math.max(ai1[aByteArray1894[k2] & 0xff], ai[l2]))
  779.         {
  780.             for(l2 = class58.anInt1893 + -1; ~l2 <= -1 && ~aByteArray1894[k2] == ~class58.aByteArray1894[l2]; l2--)
  781.                 k2--;
  782.  
  783.             if(l2 == -1)
  784.                 return k2 - -1;
  785.         }
  786.  
  787.         return -1;
  788.     }
  789.  
  790.     public boolean method1053(RSString class58, int i)
  791.     {
  792.         anInt1857++;
  793.         if(i >= -60)
  794.             method1059(-2, (byte)-2);
  795.         if(~anInt1893 > ~class58.anInt1893)
  796.             return false;
  797.         for(int j = 0; class58.anInt1893 > j; j++)
  798.             if(class58.aByteArray1894[j] != aByteArray1894[j])
  799.                 return false;
  800.  
  801.         return true;
  802.     }
  803.  
  804.     public RSString method1054(boolean flag)
  805.     {
  806.         anInt1868++;
  807.         RSString class58 = new RSString();
  808.         class58.anInt1893 = 0;
  809.         class58.aByteArray1894 = new byte[12];
  810.         int i = 0;
  811.         if(!flag)
  812.             method1046(true);
  813.         for(int j = 0; anInt1893 > j; j++)
  814.         {
  815.             if(~aByteArray1894[j] <= -66 && ~aByteArray1894[j] >= -91)
  816.             {
  817.                 class58.aByteArray1894[i++] = (byte)(97 + (aByteArray1894[j] - 65));
  818.                 class58.anInt1893 = i;
  819.             } else
  820.             if((~aByteArray1894[j] > -98 || aByteArray1894[j] > 122) && (~aByteArray1894[j] > -49 || aByteArray1894[j] > 57))
  821.             {
  822.                 if(i > 0)
  823.                     class58.aByteArray1894[i++] = 95;
  824.             } else
  825.             {
  826.                 class58.aByteArray1894[i++] = aByteArray1894[j];
  827.                 class58.anInt1893 = i;
  828.             }
  829.             if(~i == -13)
  830.                 break;
  831.         }
  832.  
  833.         return class58;
  834.     }
  835.  
  836.     public int method1055(boolean flag)
  837.     {
  838.         anInt1879++;
  839.         int i = 0;
  840.         if(!flag)
  841.             aClass58_1910 = null;
  842.         for(int j = 0; anInt1893 > j; j++)
  843.             i = -i + ((i << 0x83b22645) + (0xff & aByteArray1894[j]));
  844.  
  845.         return i;
  846.     }
  847.  
  848.     public int method1056(int i, byte abyte0[], int j, byte byte0, int k)
  849.     {
  850.         if(byte0 < 24)
  851.             aClass58_1917 = null;
  852.         ArrayUtils.arraycopy(aByteArray1894, j, abyte0, k, i - j);
  853.         anInt1873++;
  854.         return i - j;
  855.     }
  856.  
  857.     public int method1057(FontMetrics fontmetrics, boolean flag)
  858.     {
  859.         anInt1863++;
  860.         String s;
  861.         try
  862.         {
  863.             if(!flag)
  864.                 return -8;
  865.             s = new String(aByteArray1894, 0, anInt1893, "ISO-8859-1");
  866.         }
  867.         catch(UnsupportedEncodingException _ex)
  868.         {
  869.             s = new String(aByteArray1894, 0, anInt1893);
  870.         }
  871.         return fontmetrics.stringWidth(s);
  872.     }
  873.  
  874.     public RSString method1058(int i)
  875.     {
  876.         anInt1898++;
  877.         long l = method1043(-35);
  878.         synchronized(RSString.class)
  879.         {
  880.             if(AnimationLoader.aClass82_2586 == null)
  881.             {
  882.                 AnimationLoader.aClass82_2586 = new Class82(4096);
  883.             } else
  884.             {
  885.                 for(Class33_Sub3 class33_sub3 = (Class33_Sub3)AnimationLoader.aClass82_2586.getFront(109, l); class33_sub3 != null; class33_sub3 = (Class33_Sub3)AnimationLoader.aClass82_2586.method1220(false))
  886.                     if(method1039(class33_sub3.aClass58_2045, -106))
  887.                     {
  888.                         RSString class58 = class33_sub3.aClass58_2045;
  889.                         return class58;
  890.                     }
  891.  
  892.             }
  893.             if(i != 4096)
  894.                 aClass33_Sub6_Sub7_Sub3Array1904 = null;
  895.             Class33_Sub3 class33_sub3_1 = new Class33_Sub3();
  896.             class33_sub3_1.aClass58_2045 = this;
  897.             aBoolean1896 = false;
  898.             AnimationLoader.aClass82_2586.method1219(class33_sub3_1, (byte)-110, l);
  899.         }
  900.         return this;
  901.     }
  902.  
  903.     public static int method1059(int i, byte byte0)
  904.     {
  905.         anInt1897++;
  906.         int j = 0;
  907.         if(i < 0 || ~i <= 0xfffeffff)
  908.         {
  909.             i >>>= 16;
  910.             j += 16;
  911.         }
  912.         if(i >= 256)
  913.         {
  914.             j += 8;
  915.             i >>>= 8;
  916.         }
  917.         if(i >= 16)
  918.         {
  919.             j += 4;
  920.             i >>>= 4;
  921.         }
  922.         if(i >= 4)
  923.         {
  924.             j += 2;
  925.             i >>>= 2;
  926.         }
  927.         if(~i <= -2)
  928.         {
  929.             i >>>= 1;
  930.             j++;
  931.         }
  932.         if(byte0 != -98)
  933.             method1051(null, -117);
  934.         return j + i;
  935.     }
  936.  
  937.     public boolean method1060(int i, RSString class58)
  938.     {
  939.         anInt1886++;
  940.         if(class58 == null)
  941.             return false;
  942.         if(i != -1)
  943.             return false;
  944.         if(~anInt1893 != ~class58.anInt1893)
  945.             return false;
  946.         for(int j = 0; ~j > ~anInt1893; j++)
  947.         {
  948.             byte byte0 = aByteArray1894[j];
  949.             if(byte0 >= 65 && byte0 <= 90 || ~byte0 <= 63 && byte0 <= -34 && byte0 != -41)
  950.                 byte0 += 32;
  951.             byte byte1 = class58.aByteArray1894[j];
  952.             if(byte1 >= 65 && ~byte1 >= -91 || byte1 >= -64 && byte1 <= -34 && ~byte1 != 40)
  953.                 byte1 += 32;
  954.             if(~byte1 != ~byte0)
  955.                 return false;
  956.         }
  957.  
  958.         return true;
  959.     }
  960.  
  961.     public byte[] method1061(int i)
  962.     {
  963.         if(i < 117)
  964.         {
  965.             return null;
  966.         } else
  967.         {
  968.             anInt1871++;
  969.             byte abyte0[] = new byte[anInt1893];
  970.             ArrayUtils.arraycopy(aByteArray1894, 0, abyte0, 0, anInt1893);
  971.             return abyte0;
  972.         }
  973.     }
  974.  
  975.     public RSString method1062(int i)
  976.     {
  977.         byte byte0 = 2;
  978.         RSString class58 = new RSString();
  979.         class58.anInt1893 = anInt1893;
  980.         class58.aByteArray1894 = new byte[anInt1893];
  981.         for(int j = 0; anInt1893 > j; j++)
  982.         {
  983.             byte byte1 = aByteArray1894[j];
  984.             if(~byte1 <= -98 && byte1 <= 122 || byte1 >= -32 && ~byte1 >= 1 && byte1 != -9)
  985.             {
  986.                 if(byte0 == 2)
  987.                     byte1 -= 32;
  988.                 byte0 = 0;
  989.             } else
  990.             if((byte1 < 65 || byte1 > 90) && (~byte1 > 63 || ~byte1 < 33 || byte1 == -41))
  991.             {
  992.                 if(~byte1 == -47 || byte1 == 33 || byte1 == 63)
  993.                     byte0 = 2;
  994.                 else
  995.                 if(~byte1 != -33)
  996.                     byte0 = 1;
  997.                 else
  998.                 if(byte0 != 2)
  999.                     byte0 = 1;
  1000.             } else
  1001.             {
  1002.                 if(byte0 == 0)
  1003.                     byte1 += 32;
  1004.                 byte0 = 0;
  1005.             }
  1006.             class58.aByteArray1894[j] = byte1;
  1007.         }
  1008.  
  1009.         if(i > -48)
  1010.         {
  1011.             return null;
  1012.         } else
  1013.         {
  1014.             anInt1874++;
  1015.             return class58;
  1016.         }
  1017.     }
  1018.  
  1019.     public long toLong(byte byte0)
  1020.     {
  1021.         if(byte0 != 11)
  1022.             aClass33_Sub6_Sub7_Sub3Array1904 = null;
  1023.         anInt1877++;
  1024.         long l = 0L;
  1025.         for(int i = 0; ~anInt1893 < ~i && ~i > -13; i++)
  1026.         {
  1027.             l *= 37L;
  1028.             byte byte1 = aByteArray1894[i];
  1029.             if(byte1 >= 65 && ~byte1 >= -91)
  1030.                 l += byte1 + -64;
  1031.             else
  1032.             if(~byte1 <= -98 && byte1 <= 122)
  1033.                 l += 1 + byte1 + -97;
  1034.             else
  1035.             if(byte1 >= 48 && ~byte1 >= -58)
  1036.                 l += -48 + (27 + byte1);
  1037.         }
  1038.  
  1039.         for(; l % 37L == 0L && l != 0L; l /= 37L);
  1040.         return l;
  1041.     }
  1042.  
  1043.     public RSString substring(int i, byte byte0, int j)
  1044.     {
  1045.         anInt1865++;
  1046.         RSString class58 = new RSString();
  1047.         if(byte0 < 118)
  1048.             aClass58_1917 = null;
  1049.         class58.aByteArray1894 = new byte[-i + j];
  1050.         class58.anInt1893 = -i + j;
  1051.         ArrayUtils.arraycopy(aByteArray1894, i, class58.aByteArray1894, 0, class58.anInt1893);
  1052.         return class58;
  1053.     }
  1054.  
  1055.     public void method1065(int i, int j, int k, Graphics g)
  1056.     {
  1057.         if(i > -56)
  1058.             aClass58_1909 = null;
  1059.         anInt1862++;
  1060.         String s;
  1061.         try
  1062.         {
  1063.             s = new String(aByteArray1894, 0, anInt1893, "ISO-8859-1");
  1064.         }
  1065.         catch(UnsupportedEncodingException _ex)
  1066.         {
  1067.             s = new String(aByteArray1894, 0, anInt1893);
  1068.         }
  1069.         g.drawString(s, j, k);
  1070.     }
  1071.  
  1072.     public RSString method1066(int i)
  1073.     {
  1074.         anInt1884++;
  1075.         RSString class58 = new RSString();
  1076.         boolean flag = true;
  1077.         class58.anInt1893 = anInt1893;
  1078.         class58.aByteArray1894 = new byte[anInt1893];
  1079.         if(i >= -88)
  1080.             return null;
  1081.         for(int j = 0; ~anInt1893 < ~j; j++)
  1082.         {
  1083.             byte byte0 = aByteArray1894[j];
  1084.             if(~byte0 == -96)
  1085.             {
  1086.                 flag = true;
  1087.                 class58.aByteArray1894[j] = 32;
  1088.             } else
  1089.             if(~byte0 > -98 || byte0 > 122 || !flag)
  1090.             {
  1091.                 flag = false;
  1092.                 class58.aByteArray1894[j] = byte0;
  1093.             } else
  1094.             {
  1095.                 flag = false;
  1096.                 class58.aByteArray1894[j] = (byte)(-32 + byte0);
  1097.             }
  1098.         }
  1099.  
  1100.         return class58;
  1101.     }
  1102.  
  1103.     public RSString()
  1104.     {
  1105.         aBoolean1896 = true;
  1106.     }
  1107.  
  1108.     public static int anInt1856;
  1109.     public static int anInt1857;
  1110.     public static int anInt1858;
  1111.     public static int anInt1859;
  1112.     public static int anInt1860;
  1113.     public static int anInt1861;
  1114.     public static int anInt1862;
  1115.     public static int anInt1863;
  1116.     public static int anInt1864;
  1117.     public static int anInt1865;
  1118.     public static int anInt1866;
  1119.     public static int anInt1867;
  1120.     public static int anInt1868;
  1121.     public static int anInt1869;
  1122.     public static int anInt1870;
  1123.     public static int anInt1871;
  1124.     public int anInt1872;
  1125.     public static int anInt1873;
  1126.     public static int anInt1874;
  1127.     public static int anInt1875;
  1128.     public static int anInt1876;
  1129.     public static int anInt1877;
  1130.     public static int anInt1878;
  1131.     public static int anInt1879;
  1132.     public static int anInt1880;
  1133.     public static int anInt1881;
  1134.     public static int anInt1882;
  1135.     public static int anInt1883;
  1136.     public static int anInt1884;
  1137.     public static int anInt1885;
  1138.     public static int anInt1886;
  1139.     public static int anInt1887;
  1140.     public static int anInt1888;
  1141.     public static int anInt1889;
  1142.     public static int anInt1890;
  1143.     public static int anInt1891;
  1144.     public static int anInt1892;
  1145.     public int anInt1893;
  1146.     public byte aByteArray1894[];
  1147.     public static int anInt1895;
  1148.     public boolean aBoolean1896;
  1149.     public static int anInt1897;
  1150.     public static int anInt1898;
  1151.     public static int anInt1899;
  1152.     public static Class16 aClass16_1900 = new Class16(100);
  1153.     public static int anInt1901;
  1154.     public static int anInt1902;
  1155.     public static RSString aClass58_1903;
  1156.     public static Sprite aClass33_Sub6_Sub7_Sub3Array1904[];
  1157.     public static RSString aClass58_1905;
  1158.     public static RSString aClass58_1906;
  1159.     public static int anInt1907;
  1160.     public static RSString aClass58_1908;
  1161.     public static RSString aClass58_1909 = ItemDef.stringToRSString(111, "RuneScape wird geladen )2 bitte warten)3)3)3");
  1162.     public static RSString aClass58_1910;
  1163.     public static Class30_Sub1 aClass30_Sub1_1911;
  1164.     public static RSString aClass58_1912 = ItemDef.stringToRSString(107, "scrollbar");
  1165.     public static int anInt1913;
  1166.     public static RSString aClass58_1914;
  1167.     public static RSString aClass58_1915;
  1168.     public static RSString aClass58_1916 = ItemDef.stringToRSString(114, "backleft1");
  1169.     public static RSString aClass58_1917 = ItemDef.stringToRSString(123, "Die Verbindung konnte");
  1170.     public static RSString aClass58_1918;
  1171.     public static Background aClass33_Sub6_Sub7_Sub4Array1919[];
  1172.     public static Background aClass33_Sub6_Sub7_Sub4_1920;
  1173.     public static RSString aClass58_1921;
  1174.     public static int anInt1922 = 0;
  1175.  
  1176.     static
  1177.     {
  1178.         aClass58_1906 = ItemDef.stringToRSString(113, "Enter name:");
  1179.         aClass58_1910 = ItemDef.stringToRSString(112, " is already on your ignore list");
  1180.         aClass58_1905 = ItemDef.stringToRSString(122, " seconds)3");
  1181.         aClass58_1921 = aClass58_1910;
  1182.         aClass58_1918 = aClass58_1905;
  1183.         aClass58_1915 = ItemDef.stringToRSString(124, "M");
  1184.         aClass58_1908 = aClass58_1915;
  1185.         aClass58_1914 = aClass58_1906;
  1186.         aClass58_1903 = aClass58_1915;
  1187.     }
  1188. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!