home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / util / Arrays.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  11.3 KB  |  1,380 lines
  1. package java.util;
  2.  
  3. public class Arrays {
  4.    private Arrays() {
  5.    }
  6.  
  7.    public static void sort(long[] var0) {
  8.       sort1((long[])var0, 0, var0.length);
  9.    }
  10.  
  11.    public static void sort(long[] var0, int var1, int var2) {
  12.       rangeCheck(var0.length, var1, var2);
  13.       sort1(var0, var1, var2 - var1);
  14.    }
  15.  
  16.    public static void sort(int[] var0) {
  17.       sort1((int[])var0, 0, var0.length);
  18.    }
  19.  
  20.    public static void sort(int[] var0, int var1, int var2) {
  21.       rangeCheck(var0.length, var1, var2);
  22.       sort1(var0, var1, var2 - var1);
  23.    }
  24.  
  25.    public static void sort(short[] var0) {
  26.       sort1((short[])var0, 0, var0.length);
  27.    }
  28.  
  29.    public static void sort(short[] var0, int var1, int var2) {
  30.       rangeCheck(var0.length, var1, var2);
  31.       sort1(var0, var1, var2 - var1);
  32.    }
  33.  
  34.    public static void sort(char[] var0) {
  35.       sort1((char[])var0, 0, var0.length);
  36.    }
  37.  
  38.    public static void sort(char[] var0, int var1, int var2) {
  39.       rangeCheck(var0.length, var1, var2);
  40.       sort1(var0, var1, var2 - var1);
  41.    }
  42.  
  43.    public static void sort(byte[] var0) {
  44.       sort1((byte[])var0, 0, var0.length);
  45.    }
  46.  
  47.    public static void sort(byte[] var0, int var1, int var2) {
  48.       rangeCheck(var0.length, var1, var2);
  49.       sort1(var0, var1, var2 - var1);
  50.    }
  51.  
  52.    public static void sort(double[] var0) {
  53.       sort2((double[])var0, 0, var0.length);
  54.    }
  55.  
  56.    public static void sort(double[] var0, int var1, int var2) {
  57.       rangeCheck(var0.length, var1, var2);
  58.       sort2(var0, var1, var2);
  59.    }
  60.  
  61.    public static void sort(float[] var0) {
  62.       sort2((float[])var0, 0, var0.length);
  63.    }
  64.  
  65.    public static void sort(float[] var0, int var1, int var2) {
  66.       rangeCheck(var0.length, var1, var2);
  67.       sort2(var0, var1, var2);
  68.    }
  69.  
  70.    private static void sort2(double[] var0, int var1, int var2) {
  71.       long var3 = Double.doubleToLongBits((double)-0.0F);
  72.       int var5 = 0;
  73.       int var6 = var1;
  74.       int var7 = var2;
  75.  
  76.       while(var6 < var7) {
  77.          if (var0[var6] != var0[var6]) {
  78.             --var7;
  79.             var0[var6] = var0[var7];
  80.             var0[var7] = Double.NaN;
  81.          } else {
  82.             if (var0[var6] == (double)0.0F && Double.doubleToLongBits(var0[var6]) == var3) {
  83.                var0[var6] = (double)0.0F;
  84.                ++var5;
  85.             }
  86.  
  87.             ++var6;
  88.          }
  89.       }
  90.  
  91.       sort1(var0, var1, var7 - var1);
  92.       if (var5 != 0) {
  93.          int var8 = binarySearch(var0, (double)0.0F, var1, var7 - 1);
  94.  
  95.          do {
  96.             --var8;
  97.          } while(var8 >= 0 && var0[var8] == (double)0.0F);
  98.  
  99.          for(int var9 = 0; var9 < var5; ++var9) {
  100.             ++var8;
  101.             var0[var8] = (double)-0.0F;
  102.          }
  103.       }
  104.  
  105.    }
  106.  
  107.    private static void sort2(float[] var0, int var1, int var2) {
  108.       int var3 = Float.floatToIntBits(-0.0F);
  109.       int var4 = 0;
  110.       int var5 = var1;
  111.       int var6 = var2;
  112.  
  113.       while(var5 < var6) {
  114.          if (var0[var5] != var0[var5]) {
  115.             --var6;
  116.             var0[var5] = var0[var6];
  117.             var0[var6] = Float.NaN;
  118.          } else {
  119.             if (var0[var5] == 0.0F && Float.floatToIntBits(var0[var5]) == var3) {
  120.                var0[var5] = 0.0F;
  121.                ++var4;
  122.             }
  123.  
  124.             ++var5;
  125.          }
  126.       }
  127.  
  128.       sort1(var0, var1, var6 - var1);
  129.       if (var4 != 0) {
  130.          int var7 = binarySearch(var0, 0.0F, var1, var6 - 1);
  131.  
  132.          do {
  133.             --var7;
  134.          } while(var7 >= 0 && var0[var7] == 0.0F);
  135.  
  136.          for(int var8 = 0; var8 < var4; ++var8) {
  137.             ++var7;
  138.             var0[var7] = -0.0F;
  139.          }
  140.       }
  141.  
  142.    }
  143.  
  144.    private static void sort1(long[] var0, int var1, int var2) {
  145.       if (var2 < 7) {
  146.          for(int var12 = var1; var12 < var2 + var1; ++var12) {
  147.             for(int var14 = var12; var14 > var1 && var0[var14 - 1] > var0[var14]; --var14) {
  148.                swap(var0, var14, var14 - 1);
  149.             }
  150.          }
  151.  
  152.       } else {
  153.          int var3 = var1 + var2 / 2;
  154.          if (var2 > 7) {
  155.             int var4 = var1;
  156.             int var5 = var1 + var2 - 1;
  157.             if (var2 > 40) {
  158.                int var6 = var2 / 8;
  159.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  160.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  161.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  162.             }
  163.  
  164.             var3 = med3(var0, var4, var3, var5);
  165.          }
  166.  
  167.          long var13 = var0[var3];
  168.          int var15 = var1;
  169.          int var7 = var1;
  170.          int var8 = var1 + var2 - 1;
  171.          int var9 = var8;
  172.  
  173.          while(true) {
  174.             while(var7 > var8 || var0[var7] > var13) {
  175.                for(; var8 >= var7 && var0[var8] >= var13; --var8) {
  176.                   if (var0[var8] == var13) {
  177.                      swap(var0, var8, var9--);
  178.                   }
  179.                }
  180.  
  181.                if (var7 > var8) {
  182.                   int var11 = var1 + var2;
  183.                   int var10 = Math.min(var15 - var1, var7 - var15);
  184.                   vecswap(var0, var1, var7 - var10, var10);
  185.                   var10 = Math.min(var9 - var8, var11 - var9 - 1);
  186.                   vecswap(var0, var7, var11 - var10, var10);
  187.                   if ((var10 = var7 - var15) > 1) {
  188.                      sort1(var0, var1, var10);
  189.                   }
  190.  
  191.                   if ((var10 = var9 - var8) > 1) {
  192.                      sort1(var0, var11 - var10, var10);
  193.                   }
  194.  
  195.                   return;
  196.                }
  197.  
  198.                swap(var0, var7++, var8--);
  199.             }
  200.  
  201.             if (var0[var7] == var13) {
  202.                swap(var0, var15++, var7);
  203.             }
  204.  
  205.             ++var7;
  206.          }
  207.       }
  208.    }
  209.  
  210.    private static void swap(long[] var0, int var1, int var2) {
  211.       long var3 = var0[var1];
  212.       var0[var1] = var0[var2];
  213.       var0[var2] = var3;
  214.    }
  215.  
  216.    private static void vecswap(long[] var0, int var1, int var2, int var3) {
  217.       for(int var4 = 0; var4 < var3; ++var2) {
  218.          swap(var0, var1, var2);
  219.          ++var4;
  220.          ++var1;
  221.       }
  222.  
  223.    }
  224.  
  225.    private static int med3(long[] var0, int var1, int var2, int var3) {
  226.       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));
  227.    }
  228.  
  229.    private static void sort1(int[] var0, int var1, int var2) {
  230.       if (var2 < 7) {
  231.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  232.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  233.                swap(var0, var13, var13 - 1);
  234.             }
  235.          }
  236.  
  237.       } else {
  238.          int var3 = var1 + var2 / 2;
  239.          if (var2 > 7) {
  240.             int var4 = var1;
  241.             int var5 = var1 + var2 - 1;
  242.             if (var2 > 40) {
  243.                int var6 = var2 / 8;
  244.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  245.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  246.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  247.             }
  248.  
  249.             var3 = med3(var0, var4, var3, var5);
  250.          }
  251.  
  252.          int var12 = var0[var3];
  253.          int var14 = var1;
  254.          int var15 = var1;
  255.          int var7 = var1 + var2 - 1;
  256.          int var8 = var7;
  257.  
  258.          while(true) {
  259.             while(var15 > var7 || var0[var15] > var12) {
  260.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  261.                   if (var0[var7] == var12) {
  262.                      swap(var0, var7, var8--);
  263.                   }
  264.                }
  265.  
  266.                if (var15 > var7) {
  267.                   int var10 = var1 + var2;
  268.                   int var9 = Math.min(var14 - var1, var15 - var14);
  269.                   vecswap(var0, var1, var15 - var9, var9);
  270.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  271.                   vecswap(var0, var15, var10 - var9, var9);
  272.                   if ((var9 = var15 - var14) > 1) {
  273.                      sort1(var0, var1, var9);
  274.                   }
  275.  
  276.                   if ((var9 = var8 - var7) > 1) {
  277.                      sort1(var0, var10 - var9, var9);
  278.                   }
  279.  
  280.                   return;
  281.                }
  282.  
  283.                swap(var0, var15++, var7--);
  284.             }
  285.  
  286.             if (var0[var15] == var12) {
  287.                swap(var0, var14++, var15);
  288.             }
  289.  
  290.             ++var15;
  291.          }
  292.       }
  293.    }
  294.  
  295.    private static void swap(int[] var0, int var1, int var2) {
  296.       int var3 = var0[var1];
  297.       var0[var1] = var0[var2];
  298.       var0[var2] = var3;
  299.    }
  300.  
  301.    private static void vecswap(int[] var0, int var1, int var2, int var3) {
  302.       for(int var4 = 0; var4 < var3; ++var2) {
  303.          swap(var0, var1, var2);
  304.          ++var4;
  305.          ++var1;
  306.       }
  307.  
  308.    }
  309.  
  310.    private static int med3(int[] var0, int var1, int var2, int var3) {
  311.       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));
  312.    }
  313.  
  314.    private static void sort1(short[] var0, int var1, int var2) {
  315.       if (var2 < 7) {
  316.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  317.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  318.                swap(var0, var13, var13 - 1);
  319.             }
  320.          }
  321.  
  322.       } else {
  323.          int var3 = var1 + var2 / 2;
  324.          if (var2 > 7) {
  325.             int var4 = var1;
  326.             int var5 = var1 + var2 - 1;
  327.             if (var2 > 40) {
  328.                int var6 = var2 / 8;
  329.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  330.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  331.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  332.             }
  333.  
  334.             var3 = med3(var0, var4, var3, var5);
  335.          }
  336.  
  337.          short var12 = var0[var3];
  338.          int var14 = var1;
  339.          int var15 = var1;
  340.          int var7 = var1 + var2 - 1;
  341.          int var8 = var7;
  342.  
  343.          while(true) {
  344.             while(var15 > var7 || var0[var15] > var12) {
  345.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  346.                   if (var0[var7] == var12) {
  347.                      swap(var0, var7, var8--);
  348.                   }
  349.                }
  350.  
  351.                if (var15 > var7) {
  352.                   int var10 = var1 + var2;
  353.                   int var9 = Math.min(var14 - var1, var15 - var14);
  354.                   vecswap(var0, var1, var15 - var9, var9);
  355.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  356.                   vecswap(var0, var15, var10 - var9, var9);
  357.                   if ((var9 = var15 - var14) > 1) {
  358.                      sort1(var0, var1, var9);
  359.                   }
  360.  
  361.                   if ((var9 = var8 - var7) > 1) {
  362.                      sort1(var0, var10 - var9, var9);
  363.                   }
  364.  
  365.                   return;
  366.                }
  367.  
  368.                swap(var0, var15++, var7--);
  369.             }
  370.  
  371.             if (var0[var15] == var12) {
  372.                swap(var0, var14++, var15);
  373.             }
  374.  
  375.             ++var15;
  376.          }
  377.       }
  378.    }
  379.  
  380.    private static void swap(short[] var0, int var1, int var2) {
  381.       short var3 = var0[var1];
  382.       var0[var1] = var0[var2];
  383.       var0[var2] = var3;
  384.    }
  385.  
  386.    private static void vecswap(short[] var0, int var1, int var2, int var3) {
  387.       for(int var4 = 0; var4 < var3; ++var2) {
  388.          swap(var0, var1, var2);
  389.          ++var4;
  390.          ++var1;
  391.       }
  392.  
  393.    }
  394.  
  395.    private static int med3(short[] var0, int var1, int var2, int var3) {
  396.       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));
  397.    }
  398.  
  399.    private static void sort1(char[] var0, int var1, int var2) {
  400.       if (var2 < 7) {
  401.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  402.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  403.                swap(var0, var13, var13 - 1);
  404.             }
  405.          }
  406.  
  407.       } else {
  408.          int var3 = var1 + var2 / 2;
  409.          if (var2 > 7) {
  410.             int var4 = var1;
  411.             int var5 = var1 + var2 - 1;
  412.             if (var2 > 40) {
  413.                int var6 = var2 / 8;
  414.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  415.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  416.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  417.             }
  418.  
  419.             var3 = med3(var0, var4, var3, var5);
  420.          }
  421.  
  422.          char var12 = var0[var3];
  423.          int var14 = var1;
  424.          int var15 = var1;
  425.          int var7 = var1 + var2 - 1;
  426.          int var8 = var7;
  427.  
  428.          while(true) {
  429.             while(var15 > var7 || var0[var15] > var12) {
  430.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  431.                   if (var0[var7] == var12) {
  432.                      swap(var0, var7, var8--);
  433.                   }
  434.                }
  435.  
  436.                if (var15 > var7) {
  437.                   int var10 = var1 + var2;
  438.                   int var9 = Math.min(var14 - var1, var15 - var14);
  439.                   vecswap(var0, var1, var15 - var9, var9);
  440.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  441.                   vecswap(var0, var15, var10 - var9, var9);
  442.                   if ((var9 = var15 - var14) > 1) {
  443.                      sort1(var0, var1, var9);
  444.                   }
  445.  
  446.                   if ((var9 = var8 - var7) > 1) {
  447.                      sort1(var0, var10 - var9, var9);
  448.                   }
  449.  
  450.                   return;
  451.                }
  452.  
  453.                swap(var0, var15++, var7--);
  454.             }
  455.  
  456.             if (var0[var15] == var12) {
  457.                swap(var0, var14++, var15);
  458.             }
  459.  
  460.             ++var15;
  461.          }
  462.       }
  463.    }
  464.  
  465.    private static void swap(char[] var0, int var1, int var2) {
  466.       char var3 = var0[var1];
  467.       var0[var1] = var0[var2];
  468.       var0[var2] = var3;
  469.    }
  470.  
  471.    private static void vecswap(char[] var0, int var1, int var2, int var3) {
  472.       for(int var4 = 0; var4 < var3; ++var2) {
  473.          swap(var0, var1, var2);
  474.          ++var4;
  475.          ++var1;
  476.       }
  477.  
  478.    }
  479.  
  480.    private static int med3(char[] var0, int var1, int var2, int var3) {
  481.       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));
  482.    }
  483.  
  484.    private static void sort1(byte[] var0, int var1, int var2) {
  485.       if (var2 < 7) {
  486.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  487.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  488.                swap(var0, var13, var13 - 1);
  489.             }
  490.          }
  491.  
  492.       } else {
  493.          int var3 = var1 + var2 / 2;
  494.          if (var2 > 7) {
  495.             int var4 = var1;
  496.             int var5 = var1 + var2 - 1;
  497.             if (var2 > 40) {
  498.                int var6 = var2 / 8;
  499.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  500.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  501.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  502.             }
  503.  
  504.             var3 = med3(var0, var4, var3, var5);
  505.          }
  506.  
  507.          byte var12 = var0[var3];
  508.          int var14 = var1;
  509.          int var15 = var1;
  510.          int var7 = var1 + var2 - 1;
  511.          int var8 = var7;
  512.  
  513.          while(true) {
  514.             while(var15 > var7 || var0[var15] > var12) {
  515.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  516.                   if (var0[var7] == var12) {
  517.                      swap(var0, var7, var8--);
  518.                   }
  519.                }
  520.  
  521.                if (var15 > var7) {
  522.                   int var10 = var1 + var2;
  523.                   int var9 = Math.min(var14 - var1, var15 - var14);
  524.                   vecswap(var0, var1, var15 - var9, var9);
  525.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  526.                   vecswap(var0, var15, var10 - var9, var9);
  527.                   if ((var9 = var15 - var14) > 1) {
  528.                      sort1(var0, var1, var9);
  529.                   }
  530.  
  531.                   if ((var9 = var8 - var7) > 1) {
  532.                      sort1(var0, var10 - var9, var9);
  533.                   }
  534.  
  535.                   return;
  536.                }
  537.  
  538.                swap(var0, var15++, var7--);
  539.             }
  540.  
  541.             if (var0[var15] == var12) {
  542.                swap(var0, var14++, var15);
  543.             }
  544.  
  545.             ++var15;
  546.          }
  547.       }
  548.    }
  549.  
  550.    private static void swap(byte[] var0, int var1, int var2) {
  551.       byte var3 = var0[var1];
  552.       var0[var1] = var0[var2];
  553.       var0[var2] = var3;
  554.    }
  555.  
  556.    private static void vecswap(byte[] var0, int var1, int var2, int var3) {
  557.       for(int var4 = 0; var4 < var3; ++var2) {
  558.          swap(var0, var1, var2);
  559.          ++var4;
  560.          ++var1;
  561.       }
  562.  
  563.    }
  564.  
  565.    private static int med3(byte[] var0, int var1, int var2, int var3) {
  566.       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));
  567.    }
  568.  
  569.    private static void sort1(double[] var0, int var1, int var2) {
  570.       if (var2 < 7) {
  571.          for(int var12 = var1; var12 < var2 + var1; ++var12) {
  572.             for(int var14 = var12; var14 > var1 && var0[var14 - 1] > var0[var14]; --var14) {
  573.                swap(var0, var14, var14 - 1);
  574.             }
  575.          }
  576.  
  577.       } else {
  578.          int var3 = var1 + var2 / 2;
  579.          if (var2 > 7) {
  580.             int var4 = var1;
  581.             int var5 = var1 + var2 - 1;
  582.             if (var2 > 40) {
  583.                int var6 = var2 / 8;
  584.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  585.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  586.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  587.             }
  588.  
  589.             var3 = med3(var0, var4, var3, var5);
  590.          }
  591.  
  592.          double var13 = var0[var3];
  593.          int var15 = var1;
  594.          int var7 = var1;
  595.          int var8 = var1 + var2 - 1;
  596.          int var9 = var8;
  597.  
  598.          while(true) {
  599.             while(var7 > var8 || !(var0[var7] <= var13)) {
  600.                for(; var8 >= var7 && var0[var8] >= var13; --var8) {
  601.                   if (var0[var8] == var13) {
  602.                      swap(var0, var8, var9--);
  603.                   }
  604.                }
  605.  
  606.                if (var7 > var8) {
  607.                   int var11 = var1 + var2;
  608.                   int var10 = Math.min(var15 - var1, var7 - var15);
  609.                   vecswap(var0, var1, var7 - var10, var10);
  610.                   var10 = Math.min(var9 - var8, var11 - var9 - 1);
  611.                   vecswap(var0, var7, var11 - var10, var10);
  612.                   if ((var10 = var7 - var15) > 1) {
  613.                      sort1(var0, var1, var10);
  614.                   }
  615.  
  616.                   if ((var10 = var9 - var8) > 1) {
  617.                      sort1(var0, var11 - var10, var10);
  618.                   }
  619.  
  620.                   return;
  621.                }
  622.  
  623.                swap(var0, var7++, var8--);
  624.             }
  625.  
  626.             if (var0[var7] == var13) {
  627.                swap(var0, var15++, var7);
  628.             }
  629.  
  630.             ++var7;
  631.          }
  632.       }
  633.    }
  634.  
  635.    private static void swap(double[] var0, int var1, int var2) {
  636.       double var3 = var0[var1];
  637.       var0[var1] = var0[var2];
  638.       var0[var2] = var3;
  639.    }
  640.  
  641.    private static void vecswap(double[] var0, int var1, int var2, int var3) {
  642.       for(int var4 = 0; var4 < var3; ++var2) {
  643.          swap(var0, var1, var2);
  644.          ++var4;
  645.          ++var1;
  646.       }
  647.  
  648.    }
  649.  
  650.    private static int med3(double[] var0, int var1, int var2, int var3) {
  651.       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));
  652.    }
  653.  
  654.    private static void sort1(float[] var0, int var1, int var2) {
  655.       if (var2 < 7) {
  656.          for(int var11 = var1; var11 < var2 + var1; ++var11) {
  657.             for(int var13 = var11; var13 > var1 && var0[var13 - 1] > var0[var13]; --var13) {
  658.                swap(var0, var13, var13 - 1);
  659.             }
  660.          }
  661.  
  662.       } else {
  663.          int var3 = var1 + var2 / 2;
  664.          if (var2 > 7) {
  665.             int var4 = var1;
  666.             int var5 = var1 + var2 - 1;
  667.             if (var2 > 40) {
  668.                int var6 = var2 / 8;
  669.                var4 = med3(var0, var1, var1 + var6, var1 + 2 * var6);
  670.                var3 = med3(var0, var3 - var6, var3, var3 + var6);
  671.                var5 = med3(var0, var5 - 2 * var6, var5 - var6, var5);
  672.             }
  673.  
  674.             var3 = med3(var0, var4, var3, var5);
  675.          }
  676.  
  677.          float var12 = var0[var3];
  678.          int var14 = var1;
  679.          int var15 = var1;
  680.          int var7 = var1 + var2 - 1;
  681.          int var8 = var7;
  682.  
  683.          while(true) {
  684.             while(var15 > var7 || !(var0[var15] <= var12)) {
  685.                for(; var7 >= var15 && var0[var7] >= var12; --var7) {
  686.                   if (var0[var7] == var12) {
  687.                      swap(var0, var7, var8--);
  688.                   }
  689.                }
  690.  
  691.                if (var15 > var7) {
  692.                   int var10 = var1 + var2;
  693.                   int var9 = Math.min(var14 - var1, var15 - var14);
  694.                   vecswap(var0, var1, var15 - var9, var9);
  695.                   var9 = Math.min(var8 - var7, var10 - var8 - 1);
  696.                   vecswap(var0, var15, var10 - var9, var9);
  697.                   if ((var9 = var15 - var14) > 1) {
  698.                      sort1(var0, var1, var9);
  699.                   }
  700.  
  701.                   if ((var9 = var8 - var7) > 1) {
  702.                      sort1(var0, var10 - var9, var9);
  703.                   }
  704.  
  705.                   return;
  706.                }
  707.  
  708.                swap(var0, var15++, var7--);
  709.             }
  710.  
  711.             if (var0[var15] == var12) {
  712.                swap(var0, var14++, var15);
  713.             }
  714.  
  715.             ++var15;
  716.          }
  717.       }
  718.    }
  719.  
  720.    private static void swap(float[] var0, int var1, int var2) {
  721.       float var3 = var0[var1];
  722.       var0[var1] = var0[var2];
  723.       var0[var2] = var3;
  724.    }
  725.  
  726.    private static void vecswap(float[] var0, int var1, int var2, int var3) {
  727.       for(int var4 = 0; var4 < var3; ++var2) {
  728.          swap(var0, var1, var2);
  729.          ++var4;
  730.          ++var1;
  731.       }
  732.  
  733.    }
  734.  
  735.    private static int med3(float[] var0, int var1, int var2, int var3) {
  736.       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));
  737.    }
  738.  
  739.    public static void sort(Object[] var0) {
  740.       Object[] var1 = var0.clone();
  741.       mergeSort(var1, var0, 0, var0.length);
  742.    }
  743.  
  744.    public static void sort(Object[] var0, int var1, int var2) {
  745.       rangeCheck(var0.length, var1, var2);
  746.       Object[] var3 = var0.clone();
  747.       mergeSort(var3, var0, var1, var2);
  748.    }
  749.  
  750.    private static void mergeSort(Object[] var0, Object[] var1, int var2, int var3) {
  751.       int var4 = var3 - var2;
  752.       if (var4 < 7) {
  753.          for(int var9 = var2; var9 < var3; ++var9) {
  754.             for(int var10 = var9; var10 > var2 && ((Comparable)var1[var10 - 1]).compareTo((Comparable)var1[var10]) > 0; --var10) {
  755.                swap(var1, var10, var10 - 1);
  756.             }
  757.          }
  758.  
  759.       } else {
  760.          int var5 = (var2 + var3) / 2;
  761.          mergeSort(var1, var0, var2, var5);
  762.          mergeSort(var1, var0, var5, var3);
  763.          if (((Comparable)var0[var5 - 1]).compareTo((Comparable)var0[var5]) <= 0) {
  764.             System.arraycopy(var0, var2, var1, var2, var4);
  765.          } else {
  766.             int var6 = var2;
  767.             int var7 = var2;
  768.  
  769.             for(int var8 = var5; var6 < var3; ++var6) {
  770.                if (var8 < var3 && (var7 >= var5 || ((Comparable)var0[var7]).compareTo(var0[var8]) > 0)) {
  771.                   var1[var6] = var0[var8++];
  772.                } else {
  773.                   var1[var6] = var0[var7++];
  774.                }
  775.             }
  776.  
  777.          }
  778.       }
  779.    }
  780.  
  781.    private static void swap(Object[] var0, int var1, int var2) {
  782.       Object var3 = var0[var1];
  783.       var0[var1] = var0[var2];
  784.       var0[var2] = var3;
  785.    }
  786.  
  787.    public static void sort(Object[] var0, Comparator var1) {
  788.       Object[] var2 = var0.clone();
  789.       if (var1 == null) {
  790.          mergeSort(var2, var0, 0, var0.length);
  791.       } else {
  792.          mergeSort(var2, var0, 0, var0.length, var1);
  793.       }
  794.  
  795.    }
  796.  
  797.    public static void sort(Object[] var0, int var1, int var2, Comparator var3) {
  798.       rangeCheck(var0.length, var1, var2);
  799.       Object[] var4 = var0.clone();
  800.       if (var3 == null) {
  801.          mergeSort(var4, var0, var1, var2);
  802.       } else {
  803.          mergeSort(var4, var0, var1, var2, var3);
  804.       }
  805.  
  806.    }
  807.  
  808.    private static void mergeSort(Object[] var0, Object[] var1, int var2, int var3, Comparator var4) {
  809.       int var5 = var3 - var2;
  810.       if (var5 < 7) {
  811.          for(int var10 = var2; var10 < var3; ++var10) {
  812.             for(int var11 = var10; var11 > var2 && var4.compare(var1[var11 - 1], var1[var11]) > 0; --var11) {
  813.                swap(var1, var11, var11 - 1);
  814.             }
  815.          }
  816.  
  817.       } else {
  818.          int var6 = (var2 + var3) / 2;
  819.          mergeSort(var1, var0, var2, var6, var4);
  820.          mergeSort(var1, var0, var6, var3, var4);
  821.          if (var4.compare(var0[var6 - 1], var0[var6]) <= 0) {
  822.             System.arraycopy(var0, var2, var1, var2, var5);
  823.          } else {
  824.             int var7 = var2;
  825.             int var8 = var2;
  826.  
  827.             for(int var9 = var6; var7 < var3; ++var7) {
  828.                if (var9 < var3 && (var8 >= var6 || var4.compare(var0[var8], var0[var9]) > 0)) {
  829.                   var1[var7] = var0[var9++];
  830.                } else {
  831.                   var1[var7] = var0[var8++];
  832.                }
  833.             }
  834.  
  835.          }
  836.       }
  837.    }
  838.  
  839.    private static void rangeCheck(int var0, int var1, int var2) {
  840.       if (var1 > var2) {
  841.          throw new IllegalArgumentException("fromIndex(" + var1 + ") > toIndex(" + var2 + ")");
  842.       } else if (var1 < 0) {
  843.          throw new ArrayIndexOutOfBoundsException(var1);
  844.       } else if (var2 > var0) {
  845.          throw new ArrayIndexOutOfBoundsException(var2);
  846.       }
  847.    }
  848.  
  849.    public static int binarySearch(long[] var0, long var1) {
  850.       int var3 = 0;
  851.       int var4 = var0.length - 1;
  852.  
  853.       while(var3 <= var4) {
  854.          int var5 = (var3 + var4) / 2;
  855.          long var6 = var0[var5];
  856.          if (var6 < var1) {
  857.             var3 = var5 + 1;
  858.          } else {
  859.             if (var6 <= var1) {
  860.                return var5;
  861.             }
  862.  
  863.             var4 = var5 - 1;
  864.          }
  865.       }
  866.  
  867.       return -(var3 + 1);
  868.    }
  869.  
  870.    public static int binarySearch(int[] var0, int var1) {
  871.       int var2 = 0;
  872.       int var3 = var0.length - 1;
  873.  
  874.       while(var2 <= var3) {
  875.          int var4 = (var2 + var3) / 2;
  876.          int var5 = var0[var4];
  877.          if (var5 < var1) {
  878.             var2 = var4 + 1;
  879.          } else {
  880.             if (var5 <= var1) {
  881.                return var4;
  882.             }
  883.  
  884.             var3 = var4 - 1;
  885.          }
  886.       }
  887.  
  888.       return -(var2 + 1);
  889.    }
  890.  
  891.    public static int binarySearch(short[] var0, short var1) {
  892.       int var2 = 0;
  893.       int var3 = var0.length - 1;
  894.  
  895.       while(var2 <= var3) {
  896.          int var4 = (var2 + var3) / 2;
  897.          short var5 = var0[var4];
  898.          if (var5 < var1) {
  899.             var2 = var4 + 1;
  900.          } else {
  901.             if (var5 <= var1) {
  902.                return var4;
  903.             }
  904.  
  905.             var3 = var4 - 1;
  906.          }
  907.       }
  908.  
  909.       return -(var2 + 1);
  910.    }
  911.  
  912.    public static int binarySearch(char[] var0, char var1) {
  913.       int var2 = 0;
  914.       int var3 = var0.length - 1;
  915.  
  916.       while(var2 <= var3) {
  917.          int var4 = (var2 + var3) / 2;
  918.          char var5 = var0[var4];
  919.          if (var5 < var1) {
  920.             var2 = var4 + 1;
  921.          } else {
  922.             if (var5 <= var1) {
  923.                return var4;
  924.             }
  925.  
  926.             var3 = var4 - 1;
  927.          }
  928.       }
  929.  
  930.       return -(var2 + 1);
  931.    }
  932.  
  933.    public static int binarySearch(byte[] var0, byte var1) {
  934.       int var2 = 0;
  935.       int var3 = var0.length - 1;
  936.  
  937.       while(var2 <= var3) {
  938.          int var4 = (var2 + var3) / 2;
  939.          byte var5 = var0[var4];
  940.          if (var5 < var1) {
  941.             var2 = var4 + 1;
  942.          } else {
  943.             if (var5 <= var1) {
  944.                return var4;
  945.             }
  946.  
  947.             var3 = var4 - 1;
  948.          }
  949.       }
  950.  
  951.       return -(var2 + 1);
  952.    }
  953.  
  954.    public static int binarySearch(double[] var0, double var1) {
  955.       return binarySearch(var0, var1, 0, var0.length - 1);
  956.    }
  957.  
  958.    private static int binarySearch(double[] var0, double var1, int var3, int var4) {
  959.       while(var3 <= var4) {
  960.          int var5 = (var3 + var4) / 2;
  961.          double var6 = var0[var5];
  962.          int var8;
  963.          if (var6 < var1) {
  964.             var8 = -1;
  965.          } else if (var6 > var1) {
  966.             var8 = 1;
  967.          } else {
  968.             long var9 = Double.doubleToLongBits(var6);
  969.             long var11 = Double.doubleToLongBits(var1);
  970.             var8 = var9 == var11 ? 0 : (var9 < var11 ? -1 : 1);
  971.          }
  972.  
  973.          if (var8 < 0) {
  974.             var3 = var5 + 1;
  975.          } else {
  976.             if (var8 <= 0) {
  977.                return var5;
  978.             }
  979.  
  980.             var4 = var5 - 1;
  981.          }
  982.       }
  983.  
  984.       return -(var3 + 1);
  985.    }
  986.  
  987.    public static int binarySearch(float[] var0, float var1) {
  988.       return binarySearch(var0, var1, 0, var0.length - 1);
  989.    }
  990.  
  991.    private static int binarySearch(float[] var0, float var1, int var2, int var3) {
  992.       while(var2 <= var3) {
  993.          int var4 = (var2 + var3) / 2;
  994.          float var5 = var0[var4];
  995.          int var6;
  996.          if (var5 < var1) {
  997.             var6 = -1;
  998.          } else if (var5 > var1) {
  999.             var6 = 1;
  1000.          } else {
  1001.             int var7 = Float.floatToIntBits(var5);
  1002.             int var8 = Float.floatToIntBits(var1);
  1003.             var6 = var7 == var8 ? 0 : (var7 < var8 ? -1 : 1);
  1004.          }
  1005.  
  1006.          if (var6 < 0) {
  1007.             var2 = var4 + 1;
  1008.          } else {
  1009.             if (var6 <= 0) {
  1010.                return var4;
  1011.             }
  1012.  
  1013.             var3 = var4 - 1;
  1014.          }
  1015.       }
  1016.  
  1017.       return -(var2 + 1);
  1018.    }
  1019.  
  1020.    public static int binarySearch(Object[] var0, Object var1) {
  1021.       int var2 = 0;
  1022.       int var3 = var0.length - 1;
  1023.  
  1024.       while(var2 <= var3) {
  1025.          int var4 = (var2 + var3) / 2;
  1026.          Object var5 = var0[var4];
  1027.          int var6 = ((Comparable)var5).compareTo(var1);
  1028.          if (var6 < 0) {
  1029.             var2 = var4 + 1;
  1030.          } else {
  1031.             if (var6 <= 0) {
  1032.                return var4;
  1033.             }
  1034.  
  1035.             var3 = var4 - 1;
  1036.          }
  1037.       }
  1038.  
  1039.       return -(var2 + 1);
  1040.    }
  1041.  
  1042.    public static int binarySearch(Object[] var0, Object var1, Comparator var2) {
  1043.       if (var2 == null) {
  1044.          return binarySearch(var0, var1);
  1045.       } else {
  1046.          int var3 = 0;
  1047.          int var4 = var0.length - 1;
  1048.  
  1049.          while(var3 <= var4) {
  1050.             int var5 = (var3 + var4) / 2;
  1051.             Object var6 = var0[var5];
  1052.             int var7 = var2.compare(var6, var1);
  1053.             if (var7 < 0) {
  1054.                var3 = var5 + 1;
  1055.             } else {
  1056.                if (var7 <= 0) {
  1057.                   return var5;
  1058.                }
  1059.  
  1060.                var4 = var5 - 1;
  1061.             }
  1062.          }
  1063.  
  1064.          return -(var3 + 1);
  1065.       }
  1066.    }
  1067.  
  1068.    public static boolean equals(long[] var0, long[] var1) {
  1069.       if (var0 == var1) {
  1070.          return true;
  1071.       } else if (var0 != null && var1 != null) {
  1072.          int var2 = var0.length;
  1073.          if (var1.length != var2) {
  1074.             return false;
  1075.          } else {
  1076.             for(int var3 = 0; var3 < var2; ++var3) {
  1077.                if (var0[var3] != var1[var3]) {
  1078.                   return false;
  1079.                }
  1080.             }
  1081.  
  1082.             return true;
  1083.          }
  1084.       } else {
  1085.          return false;
  1086.       }
  1087.    }
  1088.  
  1089.    public static boolean equals(int[] var0, int[] var1) {
  1090.       if (var0 == var1) {
  1091.          return true;
  1092.       } else if (var0 != null && var1 != null) {
  1093.          int var2 = var0.length;
  1094.          if (var1.length != var2) {
  1095.             return false;
  1096.          } else {
  1097.             for(int var3 = 0; var3 < var2; ++var3) {
  1098.                if (var0[var3] != var1[var3]) {
  1099.                   return false;
  1100.                }
  1101.             }
  1102.  
  1103.             return true;
  1104.          }
  1105.       } else {
  1106.          return false;
  1107.       }
  1108.    }
  1109.  
  1110.    public static boolean equals(short[] var0, short[] var1) {
  1111.       if (var0 == var1) {
  1112.          return true;
  1113.       } else if (var0 != null && var1 != null) {
  1114.          int var2 = var0.length;
  1115.          if (var1.length != var2) {
  1116.             return false;
  1117.          } else {
  1118.             for(int var3 = 0; var3 < var2; ++var3) {
  1119.                if (var0[var3] != var1[var3]) {
  1120.                   return false;
  1121.                }
  1122.             }
  1123.  
  1124.             return true;
  1125.          }
  1126.       } else {
  1127.          return false;
  1128.       }
  1129.    }
  1130.  
  1131.    public static boolean equals(char[] var0, char[] var1) {
  1132.       if (var0 == var1) {
  1133.          return true;
  1134.       } else if (var0 != null && var1 != null) {
  1135.          int var2 = var0.length;
  1136.          if (var1.length != var2) {
  1137.             return false;
  1138.          } else {
  1139.             for(int var3 = 0; var3 < var2; ++var3) {
  1140.                if (var0[var3] != var1[var3]) {
  1141.                   return false;
  1142.                }
  1143.             }
  1144.  
  1145.             return true;
  1146.          }
  1147.       } else {
  1148.          return false;
  1149.       }
  1150.    }
  1151.  
  1152.    public static boolean equals(byte[] var0, byte[] var1) {
  1153.       if (var0 == var1) {
  1154.          return true;
  1155.       } else if (var0 != null && var1 != null) {
  1156.          int var2 = var0.length;
  1157.          if (var1.length != var2) {
  1158.             return false;
  1159.          } else {
  1160.             for(int var3 = 0; var3 < var2; ++var3) {
  1161.                if (var0[var3] != var1[var3]) {
  1162.                   return false;
  1163.                }
  1164.             }
  1165.  
  1166.             return true;
  1167.          }
  1168.       } else {
  1169.          return false;
  1170.       }
  1171.    }
  1172.  
  1173.    public static boolean equals(boolean[] var0, boolean[] var1) {
  1174.       if (var0 == var1) {
  1175.          return true;
  1176.       } else if (var0 != null && var1 != null) {
  1177.          int var2 = var0.length;
  1178.          if (var1.length != var2) {
  1179.             return false;
  1180.          } else {
  1181.             for(int var3 = 0; var3 < var2; ++var3) {
  1182.                if (var0[var3] != var1[var3]) {
  1183.                   return false;
  1184.                }
  1185.             }
  1186.  
  1187.             return true;
  1188.          }
  1189.       } else {
  1190.          return false;
  1191.       }
  1192.    }
  1193.  
  1194.    public static boolean equals(double[] var0, double[] var1) {
  1195.       if (var0 == var1) {
  1196.          return true;
  1197.       } else if (var0 != null && var1 != null) {
  1198.          int var2 = var0.length;
  1199.          if (var1.length != var2) {
  1200.             return false;
  1201.          } else {
  1202.             for(int var3 = 0; var3 < var2; ++var3) {
  1203.                if (Double.doubleToLongBits(var0[var3]) != Double.doubleToLongBits(var1[var3])) {
  1204.                   return false;
  1205.                }
  1206.             }
  1207.  
  1208.             return true;
  1209.          }
  1210.       } else {
  1211.          return false;
  1212.       }
  1213.    }
  1214.  
  1215.    public static boolean equals(float[] var0, float[] var1) {
  1216.       if (var0 == var1) {
  1217.          return true;
  1218.       } else if (var0 != null && var1 != null) {
  1219.          int var2 = var0.length;
  1220.          if (var1.length != var2) {
  1221.             return false;
  1222.          } else {
  1223.             for(int var3 = 0; var3 < var2; ++var3) {
  1224.                if (Float.floatToIntBits(var0[var3]) != Float.floatToIntBits(var1[var3])) {
  1225.                   return false;
  1226.                }
  1227.             }
  1228.  
  1229.             return true;
  1230.          }
  1231.       } else {
  1232.          return false;
  1233.       }
  1234.    }
  1235.  
  1236.    public static boolean equals(Object[] var0, Object[] var1) {
  1237.       if (var0 == var1) {
  1238.          return true;
  1239.       } else if (var0 != null && var1 != null) {
  1240.          int var2 = var0.length;
  1241.          if (var1.length != var2) {
  1242.             return false;
  1243.          } else {
  1244.             for(int var3 = 0; var3 < var2; ++var3) {
  1245.                Object var4 = var0[var3];
  1246.                Object var5 = var1[var3];
  1247.                if (!(var4 == null ? var5 == null : var4.equals(var5))) {
  1248.                   return false;
  1249.                }
  1250.             }
  1251.  
  1252.             return true;
  1253.          }
  1254.       } else {
  1255.          return false;
  1256.       }
  1257.    }
  1258.  
  1259.    public static void fill(long[] var0, long var1) {
  1260.       fill(var0, 0, var0.length, var1);
  1261.    }
  1262.  
  1263.    public static void fill(long[] var0, int var1, int var2, long var3) {
  1264.       rangeCheck(var0.length, var1, var2);
  1265.  
  1266.       for(int var5 = var1; var5 < var2; ++var5) {
  1267.          var0[var5] = var3;
  1268.       }
  1269.  
  1270.    }
  1271.  
  1272.    public static void fill(int[] var0, int var1) {
  1273.       fill((int[])var0, 0, var0.length, (int)var1);
  1274.    }
  1275.  
  1276.    public static void fill(int[] var0, int var1, int var2, int var3) {
  1277.       rangeCheck(var0.length, var1, var2);
  1278.  
  1279.       for(int var4 = var1; var4 < var2; ++var4) {
  1280.          var0[var4] = var3;
  1281.       }
  1282.  
  1283.    }
  1284.  
  1285.    public static void fill(short[] var0, short var1) {
  1286.       fill((short[])var0, 0, var0.length, (short)var1);
  1287.    }
  1288.  
  1289.    public static void fill(short[] var0, int var1, int var2, short var3) {
  1290.       rangeCheck(var0.length, var1, var2);
  1291.  
  1292.       for(int var4 = var1; var4 < var2; ++var4) {
  1293.          var0[var4] = var3;
  1294.       }
  1295.  
  1296.    }
  1297.  
  1298.    public static void fill(char[] var0, char var1) {
  1299.       fill((char[])var0, 0, var0.length, (char)var1);
  1300.    }
  1301.  
  1302.    public static void fill(char[] var0, int var1, int var2, char var3) {
  1303.       rangeCheck(var0.length, var1, var2);
  1304.  
  1305.       for(int var4 = var1; var4 < var2; ++var4) {
  1306.          var0[var4] = var3;
  1307.       }
  1308.  
  1309.    }
  1310.  
  1311.    public static void fill(byte[] var0, byte var1) {
  1312.       fill((byte[])var0, 0, var0.length, (byte)var1);
  1313.    }
  1314.  
  1315.    public static void fill(byte[] var0, int var1, int var2, byte var3) {
  1316.       rangeCheck(var0.length, var1, var2);
  1317.  
  1318.       for(int var4 = var1; var4 < var2; ++var4) {
  1319.          var0[var4] = var3;
  1320.       }
  1321.  
  1322.    }
  1323.  
  1324.    public static void fill(boolean[] var0, boolean var1) {
  1325.       fill(var0, 0, var0.length, var1);
  1326.    }
  1327.  
  1328.    public static void fill(boolean[] var0, int var1, int var2, boolean var3) {
  1329.       rangeCheck(var0.length, var1, var2);
  1330.  
  1331.       for(int var4 = var1; var4 < var2; ++var4) {
  1332.          var0[var4] = var3;
  1333.       }
  1334.  
  1335.    }
  1336.  
  1337.    public static void fill(double[] var0, double var1) {
  1338.       fill(var0, 0, var0.length, var1);
  1339.    }
  1340.  
  1341.    public static void fill(double[] var0, int var1, int var2, double var3) {
  1342.       rangeCheck(var0.length, var1, var2);
  1343.  
  1344.       for(int var5 = var1; var5 < var2; ++var5) {
  1345.          var0[var5] = var3;
  1346.       }
  1347.  
  1348.    }
  1349.  
  1350.    public static void fill(float[] var0, float var1) {
  1351.       fill(var0, 0, var0.length, var1);
  1352.    }
  1353.  
  1354.    public static void fill(float[] var0, int var1, int var2, float var3) {
  1355.       rangeCheck(var0.length, var1, var2);
  1356.  
  1357.       for(int var4 = var1; var4 < var2; ++var4) {
  1358.          var0[var4] = var3;
  1359.       }
  1360.  
  1361.    }
  1362.  
  1363.    public static void fill(Object[] var0, Object var1) {
  1364.       fill(var0, 0, var0.length, var1);
  1365.    }
  1366.  
  1367.    public static void fill(Object[] var0, int var1, int var2, Object var3) {
  1368.       rangeCheck(var0.length, var1, var2);
  1369.  
  1370.       for(int var4 = var1; var4 < var2; ++var4) {
  1371.          var0[var4] = var3;
  1372.       }
  1373.  
  1374.    }
  1375.  
  1376.    public static List asList(Object[] var0) {
  1377.       return new ArrayList(var0);
  1378.    }
  1379. }
  1380.