home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / util / Arrays.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  18.9 KB  |  2,152 lines
  1. package java.util;
  2.  
  3. import [Ljava.lang.Object;;
  4. import java.lang.reflect.Array;
  5.  
  6. public class Arrays {
  7.    private static final int INSERTIONSORT_THRESHOLD = 7;
  8.  
  9.    private Arrays() {
  10.    }
  11.  
  12.    public static void sort(long[] var0) {
  13.       sort1((long[])var0, 0, var0.length);
  14.    }
  15.  
  16.    public static void sort(long[] var0, int var1, int var2) {
  17.       rangeCheck(var0.length, var1, var2);
  18.       sort1(var0, var1, var2 - var1);
  19.    }
  20.  
  21.    public static void sort(int[] var0) {
  22.       sort1((int[])var0, 0, var0.length);
  23.    }
  24.  
  25.    public static void sort(int[] var0, int var1, int var2) {
  26.       rangeCheck(var0.length, var1, var2);
  27.       sort1(var0, var1, var2 - var1);
  28.    }
  29.  
  30.    public static void sort(short[] var0) {
  31.       sort1((short[])var0, 0, var0.length);
  32.    }
  33.  
  34.    public static void sort(short[] var0, int var1, int var2) {
  35.       rangeCheck(var0.length, var1, var2);
  36.       sort1(var0, var1, var2 - var1);
  37.    }
  38.  
  39.    public static void sort(char[] var0) {
  40.       sort1((char[])var0, 0, var0.length);
  41.    }
  42.  
  43.    public static void sort(char[] var0, int var1, int var2) {
  44.       rangeCheck(var0.length, var1, var2);
  45.       sort1(var0, var1, var2 - var1);
  46.    }
  47.  
  48.    public static void sort(byte[] var0) {
  49.       sort1((byte[])var0, 0, var0.length);
  50.    }
  51.  
  52.    public static void sort(byte[] var0, int var1, int var2) {
  53.       rangeCheck(var0.length, var1, var2);
  54.       sort1(var0, var1, var2 - var1);
  55.    }
  56.  
  57.    public static void sort(double[] var0) {
  58.       sort2((double[])var0, 0, var0.length);
  59.    }
  60.  
  61.    public static void sort(double[] var0, int var1, int var2) {
  62.       rangeCheck(var0.length, var1, var2);
  63.       sort2(var0, var1, var2);
  64.    }
  65.  
  66.    public static void sort(float[] var0) {
  67.       sort2((float[])var0, 0, var0.length);
  68.    }
  69.  
  70.    public static void sort(float[] var0, int var1, int var2) {
  71.       rangeCheck(var0.length, var1, var2);
  72.       sort2(var0, var1, var2);
  73.    }
  74.  
  75.    private static void sort2(double[] var0, int var1, int var2) {
  76.       long var3 = Double.doubleToLongBits((double)-0.0F);
  77.       int var5 = 0;
  78.       int var6 = var1;
  79.       int var7 = var2;
  80.  
  81.       while(var6 < var7) {
  82.          if (var0[var6] != var0[var6]) {
  83.             double var8 = var0[var6];
  84.             --var7;
  85.             var0[var6] = var0[var7];
  86.             var0[var7] = var8;
  87.          } else {
  88.             if (var0[var6] == (double)0.0F && Double.doubleToLongBits(var0[var6]) == var3) {
  89.                var0[var6] = (double)0.0F;
  90.                ++var5;
  91.             }
  92.  
  93.             ++var6;
  94.          }
  95.       }
  96.  
  97.       sort1(var0, var1, var7 - var1);
  98.       if (var5 != 0) {
  99.          int var10 = binarySearch0(var0, var1, var7, (double)0.0F);
  100.  
  101.          do {
  102.             --var10;
  103.          } while(var10 >= 0 && var0[var10] == (double)0.0F);
  104.  
  105.          for(int var9 = 0; var9 < var5; ++var9) {
  106.             ++var10;
  107.             var0[var10] = (double)-0.0F;
  108.          }
  109.       }
  110.  
  111.    }
  112.  
  113.    private static void sort2(float[] var0, int var1, int var2) {
  114.       int var3 = Float.floatToIntBits(-0.0F);
  115.       int var4 = 0;
  116.       int var5 = var1;
  117.       int var6 = var2;
  118.  
  119.       while(var5 < var6) {
  120.          if (var0[var5] != var0[var5]) {
  121.             float var7 = var0[var5];
  122.             --var6;
  123.             var0[var5] = var0[var6];
  124.             var0[var6] = var7;
  125.          } else {
  126.             if (var0[var5] == 0.0F && Float.floatToIntBits(var0[var5]) == var3) {
  127.                var0[var5] = 0.0F;
  128.                ++var4;
  129.             }
  130.  
  131.             ++var5;
  132.          }
  133.       }
  134.  
  135.       sort1(var0, var1, var6 - var1);
  136.       if (var4 != 0) {
  137.          int var9 = binarySearch0(var0, var1, var6, 0.0F);
  138.  
  139.          do {
  140.             --var9;
  141.          } while(var9 >= 0 && var0[var9] == 0.0F);
  142.  
  143.          for(int var8 = 0; var8 < var4; ++var8) {
  144.             ++var9;
  145.             var0[var9] = -0.0F;
  146.          }
  147.       }
  148.  
  149.    }
  150.  
  151.    private static void sort1(long[] var0, int var1, int var2) {
  152.       if (var2 < 7) {
  153.          for(int var12 = var1; var12 < var2 + var1; ++var12) {
  154.             for(int var14 = var12; var14 > var1 && var0[var14 - 1] > var0[var14]; --var14) {
  155.                swap(var0, var14, var14 - 1);
  156.             }
  157.          }
  158.  
  159.       } else {
  160.          int var3 = var1 + (var2 >> 1);
  161.          if (var2 > 7) {
  162.             int var4 = var1;
  163.             int var5 = var1 + var2 - 1;
  164.             if (var2 > 40) {
  165.                int var6 = var2 / 8;
  166.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  167.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  168.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  169.             }
  170.  
  171.             var3 = med3(var0, var4, var3, var5);
  172.          }
  173.  
  174.          long var13 = var0[var3];
  175.          int var15 = var1;
  176.          int var7 = var1;
  177.          int var8 = var1 + var2 - 1;
  178.          int var9 = var8;
  179.  
  180.          while(true) {
  181.             while(var7 > var8 || var0[var7] > var13) {
  182.                for(; var8 >= var7 && var0[var8] >= var13; --var8) {
  183.                   if (var0[var8] == var13) {
  184.                      swap(var0, var8, var9--);
  185.                   }
  186.                }
  187.  
  188.                if (var7 > var8) {
  189.                   int var11 = var1 + var2;
  190.                   int var10 = Math.min(var15 - var1, var7 - var15);
  191.                   vecswap(var0, var1, var7 - var10, var10);
  192.                   var10 = Math.min(var9 - var8, var11 - var9 - 1);
  193.                   vecswap(var0, var7, var11 - var10, var10);
  194.                   if ((var10 = var7 - var15) > 1) {
  195.                      sort1(var0, var1, var10);
  196.                   }
  197.  
  198.                   if ((var10 = var9 - var8) > 1) {
  199.                      sort1(var0, var11 - var10, var10);
  200.                   }
  201.  
  202.                   return;
  203.                }
  204.  
  205.                swap(var0, var7++, var8--);
  206.             }
  207.  
  208.             if (var0[var7] == var13) {
  209.                swap(var0, var15++, var7);
  210.             }
  211.  
  212.             ++var7;
  213.          }
  214.       }
  215.    }
  216.  
  217.    private static void swap(long[] var0, int var1, int var2) {
  218.       long var3 = var0[var1];
  219.       var0[var1] = var0[var2];
  220.       var0[var2] = var3;
  221.    }
  222.  
  223.    private static void vecswap(long[] var0, int var1, int var2, int var3) {
  224.       for(int var4 = 0; var4 < var3; ++var2) {
  225.          swap(var0, var1, var2);
  226.          ++var4;
  227.          ++var1;
  228.       }
  229.  
  230.    }
  231.  
  232.    private static int med3(long[] var0, int var1, int var2, int var3) {
  233.       return var0[var1] < var0[var2] ? (var0[var2] < var0[var3] ? var2 : (var0[var1] < var0[var3] ? var3 : var1)) : (var0[var2] > var0[var3] ? var2 : (var0[var1] > var0[var3] ? var3 : var1));
  234.    }
  235.  
  236.    private static void sort1(int[] var0, int var1, int var2) {
  237.       if (var2 < 7) {
  238.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  239.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  240.                swap(var0, var13, var13 - 1);
  241.             }
  242.          }
  243.  
  244.       } else {
  245.          int var3 = var1 + (var2 >> 1);
  246.          if (var2 > 7) {
  247.             int var4 = var1;
  248.             int var5 = var1 + var2 - 1;
  249.             if (var2 > 40) {
  250.                int var6 = var2 / 8;
  251.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  252.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  253.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  254.             }
  255.  
  256.             var3 = med3(var0, var4, var3, var5);
  257.          }
  258.  
  259.          int var12 = var0[var3];
  260.          int var14 = var1;
  261.          int var15 = var1;
  262.          int var7 = var1 + var2 - 1;
  263.          int var8 = var7;
  264.  
  265.          while(true) {
  266.             while(var15 > var7 || var0[var15] > var12) {
  267.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  268.                   if (var0[var7] == var12) {
  269.                      swap(var0, var7, var8--);
  270.                   }
  271.                }
  272.  
  273.                if (var15 > var7) {
  274.                   int var10 = var1 + var2;
  275.                   int var9 = Math.min(var14 - var1, var15 - var14);
  276.                   vecswap(var0, var1, var15 - var9, var9);
  277.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  278.                   vecswap(var0, var15, var10 - var9, var9);
  279.                   if ((var9 = var15 - var14) > 1) {
  280.                      sort1(var0, var1, var9);
  281.                   }
  282.  
  283.                   if ((var9 = var8 - var7) > 1) {
  284.                      sort1(var0, var10 - var9, var9);
  285.                   }
  286.  
  287.                   return;
  288.                }
  289.  
  290.                swap(var0, var15++, var7--);
  291.             }
  292.  
  293.             if (var0[var15] == var12) {
  294.                swap(var0, var14++, var15);
  295.             }
  296.  
  297.             ++var15;
  298.          }
  299.       }
  300.    }
  301.  
  302.    private static void swap(int[] var0, int var1, int var2) {
  303.       int var3 = var0[var1];
  304.       var0[var1] = var0[var2];
  305.       var0[var2] = var3;
  306.    }
  307.  
  308.    private static void vecswap(int[] var0, int var1, int var2, int var3) {
  309.       for(int var4 = 0; var4 < var3; ++var2) {
  310.          swap(var0, var1, var2);
  311.          ++var4;
  312.          ++var1;
  313.       }
  314.  
  315.    }
  316.  
  317.    private static int med3(int[] var0, int var1, int var2, int var3) {
  318.       return var0[var1] < var0[var2] ? (var0[var2] < var0[var3] ? var2 : (var0[var1] < var0[var3] ? var3 : var1)) : (var0[var2] > var0[var3] ? var2 : (var0[var1] > var0[var3] ? var3 : var1));
  319.    }
  320.  
  321.    private static void sort1(short[] var0, int var1, int var2) {
  322.       if (var2 < 7) {
  323.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  324.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  325.                swap(var0, var13, var13 - 1);
  326.             }
  327.          }
  328.  
  329.       } else {
  330.          int var3 = var1 + (var2 >> 1);
  331.          if (var2 > 7) {
  332.             int var4 = var1;
  333.             int var5 = var1 + var2 - 1;
  334.             if (var2 > 40) {
  335.                int var6 = var2 / 8;
  336.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  337.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  338.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  339.             }
  340.  
  341.             var3 = med3(var0, var4, var3, var5);
  342.          }
  343.  
  344.          short var12 = var0[var3];
  345.          int var14 = var1;
  346.          int var15 = var1;
  347.          int var7 = var1 + var2 - 1;
  348.          int var8 = var7;
  349.  
  350.          while(true) {
  351.             while(var15 > var7 || var0[var15] > var12) {
  352.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  353.                   if (var0[var7] == var12) {
  354.                      swap(var0, var7, var8--);
  355.                   }
  356.                }
  357.  
  358.                if (var15 > var7) {
  359.                   int var10 = var1 + var2;
  360.                   int var9 = Math.min(var14 - var1, var15 - var14);
  361.                   vecswap(var0, var1, var15 - var9, var9);
  362.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  363.                   vecswap(var0, var15, var10 - var9, var9);
  364.                   if ((var9 = var15 - var14) > 1) {
  365.                      sort1(var0, var1, var9);
  366.                   }
  367.  
  368.                   if ((var9 = var8 - var7) > 1) {
  369.                      sort1(var0, var10 - var9, var9);
  370.                   }
  371.  
  372.                   return;
  373.                }
  374.  
  375.                swap(var0, var15++, var7--);
  376.             }
  377.  
  378.             if (var0[var15] == var12) {
  379.                swap(var0, var14++, var15);
  380.             }
  381.  
  382.             ++var15;
  383.          }
  384.       }
  385.    }
  386.  
  387.    private static void swap(short[] var0, int var1, int var2) {
  388.       short var3 = var0[var1];
  389.       var0[var1] = var0[var2];
  390.       var0[var2] = var3;
  391.    }
  392.  
  393.    private static void vecswap(short[] var0, int var1, int var2, int var3) {
  394.       for(int var4 = 0; var4 < var3; ++var2) {
  395.          swap(var0, var1, var2);
  396.          ++var4;
  397.          ++var1;
  398.       }
  399.  
  400.    }
  401.  
  402.    private static int med3(short[] var0, int var1, int var2, int var3) {
  403.       return var0[var1] < var0[var2] ? (var0[var2] < var0[var3] ? var2 : (var0[var1] < var0[var3] ? var3 : var1)) : (var0[var2] > var0[var3] ? var2 : (var0[var1] > var0[var3] ? var3 : var1));
  404.    }
  405.  
  406.    private static void sort1(char[] var0, int var1, int var2) {
  407.       if (var2 < 7) {
  408.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  409.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  410.                swap(var0, var13, var13 - 1);
  411.             }
  412.          }
  413.  
  414.       } else {
  415.          int var3 = var1 + (var2 >> 1);
  416.          if (var2 > 7) {
  417.             int var4 = var1;
  418.             int var5 = var1 + var2 - 1;
  419.             if (var2 > 40) {
  420.                int var6 = var2 / 8;
  421.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  422.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  423.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  424.             }
  425.  
  426.             var3 = med3(var0, var4, var3, var5);
  427.          }
  428.  
  429.          char var12 = var0[var3];
  430.          int var14 = var1;
  431.          int var15 = var1;
  432.          int var7 = var1 + var2 - 1;
  433.          int var8 = var7;
  434.  
  435.          while(true) {
  436.             while(var15 > var7 || var0[var15] > var12) {
  437.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  438.                   if (var0[var7] == var12) {
  439.                      swap(var0, var7, var8--);
  440.                   }
  441.                }
  442.  
  443.                if (var15 > var7) {
  444.                   int var10 = var1 + var2;
  445.                   int var9 = Math.min(var14 - var1, var15 - var14);
  446.                   vecswap(var0, var1, var15 - var9, var9);
  447.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  448.                   vecswap(var0, var15, var10 - var9, var9);
  449.                   if ((var9 = var15 - var14) > 1) {
  450.                      sort1(var0, var1, var9);
  451.                   }
  452.  
  453.                   if ((var9 = var8 - var7) > 1) {
  454.                      sort1(var0, var10 - var9, var9);
  455.                   }
  456.  
  457.                   return;
  458.                }
  459.  
  460.                swap(var0, var15++, var7--);
  461.             }
  462.  
  463.             if (var0[var15] == var12) {
  464.                swap(var0, var14++, var15);
  465.             }
  466.  
  467.             ++var15;
  468.          }
  469.       }
  470.    }
  471.  
  472.    private static void swap(char[] var0, int var1, int var2) {
  473.       char var3 = var0[var1];
  474.       var0[var1] = var0[var2];
  475.       var0[var2] = var3;
  476.    }
  477.  
  478.    private static void vecswap(char[] var0, int var1, int var2, int var3) {
  479.       for(int var4 = 0; var4 < var3; ++var2) {
  480.          swap(var0, var1, var2);
  481.          ++var4;
  482.          ++var1;
  483.       }
  484.  
  485.    }
  486.  
  487.    private static int med3(char[] var0, int var1, int var2, int var3) {
  488.       return var0[var1] < var0[var2] ? (var0[var2] < var0[var3] ? var2 : (var0[var1] < var0[var3] ? var3 : var1)) : (var0[var2] > var0[var3] ? var2 : (var0[var1] > var0[var3] ? var3 : var1));
  489.    }
  490.  
  491.    private static void sort1(byte[] var0, int var1, int var2) {
  492.       if (var2 < 7) {
  493.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  494.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  495.                swap(var0, var13, var13 - 1);
  496.             }
  497.          }
  498.  
  499.       } else {
  500.          int var3 = var1 + (var2 >> 1);
  501.          if (var2 > 7) {
  502.             int var4 = var1;
  503.             int var5 = var1 + var2 - 1;
  504.             if (var2 > 40) {
  505.                int var6 = var2 / 8;
  506.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  507.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  508.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  509.             }
  510.  
  511.             var3 = med3(var0, var4, var3, var5);
  512.          }
  513.  
  514.          byte var12 = var0[var3];
  515.          int var14 = var1;
  516.          int var15 = var1;
  517.          int var7 = var1 + var2 - 1;
  518.          int var8 = var7;
  519.  
  520.          while(true) {
  521.             while(var15 > var7 || var0[var15] > var12) {
  522.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  523.                   if (var0[var7] == var12) {
  524.                      swap(var0, var7, var8--);
  525.                   }
  526.                }
  527.  
  528.                if (var15 > var7) {
  529.                   int var10 = var1 + var2;
  530.                   int var9 = Math.min(var14 - var1, var15 - var14);
  531.                   vecswap(var0, var1, var15 - var9, var9);
  532.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  533.                   vecswap(var0, var15, var10 - var9, var9);
  534.                   if ((var9 = var15 - var14) > 1) {
  535.                      sort1(var0, var1, var9);
  536.                   }
  537.  
  538.                   if ((var9 = var8 - var7) > 1) {
  539.                      sort1(var0, var10 - var9, var9);
  540.                   }
  541.  
  542.                   return;
  543.                }
  544.  
  545.                swap(var0, var15++, var7--);
  546.             }
  547.  
  548.             if (var0[var15] == var12) {
  549.                swap(var0, var14++, var15);
  550.             }
  551.  
  552.             ++var15;
  553.          }
  554.       }
  555.    }
  556.  
  557.    private static void swap(byte[] var0, int var1, int var2) {
  558.       byte var3 = var0[var1];
  559.       var0[var1] = var0[var2];
  560.       var0[var2] = var3;
  561.    }
  562.  
  563.    private static void vecswap(byte[] var0, int var1, int var2, int var3) {
  564.       for(int var4 = 0; var4 < var3; ++var2) {
  565.          swap(var0, var1, var2);
  566.          ++var4;
  567.          ++var1;
  568.       }
  569.  
  570.    }
  571.  
  572.    private static int med3(byte[] var0, int var1, int var2, int var3) {
  573.       return var0[var1] < var0[var2] ? (var0[var2] < var0[var3] ? var2 : (var0[var1] < var0[var3] ? var3 : var1)) : (var0[var2] > var0[var3] ? var2 : (var0[var1] > var0[var3] ? var3 : var1));
  574.    }
  575.  
  576.    private static void sort1(double[] var0, int var1, int var2) {
  577.       if (var2 < 7) {
  578.          for(int var12 = var1; var12 < var2 + var1; ++var12) {
  579.             for(int var14 = var12; var14 > var1 && var0[var14 - 1] > var0[var14]; --var14) {
  580.                swap(var0, var14, var14 - 1);
  581.             }
  582.          }
  583.  
  584.       } else {
  585.          int var3 = var1 + (var2 >> 1);
  586.          if (var2 > 7) {
  587.             int var4 = var1;
  588.             int var5 = var1 + var2 - 1;
  589.             if (var2 > 40) {
  590.                int var6 = var2 / 8;
  591.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  592.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  593.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  594.             }
  595.  
  596.             var3 = med3(var0, var4, var3, var5);
  597.          }
  598.  
  599.          double var13 = var0[var3];
  600.          int var15 = var1;
  601.          int var7 = var1;
  602.          int var8 = var1 + var2 - 1;
  603.          int var9 = var8;
  604.  
  605.          while(true) {
  606.             while(var7 > var8 || !(var0[var7] <= var13)) {
  607.                for(; var8 >= var7 && var0[var8] >= var13; --var8) {
  608.                   if (var0[var8] == var13) {
  609.                      swap(var0, var8, var9--);
  610.                   }
  611.                }
  612.  
  613.                if (var7 > var8) {
  614.                   int var11 = var1 + var2;
  615.                   int var10 = Math.min(var15 - var1, var7 - var15);
  616.                   vecswap(var0, var1, var7 - var10, var10);
  617.                   var10 = Math.min(var9 - var8, var11 - var9 - 1);
  618.                   vecswap(var0, var7, var11 - var10, var10);
  619.                   if ((var10 = var7 - var15) > 1) {
  620.                      sort1(var0, var1, var10);
  621.                   }
  622.  
  623.                   if ((var10 = var9 - var8) > 1) {
  624.                      sort1(var0, var11 - var10, var10);
  625.                   }
  626.  
  627.                   return;
  628.                }
  629.  
  630.                swap(var0, var7++, var8--);
  631.             }
  632.  
  633.             if (var0[var7] == var13) {
  634.                swap(var0, var15++, var7);
  635.             }
  636.  
  637.             ++var7;
  638.          }
  639.       }
  640.    }
  641.  
  642.    private static void swap(double[] var0, int var1, int var2) {
  643.       double var3 = var0[var1];
  644.       var0[var1] = var0[var2];
  645.       var0[var2] = var3;
  646.    }
  647.  
  648.    private static void vecswap(double[] var0, int var1, int var2, int var3) {
  649.       for(int var4 = 0; var4 < var3; ++var2) {
  650.          swap(var0, var1, var2);
  651.          ++var4;
  652.          ++var1;
  653.       }
  654.  
  655.    }
  656.  
  657.    private static int med3(double[] var0, int var1, int var2, int var3) {
  658.       return var0[var1] < var0[var2] ? (var0[var2] < var0[var3] ? var2 : (var0[var1] < var0[var3] ? var3 : var1)) : (var0[var2] > var0[var3] ? var2 : (var0[var1] > var0[var3] ? var3 : var1));
  659.    }
  660.  
  661.    private static void sort1(float[] var0, int var1, int var2) {
  662.       if (var2 < 7) {
  663.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  664.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  665.                swap(var0, var13, var13 - 1);
  666.             }
  667.          }
  668.  
  669.       } else {
  670.          int var3 = var1 + (var2 >> 1);
  671.          if (var2 > 7) {
  672.             int var4 = var1;
  673.             int var5 = var1 + var2 - 1;
  674.             if (var2 > 40) {
  675.                int var6 = var2 / 8;
  676.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  677.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  678.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  679.             }
  680.  
  681.             var3 = med3(var0, var4, var3, var5);
  682.          }
  683.  
  684.          float var12 = var0[var3];
  685.          int var14 = var1;
  686.          int var15 = var1;
  687.          int var7 = var1 + var2 - 1;
  688.          int var8 = var7;
  689.  
  690.          while(true) {
  691.             while(var15 > var7 || !(var0[var15] <= var12)) {
  692.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  693.                   if (var0[var7] == var12) {
  694.                      swap(var0, var7, var8--);
  695.                   }
  696.                }
  697.  
  698.                if (var15 > var7) {
  699.                   int var10 = var1 + var2;
  700.                   int var9 = Math.min(var14 - var1, var15 - var14);
  701.                   vecswap(var0, var1, var15 - var9, var9);
  702.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  703.                   vecswap(var0, var15, var10 - var9, var9);
  704.                   if ((var9 = var15 - var14) > 1) {
  705.                      sort1(var0, var1, var9);
  706.                   }
  707.  
  708.                   if ((var9 = var8 - var7) > 1) {
  709.                      sort1(var0, var10 - var9, var9);
  710.                   }
  711.  
  712.                   return;
  713.                }
  714.  
  715.                swap(var0, var15++, var7--);
  716.             }
  717.  
  718.             if (var0[var15] == var12) {
  719.                swap(var0, var14++, var15);
  720.             }
  721.  
  722.             ++var15;
  723.          }
  724.       }
  725.    }
  726.  
  727.    private static void swap(float[] var0, int var1, int var2) {
  728.       float var3 = var0[var1];
  729.       var0[var1] = var0[var2];
  730.       var0[var2] = var3;
  731.    }
  732.  
  733.    private static void vecswap(float[] var0, int var1, int var2, int var3) {
  734.       for(int var4 = 0; var4 < var3; ++var2) {
  735.          swap(var0, var1, var2);
  736.          ++var4;
  737.          ++var1;
  738.       }
  739.  
  740.    }
  741.  
  742.    private static int med3(float[] var0, int var1, int var2, int var3) {
  743.       return var0[var1] < var0[var2] ? (var0[var2] < var0[var3] ? var2 : (var0[var1] < var0[var3] ? var3 : var1)) : (var0[var2] > var0[var3] ? var2 : (var0[var1] > var0[var3] ? var3 : var1));
  744.    }
  745.  
  746.    public static void sort(Object[] var0) {
  747.       Object[] var1 = ((Object;)var0).clone();
  748.       mergeSort(var1, var0, 0, var0.length, 0);
  749.    }
  750.  
  751.    public static void sort(Object[] var0, int var1, int var2) {
  752.       rangeCheck(var0.length, var1, var2);
  753.       Object[] var3 = copyOfRange(var0, var1, var2);
  754.       mergeSort(var3, var0, var1, var2, -var1);
  755.    }
  756.  
  757.    private static void mergeSort(Object[] var0, Object[] var1, int var2, int var3, int var4) {
  758.       int var5 = var3 - var2;
  759.       if (var5 < 7) {
  760.          for(int var14 = var2; var14 < var3; ++var14) {
  761.             for(int var15 = var14; var15 > var2 && ((Comparable)var1[var15 - 1]).compareTo(var1[var15]) > 0; --var15) {
  762.                swap(var1, var15, var15 - 1);
  763.             }
  764.          }
  765.  
  766.       } else {
  767.          int var7 = var3;
  768.          var2 += var4;
  769.          var3 += var4;
  770.          int var8 = var2 + var3 >>> 1;
  771.          mergeSort(var1, var0, var2, var8, -var4);
  772.          mergeSort(var1, var0, var8, var3, -var4);
  773.          if (((Comparable)var0[var8 - 1]).compareTo(var0[var8]) <= 0) {
  774.             System.arraycopy(var0, var2, var1, var2, var5);
  775.          } else {
  776.             int var9 = var2;
  777.             int var10 = var2;
  778.  
  779.             for(int var11 = var8; var9 < var7; ++var9) {
  780.                if (var11 < var3 && (var10 >= var8 || ((Comparable)var0[var10]).compareTo(var0[var11]) > 0)) {
  781.                   var1[var9] = var0[var11++];
  782.                } else {
  783.                   var1[var9] = var0[var10++];
  784.                }
  785.             }
  786.  
  787.          }
  788.       }
  789.    }
  790.  
  791.    private static void swap(Object[] var0, int var1, int var2) {
  792.       Object var3 = var0[var1];
  793.       var0[var1] = var0[var2];
  794.       var0[var2] = var3;
  795.    }
  796.  
  797.    public static <T> void sort(T[] var0, Comparator<? super T> var1) {
  798.       Object[] var2 = ((Object;)var0).clone();
  799.       if (var1 == null) {
  800.          mergeSort(var2, var0, 0, var0.length, 0);
  801.       } else {
  802.          mergeSort(var2, var0, 0, var0.length, 0, var1);
  803.       }
  804.  
  805.    }
  806.  
  807.    public static <T> void sort(T[] var0, int var1, int var2, Comparator<? super T> var3) {
  808.       rangeCheck(var0.length, var1, var2);
  809.       Object[] var4 = copyOfRange(var0, var1, var2);
  810.       if (var3 == null) {
  811.          mergeSort(var4, var0, var1, var2, -var1);
  812.       } else {
  813.          mergeSort(var4, var0, var1, var2, -var1, var3);
  814.       }
  815.  
  816.    }
  817.  
  818.    private static void mergeSort(Object[] var0, Object[] var1, int var2, int var3, int var4, Comparator var5) {
  819.       int var6 = var3 - var2;
  820.       if (var6 < 7) {
  821.          for(int var15 = var2; var15 < var3; ++var15) {
  822.             for(int var16 = var15; var16 > var2 && var5.compare(var1[var16 - 1], var1[var16]) > 0; --var16) {
  823.                swap(var1, var16, var16 - 1);
  824.             }
  825.          }
  826.  
  827.       } else {
  828.          int var8 = var3;
  829.          var2 += var4;
  830.          var3 += var4;
  831.          int var9 = var2 + var3 >>> 1;
  832.          mergeSort(var1, var0, var2, var9, -var4, var5);
  833.          mergeSort(var1, var0, var9, var3, -var4, var5);
  834.          if (var5.compare(var0[var9 - 1], var0[var9]) <= 0) {
  835.             System.arraycopy(var0, var2, var1, var2, var6);
  836.          } else {
  837.             int var10 = var2;
  838.             int var11 = var2;
  839.  
  840.             for(int var12 = var9; var10 < var8; ++var10) {
  841.                if (var12 < var3 && (var11 >= var9 || var5.compare(var0[var11], var0[var12]) > 0)) {
  842.                   var1[var10] = var0[var12++];
  843.                } else {
  844.                   var1[var10] = var0[var11++];
  845.                }
  846.             }
  847.  
  848.          }
  849.       }
  850.    }
  851.  
  852.    private static void rangeCheck(int var0, int var1, int var2) {
  853.       if (var1 > var2) {
  854.          throw new IllegalArgumentException("fromIndex(" + var1 + ") > toIndex(" + var2 + ")");
  855.       } else if (var1 < 0) {
  856.          throw new ArrayIndexOutOfBoundsException(var1);
  857.       } else if (var2 > var0) {
  858.          throw new ArrayIndexOutOfBoundsException(var2);
  859.       }
  860.    }
  861.  
  862.    public static int binarySearch(long[] var0, long var1) {
  863.       return binarySearch0(var0, 0, var0.length, var1);
  864.    }
  865.  
  866.    public static int binarySearch(long[] var0, int var1, int var2, long var3) {
  867.       rangeCheck(var0.length, var1, var2);
  868.       return binarySearch0(var0, var1, var2, var3);
  869.    }
  870.  
  871.    private static int binarySearch0(long[] var0, int var1, int var2, long var3) {
  872.       int var5 = var1;
  873.       int var6 = var2 - 1;
  874.  
  875.       while(var5 <= var6) {
  876.          int var7 = var5 + var6 >>> 1;
  877.          long var8 = var0[var7];
  878.          if (var8 < var3) {
  879.             var5 = var7 + 1;
  880.          } else {
  881.             if (var8 <= var3) {
  882.                return var7;
  883.             }
  884.  
  885.             var6 = var7 - 1;
  886.          }
  887.       }
  888.  
  889.       return -(var5 + 1);
  890.    }
  891.  
  892.    public static int binarySearch(int[] var0, int var1) {
  893.       return binarySearch0((int[])var0, 0, var0.length, (int)var1);
  894.    }
  895.  
  896.    public static int binarySearch(int[] var0, int var1, int var2, int var3) {
  897.       rangeCheck(var0.length, var1, var2);
  898.       return binarySearch0(var0, var1, var2, var3);
  899.    }
  900.  
  901.    private static int binarySearch0(int[] var0, int var1, int var2, int var3) {
  902.       int var4 = var1;
  903.       int var5 = var2 - 1;
  904.  
  905.       while(var4 <= var5) {
  906.          int var6 = var4 + var5 >>> 1;
  907.          int var7 = var0[var6];
  908.          if (var7 < var3) {
  909.             var4 = var6 + 1;
  910.          } else {
  911.             if (var7 <= var3) {
  912.                return var6;
  913.             }
  914.  
  915.             var5 = var6 - 1;
  916.          }
  917.       }
  918.  
  919.       return -(var4 + 1);
  920.    }
  921.  
  922.    public static int binarySearch(short[] var0, short var1) {
  923.       return binarySearch0((short[])var0, 0, var0.length, (short)var1);
  924.    }
  925.  
  926.    public static int binarySearch(short[] var0, int var1, int var2, short var3) {
  927.       rangeCheck(var0.length, var1, var2);
  928.       return binarySearch0(var0, var1, var2, var3);
  929.    }
  930.  
  931.    private static int binarySearch0(short[] var0, int var1, int var2, short var3) {
  932.       int var4 = var1;
  933.       int var5 = var2 - 1;
  934.  
  935.       while(var4 <= var5) {
  936.          int var6 = var4 + var5 >>> 1;
  937.          short var7 = var0[var6];
  938.          if (var7 < var3) {
  939.             var4 = var6 + 1;
  940.          } else {
  941.             if (var7 <= var3) {
  942.                return var6;
  943.             }
  944.  
  945.             var5 = var6 - 1;
  946.          }
  947.       }
  948.  
  949.       return -(var4 + 1);
  950.    }
  951.  
  952.    public static int binarySearch(char[] var0, char var1) {
  953.       return binarySearch0((char[])var0, 0, var0.length, (char)var1);
  954.    }
  955.  
  956.    public static int binarySearch(char[] var0, int var1, int var2, char var3) {
  957.       rangeCheck(var0.length, var1, var2);
  958.       return binarySearch0(var0, var1, var2, var3);
  959.    }
  960.  
  961.    private static int binarySearch0(char[] var0, int var1, int var2, char var3) {
  962.       int var4 = var1;
  963.       int var5 = var2 - 1;
  964.  
  965.       while(var4 <= var5) {
  966.          int var6 = var4 + var5 >>> 1;
  967.          char var7 = var0[var6];
  968.          if (var7 < var3) {
  969.             var4 = var6 + 1;
  970.          } else {
  971.             if (var7 <= var3) {
  972.                return var6;
  973.             }
  974.  
  975.             var5 = var6 - 1;
  976.          }
  977.       }
  978.  
  979.       return -(var4 + 1);
  980.    }
  981.  
  982.    public static int binarySearch(byte[] var0, byte var1) {
  983.       return binarySearch0((byte[])var0, 0, var0.length, (byte)var1);
  984.    }
  985.  
  986.    public static int binarySearch(byte[] var0, int var1, int var2, byte var3) {
  987.       rangeCheck(var0.length, var1, var2);
  988.       return binarySearch0(var0, var1, var2, var3);
  989.    }
  990.  
  991.    private static int binarySearch0(byte[] var0, int var1, int var2, byte var3) {
  992.       int var4 = var1;
  993.       int var5 = var2 - 1;
  994.  
  995.       while(var4 <= var5) {
  996.          int var6 = var4 + var5 >>> 1;
  997.          byte var7 = var0[var6];
  998.          if (var7 < var3) {
  999.             var4 = var6 + 1;
  1000.          } else {
  1001.             if (var7 <= var3) {
  1002.                return var6;
  1003.             }
  1004.  
  1005.             var5 = var6 - 1;
  1006.          }
  1007.       }
  1008.  
  1009.       return -(var4 + 1);
  1010.    }
  1011.  
  1012.    public static int binarySearch(double[] var0, double var1) {
  1013.       return binarySearch0(var0, 0, var0.length, var1);
  1014.    }
  1015.  
  1016.    public static int binarySearch(double[] var0, int var1, int var2, double var3) {
  1017.       rangeCheck(var0.length, var1, var2);
  1018.       return binarySearch0(var0, var1, var2, var3);
  1019.    }
  1020.  
  1021.    private static int binarySearch0(double[] var0, int var1, int var2, double var3) {
  1022.       int var5 = var1;
  1023.       int var6 = var2 - 1;
  1024.  
  1025.       while(var5 <= var6) {
  1026.          int var7 = var5 + var6 >>> 1;
  1027.          double var8 = var0[var7];
  1028.          int var10;
  1029.          if (var8 < var3) {
  1030.             var10 = -1;
  1031.          } else if (var8 > var3) {
  1032.             var10 = 1;
  1033.          } else {
  1034.             long var11 = Double.doubleToLongBits(var8);
  1035.             long var13 = Double.doubleToLongBits(var3);
  1036.             var10 = var11 == var13 ? 0 : (var11 < var13 ? -1 : 1);
  1037.          }
  1038.  
  1039.          if (var10 < 0) {
  1040.             var5 = var7 + 1;
  1041.          } else {
  1042.             if (var10 <= 0) {
  1043.                return var7;
  1044.             }
  1045.  
  1046.             var6 = var7 - 1;
  1047.          }
  1048.       }
  1049.  
  1050.       return -(var5 + 1);
  1051.    }
  1052.  
  1053.    public static int binarySearch(float[] var0, float var1) {
  1054.       return binarySearch0(var0, 0, var0.length, var1);
  1055.    }
  1056.  
  1057.    public static int binarySearch(float[] var0, int var1, int var2, float var3) {
  1058.       rangeCheck(var0.length, var1, var2);
  1059.       return binarySearch0(var0, var1, var2, var3);
  1060.    }
  1061.  
  1062.    private static int binarySearch0(float[] var0, int var1, int var2, float var3) {
  1063.       int var4 = var1;
  1064.       int var5 = var2 - 1;
  1065.  
  1066.       while(var4 <= var5) {
  1067.          int var6 = var4 + var5 >>> 1;
  1068.          float var7 = var0[var6];
  1069.          int var8;
  1070.          if (var7 < var3) {
  1071.             var8 = -1;
  1072.          } else if (var7 > var3) {
  1073.             var8 = 1;
  1074.          } else {
  1075.             int var9 = Float.floatToIntBits(var7);
  1076.             int var10 = Float.floatToIntBits(var3);
  1077.             var8 = var9 == var10 ? 0 : (var9 < var10 ? -1 : 1);
  1078.          }
  1079.  
  1080.          if (var8 < 0) {
  1081.             var4 = var6 + 1;
  1082.          } else {
  1083.             if (var8 <= 0) {
  1084.                return var6;
  1085.             }
  1086.  
  1087.             var5 = var6 - 1;
  1088.          }
  1089.       }
  1090.  
  1091.       return -(var4 + 1);
  1092.    }
  1093.  
  1094.    public static int binarySearch(Object[] var0, Object var1) {
  1095.       return binarySearch0(var0, 0, var0.length, var1);
  1096.    }
  1097.  
  1098.    public static int binarySearch(Object[] var0, int var1, int var2, Object var3) {
  1099.       rangeCheck(var0.length, var1, var2);
  1100.       return binarySearch0(var0, var1, var2, var3);
  1101.    }
  1102.  
  1103.    private static int binarySearch0(Object[] var0, int var1, int var2, Object var3) {
  1104.       int var4 = var1;
  1105.       int var5 = var2 - 1;
  1106.  
  1107.       while(var4 <= var5) {
  1108.          int var6 = var4 + var5 >>> 1;
  1109.          Comparable var7 = (Comparable)var0[var6];
  1110.          int var8 = var7.compareTo(var3);
  1111.          if (var8 < 0) {
  1112.             var4 = var6 + 1;
  1113.          } else {
  1114.             if (var8 <= 0) {
  1115.                return var6;
  1116.             }
  1117.  
  1118.             var5 = var6 - 1;
  1119.          }
  1120.       }
  1121.  
  1122.       return -(var4 + 1);
  1123.    }
  1124.  
  1125.    public static <T> int binarySearch(T[] var0, T var1, Comparator<? super T> var2) {
  1126.       return binarySearch0(var0, 0, var0.length, var1, var2);
  1127.    }
  1128.  
  1129.    public static <T> int binarySearch(T[] var0, int var1, int var2, T var3, Comparator<? super T> var4) {
  1130.       rangeCheck(var0.length, var1, var2);
  1131.       return binarySearch0(var0, var1, var2, var3, var4);
  1132.    }
  1133.  
  1134.    private static <T> int binarySearch0(T[] var0, int var1, int var2, T var3, Comparator<? super T> var4) {
  1135.       if (var4 == null) {
  1136.          return binarySearch0(var0, var1, var2, var3);
  1137.       } else {
  1138.          int var5 = var1;
  1139.          int var6 = var2 - 1;
  1140.  
  1141.          while(var5 <= var6) {
  1142.             int var7 = var5 + var6 >>> 1;
  1143.             Object var8 = var0[var7];
  1144.             int var9 = var4.compare(var8, var3);
  1145.             if (var9 < 0) {
  1146.                var5 = var7 + 1;
  1147.             } else {
  1148.                if (var9 <= 0) {
  1149.                   return var7;
  1150.                }
  1151.  
  1152.                var6 = var7 - 1;
  1153.             }
  1154.          }
  1155.  
  1156.          return -(var5 + 1);
  1157.       }
  1158.    }
  1159.  
  1160.    public static boolean equals(long[] var0, long[] var1) {
  1161.       if (var0 == var1) {
  1162.          return true;
  1163.       } else if (var0 != null && var1 != null) {
  1164.          int var2 = var0.length;
  1165.          if (var1.length != var2) {
  1166.             return false;
  1167.          } else {
  1168.             for(int var3 = 0; var3 < var2; ++var3) {
  1169.                if (var0[var3] != var1[var3]) {
  1170.                   return false;
  1171.                }
  1172.             }
  1173.  
  1174.             return true;
  1175.          }
  1176.       } else {
  1177.          return false;
  1178.       }
  1179.    }
  1180.  
  1181.    public static boolean equals(int[] var0, int[] var1) {
  1182.       if (var0 == var1) {
  1183.          return true;
  1184.       } else if (var0 != null && var1 != null) {
  1185.          int var2 = var0.length;
  1186.          if (var1.length != var2) {
  1187.             return false;
  1188.          } else {
  1189.             for(int var3 = 0; var3 < var2; ++var3) {
  1190.                if (var0[var3] != var1[var3]) {
  1191.                   return false;
  1192.                }
  1193.             }
  1194.  
  1195.             return true;
  1196.          }
  1197.       } else {
  1198.          return false;
  1199.       }
  1200.    }
  1201.  
  1202.    public static boolean equals(short[] var0, short[] var1) {
  1203.       if (var0 == var1) {
  1204.          return true;
  1205.       } else if (var0 != null && var1 != null) {
  1206.          int var2 = var0.length;
  1207.          if (var1.length != var2) {
  1208.             return false;
  1209.          } else {
  1210.             for(int var3 = 0; var3 < var2; ++var3) {
  1211.                if (var0[var3] != var1[var3]) {
  1212.                   return false;
  1213.                }
  1214.             }
  1215.  
  1216.             return true;
  1217.          }
  1218.       } else {
  1219.          return false;
  1220.       }
  1221.    }
  1222.  
  1223.    public static boolean equals(char[] var0, char[] var1) {
  1224.       if (var0 == var1) {
  1225.          return true;
  1226.       } else if (var0 != null && var1 != null) {
  1227.          int var2 = var0.length;
  1228.          if (var1.length != var2) {
  1229.             return false;
  1230.          } else {
  1231.             for(int var3 = 0; var3 < var2; ++var3) {
  1232.                if (var0[var3] != var1[var3]) {
  1233.                   return false;
  1234.                }
  1235.             }
  1236.  
  1237.             return true;
  1238.          }
  1239.       } else {
  1240.          return false;
  1241.       }
  1242.    }
  1243.  
  1244.    public static boolean equals(byte[] var0, byte[] var1) {
  1245.       if (var0 == var1) {
  1246.          return true;
  1247.       } else if (var0 != null && var1 != null) {
  1248.          int var2 = var0.length;
  1249.          if (var1.length != var2) {
  1250.             return false;
  1251.          } else {
  1252.             for(int var3 = 0; var3 < var2; ++var3) {
  1253.                if (var0[var3] != var1[var3]) {
  1254.                   return false;
  1255.                }
  1256.             }
  1257.  
  1258.             return true;
  1259.          }
  1260.       } else {
  1261.          return false;
  1262.       }
  1263.    }
  1264.  
  1265.    public static boolean equals(boolean[] var0, boolean[] var1) {
  1266.       if (var0 == var1) {
  1267.          return true;
  1268.       } else if (var0 != null && var1 != null) {
  1269.          int var2 = var0.length;
  1270.          if (var1.length != var2) {
  1271.             return false;
  1272.          } else {
  1273.             for(int var3 = 0; var3 < var2; ++var3) {
  1274.                if (var0[var3] != var1[var3]) {
  1275.                   return false;
  1276.                }
  1277.             }
  1278.  
  1279.             return true;
  1280.          }
  1281.       } else {
  1282.          return false;
  1283.       }
  1284.    }
  1285.  
  1286.    public static boolean equals(double[] var0, double[] var1) {
  1287.       if (var0 == var1) {
  1288.          return true;
  1289.       } else if (var0 != null && var1 != null) {
  1290.          int var2 = var0.length;
  1291.          if (var1.length != var2) {
  1292.             return false;
  1293.          } else {
  1294.             for(int var3 = 0; var3 < var2; ++var3) {
  1295.                if (Double.doubleToLongBits(var0[var3]) != Double.doubleToLongBits(var1[var3])) {
  1296.                   return false;
  1297.                }
  1298.             }
  1299.  
  1300.             return true;
  1301.          }
  1302.       } else {
  1303.          return false;
  1304.       }
  1305.    }
  1306.  
  1307.    public static boolean equals(float[] var0, float[] var1) {
  1308.       if (var0 == var1) {
  1309.          return true;
  1310.       } else if (var0 != null && var1 != null) {
  1311.          int var2 = var0.length;
  1312.          if (var1.length != var2) {
  1313.             return false;
  1314.          } else {
  1315.             for(int var3 = 0; var3 < var2; ++var3) {
  1316.                if (Float.floatToIntBits(var0[var3]) != Float.floatToIntBits(var1[var3])) {
  1317.                   return false;
  1318.                }
  1319.             }
  1320.  
  1321.             return true;
  1322.          }
  1323.       } else {
  1324.          return false;
  1325.       }
  1326.    }
  1327.  
  1328.    public static boolean equals(Object[] var0, Object[] var1) {
  1329.       if (var0 == var1) {
  1330.          return true;
  1331.       } else if (var0 != null && var1 != null) {
  1332.          int var2 = var0.length;
  1333.          if (var1.length != var2) {
  1334.             return false;
  1335.          } else {
  1336.             int var3 = 0;
  1337.  
  1338.             while(true) {
  1339.                if (var3 >= var2) {
  1340.                   return true;
  1341.                }
  1342.  
  1343.                Object var4 = var0[var3];
  1344.                Object var5 = var1[var3];
  1345.                if (var4 == null) {
  1346.                   if (var5 != null) {
  1347.                      break;
  1348.                   }
  1349.                } else if (!var4.equals(var5)) {
  1350.                   break;
  1351.                }
  1352.  
  1353.                ++var3;
  1354.             }
  1355.  
  1356.             return false;
  1357.          }
  1358.       } else {
  1359.          return false;
  1360.       }
  1361.    }
  1362.  
  1363.    public static void fill(long[] var0, long var1) {
  1364.       fill(var0, 0, var0.length, var1);
  1365.    }
  1366.  
  1367.    public static void fill(long[] var0, int var1, int var2, long var3) {
  1368.       rangeCheck(var0.length, var1, var2);
  1369.  
  1370.       for(int var5 = var1; var5 < var2; ++var5) {
  1371.          var0[var5] = var3;
  1372.       }
  1373.  
  1374.    }
  1375.  
  1376.    public static void fill(int[] var0, int var1) {
  1377.       fill((int[])var0, 0, var0.length, (int)var1);
  1378.    }
  1379.  
  1380.    public static void fill(int[] var0, int var1, int var2, int var3) {
  1381.       rangeCheck(var0.length, var1, var2);
  1382.  
  1383.       for(int var4 = var1; var4 < var2; ++var4) {
  1384.          var0[var4] = var3;
  1385.       }
  1386.  
  1387.    }
  1388.  
  1389.    public static void fill(short[] var0, short var1) {
  1390.       fill((short[])var0, 0, var0.length, (short)var1);
  1391.    }
  1392.  
  1393.    public static void fill(short[] var0, int var1, int var2, short var3) {
  1394.       rangeCheck(var0.length, var1, var2);
  1395.  
  1396.       for(int var4 = var1; var4 < var2; ++var4) {
  1397.          var0[var4] = var3;
  1398.       }
  1399.  
  1400.    }
  1401.  
  1402.    public static void fill(char[] var0, char var1) {
  1403.       fill((char[])var0, 0, var0.length, (char)var1);
  1404.    }
  1405.  
  1406.    public static void fill(char[] var0, int var1, int var2, char var3) {
  1407.       rangeCheck(var0.length, var1, var2);
  1408.  
  1409.       for(int var4 = var1; var4 < var2; ++var4) {
  1410.          var0[var4] = var3;
  1411.       }
  1412.  
  1413.    }
  1414.  
  1415.    public static void fill(byte[] var0, byte var1) {
  1416.       fill((byte[])var0, 0, var0.length, (byte)var1);
  1417.    }
  1418.  
  1419.    public static void fill(byte[] var0, int var1, int var2, byte var3) {
  1420.       rangeCheck(var0.length, var1, var2);
  1421.  
  1422.       for(int var4 = var1; var4 < var2; ++var4) {
  1423.          var0[var4] = var3;
  1424.       }
  1425.  
  1426.    }
  1427.  
  1428.    public static void fill(boolean[] var0, boolean var1) {
  1429.       fill(var0, 0, var0.length, var1);
  1430.    }
  1431.  
  1432.    public static void fill(boolean[] var0, int var1, int var2, boolean var3) {
  1433.       rangeCheck(var0.length, var1, var2);
  1434.  
  1435.       for(int var4 = var1; var4 < var2; ++var4) {
  1436.          var0[var4] = var3;
  1437.       }
  1438.  
  1439.    }
  1440.  
  1441.    public static void fill(double[] var0, double var1) {
  1442.       fill(var0, 0, var0.length, var1);
  1443.    }
  1444.  
  1445.    public static void fill(double[] var0, int var1, int var2, double var3) {
  1446.       rangeCheck(var0.length, var1, var2);
  1447.  
  1448.       for(int var5 = var1; var5 < var2; ++var5) {
  1449.          var0[var5] = var3;
  1450.       }
  1451.  
  1452.    }
  1453.  
  1454.    public static void fill(float[] var0, float var1) {
  1455.       fill(var0, 0, var0.length, var1);
  1456.    }
  1457.  
  1458.    public static void fill(float[] var0, int var1, int var2, float var3) {
  1459.       rangeCheck(var0.length, var1, var2);
  1460.  
  1461.       for(int var4 = var1; var4 < var2; ++var4) {
  1462.          var0[var4] = var3;
  1463.       }
  1464.  
  1465.    }
  1466.  
  1467.    public static void fill(Object[] var0, Object var1) {
  1468.       fill(var0, 0, var0.length, var1);
  1469.    }
  1470.  
  1471.    public static void fill(Object[] var0, int var1, int var2, Object var3) {
  1472.       rangeCheck(var0.length, var1, var2);
  1473.  
  1474.       for(int var4 = var1; var4 < var2; ++var4) {
  1475.          var0[var4] = var3;
  1476.       }
  1477.  
  1478.    }
  1479.  
  1480.    public static <T> T[] copyOf(T[] var0, int var1) {
  1481.       return (T[])(copyOf(var0, var1, var0.getClass()));
  1482.    }
  1483.  
  1484.    public static <T, U> T[] copyOf(U[] var0, int var1, Class<? extends T[]> var2) {
  1485.       Object[] var3 = var2 == Object[].class ? (Object[])(new Object[var1]) : (Object[])((Object[])Array.newInstance(var2.getComponentType(), var1));
  1486.       System.arraycopy(var0, 0, var3, 0, Math.min(var0.length, var1));
  1487.       return (T[])var3;
  1488.    }
  1489.  
  1490.    public static byte[] copyOf(byte[] var0, int var1) {
  1491.       byte[] var2 = new byte[var1];
  1492.       System.arraycopy(var0, 0, var2, 0, Math.min(var0.length, var1));
  1493.       return var2;
  1494.    }
  1495.  
  1496.    public static short[] copyOf(short[] var0, int var1) {
  1497.       short[] var2 = new short[var1];
  1498.       System.arraycopy(var0, 0, var2, 0, Math.min(var0.length, var1));
  1499.       return var2;
  1500.    }
  1501.  
  1502.    public static int[] copyOf(int[] var0, int var1) {
  1503.       int[] var2 = new int[var1];
  1504.       System.arraycopy(var0, 0, var2, 0, Math.min(var0.length, var1));
  1505.       return var2;
  1506.    }
  1507.  
  1508.    public static long[] copyOf(long[] var0, int var1) {
  1509.       long[] var2 = new long[var1];
  1510.       System.arraycopy(var0, 0, var2, 0, Math.min(var0.length, var1));
  1511.       return var2;
  1512.    }
  1513.  
  1514.    public static char[] copyOf(char[] var0, int var1) {
  1515.       char[] var2 = new char[var1];
  1516.       System.arraycopy(var0, 0, var2, 0, Math.min(var0.length, var1));
  1517.       return var2;
  1518.    }
  1519.  
  1520.    public static float[] copyOf(float[] var0, int var1) {
  1521.       float[] var2 = new float[var1];
  1522.       System.arraycopy(var0, 0, var2, 0, Math.min(var0.length, var1));
  1523.       return var2;
  1524.    }
  1525.  
  1526.    public static double[] copyOf(double[] var0, int var1) {
  1527.       double[] var2 = new double[var1];
  1528.       System.arraycopy(var0, 0, var2, 0, Math.min(var0.length, var1));
  1529.       return var2;
  1530.    }
  1531.  
  1532.    public static boolean[] copyOf(boolean[] var0, int var1) {
  1533.       boolean[] var2 = new boolean[var1];
  1534.       System.arraycopy(var0, 0, var2, 0, Math.min(var0.length, var1));
  1535.       return var2;
  1536.    }
  1537.  
  1538.    public static <T> T[] copyOfRange(T[] var0, int var1, int var2) {
  1539.       return (T[])copyOfRange(var0, var1, var2, var0.getClass());
  1540.    }
  1541.  
  1542.    public static <T, U> T[] copyOfRange(U[] var0, int var1, int var2, Class<? extends T[]> var3) {
  1543.       int var4 = var2 - var1;
  1544.       if (var4 < 0) {
  1545.          throw new IllegalArgumentException(var1 + " > " + var2);
  1546.       } else {
  1547.          Object[] var5 = var3 == Object[].class ? (Object[])(new Object[var4]) : (Object[])((Object[])Array.newInstance(var3.getComponentType(), var4));
  1548.          System.arraycopy(var0, var1, var5, 0, Math.min(var0.length - var1, var4));
  1549.          return (T[])var5;
  1550.       }
  1551.    }
  1552.  
  1553.    public static byte[] copyOfRange(byte[] var0, int var1, int var2) {
  1554.       int var3 = var2 - var1;
  1555.       if (var3 < 0) {
  1556.          throw new IllegalArgumentException(var1 + " > " + var2);
  1557.       } else {
  1558.          byte[] var4 = new byte[var3];
  1559.          System.arraycopy(var0, var1, var4, 0, Math.min(var0.length - var1, var3));
  1560.          return var4;
  1561.       }
  1562.    }
  1563.  
  1564.    public static short[] copyOfRange(short[] var0, int var1, int var2) {
  1565.       int var3 = var2 - var1;
  1566.       if (var3 < 0) {
  1567.          throw new IllegalArgumentException(var1 + " > " + var2);
  1568.       } else {
  1569.          short[] var4 = new short[var3];
  1570.          System.arraycopy(var0, var1, var4, 0, Math.min(var0.length - var1, var3));
  1571.          return var4;
  1572.       }
  1573.    }
  1574.  
  1575.    public static int[] copyOfRange(int[] var0, int var1, int var2) {
  1576.       int var3 = var2 - var1;
  1577.       if (var3 < 0) {
  1578.          throw new IllegalArgumentException(var1 + " > " + var2);
  1579.       } else {
  1580.          int[] var4 = new int[var3];
  1581.          System.arraycopy(var0, var1, var4, 0, Math.min(var0.length - var1, var3));
  1582.          return var4;
  1583.       }
  1584.    }
  1585.  
  1586.    public static long[] copyOfRange(long[] var0, int var1, int var2) {
  1587.       int var3 = var2 - var1;
  1588.       if (var3 < 0) {
  1589.          throw new IllegalArgumentException(var1 + " > " + var2);
  1590.       } else {
  1591.          long[] var4 = new long[var3];
  1592.          System.arraycopy(var0, var1, var4, 0, Math.min(var0.length - var1, var3));
  1593.          return var4;
  1594.       }
  1595.    }
  1596.  
  1597.    public static char[] copyOfRange(char[] var0, int var1, int var2) {
  1598.       int var3 = var2 - var1;
  1599.       if (var3 < 0) {
  1600.          throw new IllegalArgumentException(var1 + " > " + var2);
  1601.       } else {
  1602.          char[] var4 = new char[var3];
  1603.          System.arraycopy(var0, var1, var4, 0, Math.min(var0.length - var1, var3));
  1604.          return var4;
  1605.       }
  1606.    }
  1607.  
  1608.    public static float[] copyOfRange(float[] var0, int var1, int var2) {
  1609.       int var3 = var2 - var1;
  1610.       if (var3 < 0) {
  1611.          throw new IllegalArgumentException(var1 + " > " + var2);
  1612.       } else {
  1613.          float[] var4 = new float[var3];
  1614.          System.arraycopy(var0, var1, var4, 0, Math.min(var0.length - var1, var3));
  1615.          return var4;
  1616.       }
  1617.    }
  1618.  
  1619.    public static double[] copyOfRange(double[] var0, int var1, int var2) {
  1620.       int var3 = var2 - var1;
  1621.       if (var3 < 0) {
  1622.          throw new IllegalArgumentException(var1 + " > " + var2);
  1623.       } else {
  1624.          double[] var4 = new double[var3];
  1625.          System.arraycopy(var0, var1, var4, 0, Math.min(var0.length - var1, var3));
  1626.          return var4;
  1627.       }
  1628.    }
  1629.  
  1630.    public static boolean[] copyOfRange(boolean[] var0, int var1, int var2) {
  1631.       int var3 = var2 - var1;
  1632.       if (var3 < 0) {
  1633.          throw new IllegalArgumentException(var1 + " > " + var2);
  1634.       } else {
  1635.          boolean[] var4 = new boolean[var3];
  1636.          System.arraycopy(var0, var1, var4, 0, Math.min(var0.length - var1, var3));
  1637.          return var4;
  1638.       }
  1639.    }
  1640.  
  1641.    public static <T> List<T> asList(T... var0) {
  1642.       return new ArrayList(var0);
  1643.    }
  1644.  
  1645.    public static int hashCode(long[] var0) {
  1646.       if (var0 == null) {
  1647.          return 0;
  1648.       } else {
  1649.          int var1 = 1;
  1650.  
  1651.          for(long var5 : var0) {
  1652.             int var7 = (int)(var5 ^ var5 >>> 32);
  1653.             var1 = 31 * var1 + var7;
  1654.          }
  1655.  
  1656.          return var1;
  1657.       }
  1658.    }
  1659.  
  1660.    public static int hashCode(int[] var0) {
  1661.       if (var0 == null) {
  1662.          return 0;
  1663.       } else {
  1664.          int var1 = 1;
  1665.  
  1666.          for(int var5 : var0) {
  1667.             var1 = 31 * var1 + var5;
  1668.          }
  1669.  
  1670.          return var1;
  1671.       }
  1672.    }
  1673.  
  1674.    public static int hashCode(short[] var0) {
  1675.       if (var0 == null) {
  1676.          return 0;
  1677.       } else {
  1678.          int var1 = 1;
  1679.  
  1680.          for(short var5 : var0) {
  1681.             var1 = 31 * var1 + var5;
  1682.          }
  1683.  
  1684.          return var1;
  1685.       }
  1686.    }
  1687.  
  1688.    public static int hashCode(char[] var0) {
  1689.       if (var0 == null) {
  1690.          return 0;
  1691.       } else {
  1692.          int var1 = 1;
  1693.  
  1694.          for(char var5 : var0) {
  1695.             var1 = 31 * var1 + var5;
  1696.          }
  1697.  
  1698.          return var1;
  1699.       }
  1700.    }
  1701.  
  1702.    public static int hashCode(byte[] var0) {
  1703.       if (var0 == null) {
  1704.          return 0;
  1705.       } else {
  1706.          int var1 = 1;
  1707.  
  1708.          for(byte var5 : var0) {
  1709.             var1 = 31 * var1 + var5;
  1710.          }
  1711.  
  1712.          return var1;
  1713.       }
  1714.    }
  1715.  
  1716.    public static int hashCode(boolean[] var0) {
  1717.       if (var0 == null) {
  1718.          return 0;
  1719.       } else {
  1720.          int var1 = 1;
  1721.  
  1722.          for(boolean var5 : var0) {
  1723.             var1 = 31 * var1 + (var5 ? 1231 : 1237);
  1724.          }
  1725.  
  1726.          return var1;
  1727.       }
  1728.    }
  1729.  
  1730.    public static int hashCode(float[] var0) {
  1731.       if (var0 == null) {
  1732.          return 0;
  1733.       } else {
  1734.          int var1 = 1;
  1735.  
  1736.          for(float var5 : var0) {
  1737.             var1 = 31 * var1 + Float.floatToIntBits(var5);
  1738.          }
  1739.  
  1740.          return var1;
  1741.       }
  1742.    }
  1743.  
  1744.    public static int hashCode(double[] var0) {
  1745.       if (var0 == null) {
  1746.          return 0;
  1747.       } else {
  1748.          int var1 = 1;
  1749.  
  1750.          for(double var5 : var0) {
  1751.             long var7 = Double.doubleToLongBits(var5);
  1752.             var1 = 31 * var1 + (int)(var7 ^ var7 >>> 32);
  1753.          }
  1754.  
  1755.          return var1;
  1756.       }
  1757.    }
  1758.  
  1759.    public static int hashCode(Object[] var0) {
  1760.       if (var0 == null) {
  1761.          return 0;
  1762.       } else {
  1763.          int var1 = 1;
  1764.  
  1765.          for(Object var5 : var0) {
  1766.             var1 = 31 * var1 + (var5 == null ? 0 : var5.hashCode());
  1767.          }
  1768.  
  1769.          return var1;
  1770.       }
  1771.    }
  1772.  
  1773.    public static int deepHashCode(Object[] var0) {
  1774.       if (var0 == null) {
  1775.          return 0;
  1776.       } else {
  1777.          int var1 = 1;
  1778.  
  1779.          for(Object var5 : var0) {
  1780.             int var6 = 0;
  1781.             if (var5 instanceof Object[]) {
  1782.                var6 = deepHashCode(var5);
  1783.             } else if (var5 instanceof byte[]) {
  1784.                var6 = hashCode((byte[])var5);
  1785.             } else if (var5 instanceof short[]) {
  1786.                var6 = hashCode((short[])var5);
  1787.             } else if (var5 instanceof int[]) {
  1788.                var6 = hashCode((int[])var5);
  1789.             } else if (var5 instanceof long[]) {
  1790.                var6 = hashCode((long[])var5);
  1791.             } else if (var5 instanceof char[]) {
  1792.                var6 = hashCode((char[])var5);
  1793.             } else if (var5 instanceof float[]) {
  1794.                var6 = hashCode((float[])var5);
  1795.             } else if (var5 instanceof double[]) {
  1796.                var6 = hashCode((double[])var5);
  1797.             } else if (var5 instanceof boolean[]) {
  1798.                var6 = hashCode((boolean[])var5);
  1799.             } else if (var5 != null) {
  1800.                var6 = var5.hashCode();
  1801.             }
  1802.  
  1803.             var1 = 31 * var1 + var6;
  1804.          }
  1805.  
  1806.          return var1;
  1807.       }
  1808.    }
  1809.  
  1810.    public static boolean deepEquals(Object[] var0, Object[] var1) {
  1811.       if (var0 == var1) {
  1812.          return true;
  1813.       } else if (var0 != null && var1 != null) {
  1814.          int var2 = var0.length;
  1815.          if (var1.length != var2) {
  1816.             return false;
  1817.          } else {
  1818.             for(int var3 = 0; var3 < var2; ++var3) {
  1819.                Object var4 = var0[var3];
  1820.                Object var5 = var1[var3];
  1821.                if (var4 != var5) {
  1822.                   if (var4 == null) {
  1823.                      return false;
  1824.                   }
  1825.  
  1826.                   boolean var6;
  1827.                   if (var4 instanceof Object[] && var5 instanceof Object[]) {
  1828.                      var6 = deepEquals(var4, var5);
  1829.                   } else if (var4 instanceof byte[] && var5 instanceof byte[]) {
  1830.                      var6 = equals((byte[])var4, (byte[])var5);
  1831.                   } else if (var4 instanceof short[] && var5 instanceof short[]) {
  1832.                      var6 = equals((short[])var4, (short[])var5);
  1833.                   } else if (var4 instanceof int[] && var5 instanceof int[]) {
  1834.                      var6 = equals((int[])var4, (int[])var5);
  1835.                   } else if (var4 instanceof long[] && var5 instanceof long[]) {
  1836.                      var6 = equals((long[])var4, (long[])var5);
  1837.                   } else if (var4 instanceof char[] && var5 instanceof char[]) {
  1838.                      var6 = equals((char[])var4, (char[])var5);
  1839.                   } else if (var4 instanceof float[] && var5 instanceof float[]) {
  1840.                      var6 = equals((float[])var4, (float[])var5);
  1841.                   } else if (var4 instanceof double[] && var5 instanceof double[]) {
  1842.                      var6 = equals((double[])var4, (double[])var5);
  1843.                   } else if (var4 instanceof boolean[] && var5 instanceof boolean[]) {
  1844.                      var6 = equals((boolean[])var4, (boolean[])var5);
  1845.                   } else {
  1846.                      var6 = var4.equals(var5);
  1847.                   }
  1848.  
  1849.                   if (!var6) {
  1850.                      return false;
  1851.                   }
  1852.                }
  1853.             }
  1854.  
  1855.             return true;
  1856.          }
  1857.       } else {
  1858.          return false;
  1859.       }
  1860.    }
  1861.  
  1862.    public static String toString(long[] var0) {
  1863.       if (var0 == null) {
  1864.          return "null";
  1865.       } else {
  1866.          int var1 = var0.length - 1;
  1867.          if (var1 == -1) {
  1868.             return "[]";
  1869.          } else {
  1870.             StringBuilder var2 = new StringBuilder();
  1871.             var2.append('[');
  1872.             int var3 = 0;
  1873.  
  1874.             while(true) {
  1875.                var2.append(var0[var3]);
  1876.                if (var3 == var1) {
  1877.                   return var2.append(']').toString();
  1878.                }
  1879.  
  1880.                var2.append(", ");
  1881.                ++var3;
  1882.             }
  1883.          }
  1884.       }
  1885.    }
  1886.  
  1887.    public static String toString(int[] var0) {
  1888.       if (var0 == null) {
  1889.          return "null";
  1890.       } else {
  1891.          int var1 = var0.length - 1;
  1892.          if (var1 == -1) {
  1893.             return "[]";
  1894.          } else {
  1895.             StringBuilder var2 = new StringBuilder();
  1896.             var2.append('[');
  1897.             int var3 = 0;
  1898.  
  1899.             while(true) {
  1900.                var2.append(var0[var3]);
  1901.                if (var3 == var1) {
  1902.                   return var2.append(']').toString();
  1903.                }
  1904.  
  1905.                var2.append(", ");
  1906.                ++var3;
  1907.             }
  1908.          }
  1909.       }
  1910.    }
  1911.  
  1912.    public static String toString(short[] var0) {
  1913.       if (var0 == null) {
  1914.          return "null";
  1915.       } else {
  1916.          int var1 = var0.length - 1;
  1917.          if (var1 == -1) {
  1918.             return "[]";
  1919.          } else {
  1920.             StringBuilder var2 = new StringBuilder();
  1921.             var2.append('[');
  1922.             int var3 = 0;
  1923.  
  1924.             while(true) {
  1925.                var2.append(var0[var3]);
  1926.                if (var3 == var1) {
  1927.                   return var2.append(']').toString();
  1928.                }
  1929.  
  1930.                var2.append(", ");
  1931.                ++var3;
  1932.             }
  1933.          }
  1934.       }
  1935.    }
  1936.  
  1937.    public static String toString(char[] var0) {
  1938.       if (var0 == null) {
  1939.          return "null";
  1940.       } else {
  1941.          int var1 = var0.length - 1;
  1942.          if (var1 == -1) {
  1943.             return "[]";
  1944.          } else {
  1945.             StringBuilder var2 = new StringBuilder();
  1946.             var2.append('[');
  1947.             int var3 = 0;
  1948.  
  1949.             while(true) {
  1950.                var2.append(var0[var3]);
  1951.                if (var3 == var1) {
  1952.                   return var2.append(']').toString();
  1953.                }
  1954.  
  1955.                var2.append(", ");
  1956.                ++var3;
  1957.             }
  1958.          }
  1959.       }
  1960.    }
  1961.  
  1962.    public static String toString(byte[] var0) {
  1963.       if (var0 == null) {
  1964.          return "null";
  1965.       } else {
  1966.          int var1 = var0.length - 1;
  1967.          if (var1 == -1) {
  1968.             return "[]";
  1969.          } else {
  1970.             StringBuilder var2 = new StringBuilder();
  1971.             var2.append('[');
  1972.             int var3 = 0;
  1973.  
  1974.             while(true) {
  1975.                var2.append(var0[var3]);
  1976.                if (var3 == var1) {
  1977.                   return var2.append(']').toString();
  1978.                }
  1979.  
  1980.                var2.append(", ");
  1981.                ++var3;
  1982.             }
  1983.          }
  1984.       }
  1985.    }
  1986.  
  1987.    public static String toString(boolean[] var0) {
  1988.       if (var0 == null) {
  1989.          return "null";
  1990.       } else {
  1991.          int var1 = var0.length - 1;
  1992.          if (var1 == -1) {
  1993.             return "[]";
  1994.          } else {
  1995.             StringBuilder var2 = new StringBuilder();
  1996.             var2.append('[');
  1997.             int var3 = 0;
  1998.  
  1999.             while(true) {
  2000.                var2.append(var0[var3]);
  2001.                if (var3 == var1) {
  2002.                   return var2.append(']').toString();
  2003.                }
  2004.  
  2005.                var2.append(", ");
  2006.                ++var3;
  2007.             }
  2008.          }
  2009.       }
  2010.    }
  2011.  
  2012.    public static String toString(float[] var0) {
  2013.       if (var0 == null) {
  2014.          return "null";
  2015.       } else {
  2016.          int var1 = var0.length - 1;
  2017.          if (var1 == -1) {
  2018.             return "[]";
  2019.          } else {
  2020.             StringBuilder var2 = new StringBuilder();
  2021.             var2.append('[');
  2022.             int var3 = 0;
  2023.  
  2024.             while(true) {
  2025.                var2.append(var0[var3]);
  2026.                if (var3 == var1) {
  2027.                   return var2.append(']').toString();
  2028.                }
  2029.  
  2030.                var2.append(", ");
  2031.                ++var3;
  2032.             }
  2033.          }
  2034.       }
  2035.    }
  2036.  
  2037.    public static String toString(double[] var0) {
  2038.       if (var0 == null) {
  2039.          return "null";
  2040.       } else {
  2041.          int var1 = var0.length - 1;
  2042.          if (var1 == -1) {
  2043.             return "[]";
  2044.          } else {
  2045.             StringBuilder var2 = new StringBuilder();
  2046.             var2.append('[');
  2047.             int var3 = 0;
  2048.  
  2049.             while(true) {
  2050.                var2.append(var0[var3]);
  2051.                if (var3 == var1) {
  2052.                   return var2.append(']').toString();
  2053.                }
  2054.  
  2055.                var2.append(", ");
  2056.                ++var3;
  2057.             }
  2058.          }
  2059.       }
  2060.    }
  2061.  
  2062.    public static String toString(Object[] var0) {
  2063.       if (var0 == null) {
  2064.          return "null";
  2065.       } else {
  2066.          int var1 = var0.length - 1;
  2067.          if (var1 == -1) {
  2068.             return "[]";
  2069.          } else {
  2070.             StringBuilder var2 = new StringBuilder();
  2071.             var2.append('[');
  2072.             int var3 = 0;
  2073.  
  2074.             while(true) {
  2075.                var2.append(String.valueOf(var0[var3]));
  2076.                if (var3 == var1) {
  2077.                   return var2.append(']').toString();
  2078.                }
  2079.  
  2080.                var2.append(", ");
  2081.                ++var3;
  2082.             }
  2083.          }
  2084.       }
  2085.    }
  2086.  
  2087.    public static String deepToString(Object[] var0) {
  2088.       if (var0 == null) {
  2089.          return "null";
  2090.       } else {
  2091.          int var1 = 20 * var0.length;
  2092.          if (var0.length != 0 && var1 <= 0) {
  2093.             var1 = Integer.MAX_VALUE;
  2094.          }
  2095.  
  2096.          StringBuilder var2 = new StringBuilder(var1);
  2097.          deepToString(var0, var2, new HashSet());
  2098.          return var2.toString();
  2099.       }
  2100.    }
  2101.  
  2102.    private static void deepToString(Object[] var0, StringBuilder var1, Set<Object[]> var2) {
  2103.       if (var0 == null) {
  2104.          var1.append("null");
  2105.       } else {
  2106.          var2.add(var0);
  2107.          var1.append('[');
  2108.  
  2109.          for(int var3 = 0; var3 < var0.length; ++var3) {
  2110.             if (var3 != 0) {
  2111.                var1.append(", ");
  2112.             }
  2113.  
  2114.             Object var4 = var0[var3];
  2115.             if (var4 == null) {
  2116.                var1.append("null");
  2117.             } else {
  2118.                Class var5 = var4.getClass();
  2119.                if (var5.isArray()) {
  2120.                   if (var5 == byte[].class) {
  2121.                      var1.append(toString((byte[])var4));
  2122.                   } else if (var5 == short[].class) {
  2123.                      var1.append(toString((short[])var4));
  2124.                   } else if (var5 == int[].class) {
  2125.                      var1.append(toString((int[])var4));
  2126.                   } else if (var5 == long[].class) {
  2127.                      var1.append(toString((long[])var4));
  2128.                   } else if (var5 == char[].class) {
  2129.                      var1.append(toString((char[])var4));
  2130.                   } else if (var5 == float[].class) {
  2131.                      var1.append(toString((float[])var4));
  2132.                   } else if (var5 == double[].class) {
  2133.                      var1.append(toString((double[])var4));
  2134.                   } else if (var5 == boolean[].class) {
  2135.                      var1.append(toString((boolean[])var4));
  2136.                   } else if (var2.contains(var4)) {
  2137.                      var1.append("[...]");
  2138.                   } else {
  2139.                      deepToString(var4, var1, var2);
  2140.                   }
  2141.                } else {
  2142.                   var1.append(var4.toString());
  2143.                }
  2144.             }
  2145.          }
  2146.  
  2147.          var1.append(']');
  2148.          var2.remove(var0);
  2149.       }
  2150.    }
  2151. }
  2152.