/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.lang3;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;


public class ArrayUtils {
    public static boolean[] add(final boolean[] array, final boolean element) {
      return null;
    }

    public static boolean[] add(final boolean[] array, final int index, final boolean element) {
      return null;
    }

    public static byte[] add(final byte[] array, final byte element) {
      return null;
    }

    public static byte[] add(final byte[] array, final int index, final byte element) {
      return null;
    }

    public static char[] add(final char[] array, final char element) {
      return null;
    }

    public static char[] add(final char[] array, final int index, final char element) {
      return null;
    }

    public static double[] add(final double[] array, final double element) {
      return null;
    }

    public static double[] add(final double[] array, final int index, final double element) {
      return null;
    }

    public static float[] add(final float[] array, final float element) {
      return null;
    }

    public static float[] add(final float[] array, final int index, final float element) {
      return null;
    }

    public static int[] add(final int[] array, final int element) {
      return null;
    }

    public static int[] add(final int[] array, final int index, final int element) {
      return null;
    }

    public static long[] add(final long[] array, final int index, final long element) {
      return null;
    }

    public static long[] add(final long[] array, final long element) {
      return null;
    }

    public static short[] add(final short[] array, final int index, final short element) {
      return null;
    }

    public static short[] add(final short[] array, final short element) {
      return null;
    }

    public static <T> T[] add(final T[] array, final int index, final T element) {
      return null;
    }

    public static <T> T[] add(final T[] array, final T element) {
      return null;
    }

    public static boolean[] addAll(final boolean[] array1, final boolean... array2) {
      return null;
    }

    public static byte[] addAll(final byte[] array1, final byte... array2) {
      return null;
    }

    public static char[] addAll(final char[] array1, final char... array2) {
      return null;
    }

    public static double[] addAll(final double[] array1, final double... array2) {
      return null;
    }

    public static float[] addAll(final float[] array1, final float... array2) {
      return null;
    }

    public static int[] addAll(final int[] array1, final int... array2) {
      return null;
    }

    public static long[] addAll(final long[] array1, final long... array2) {
      return null;
    }

    public static short[] addAll(final short[] array1, final short... array2) {
      return null;
    }

    public static <T> T[] addAll(final T[] array1, @SuppressWarnings("unchecked") final T... array2) {
      return null;
    }

    public static boolean[] addFirst(final boolean[] array, final boolean element) {
      return null;
    }

    public static byte[] addFirst(final byte[] array, final byte element) {
      return null;
    }

    public static char[] addFirst(final char[] array, final char element) {
      return null;
    }

    public static double[] addFirst(final double[] array, final double element) {
      return null;
    }

    public static float[] addFirst(final float[] array, final float element) {
      return null;
    }

    public static int[] addFirst(final int[] array, final int element) {
      return null;
    }

    public static long[] addFirst(final long[] array, final long element) {
      return null;
    }

    public static short[] addFirst(final short[] array, final short element) {
      return null;
    }

    public static <T> T[] addFirst(final T[] array, final T element) {
      return null;
    }

    public static boolean[] clone(final boolean[] array) {
      return null;
    }

    public static byte[] clone(final byte[] array) {
      return null;
    }

    public static char[] clone(final char[] array) {
      return null;
    }

    public static double[] clone(final double[] array) {
      return null;
    }

    public static float[] clone(final float[] array) {
      return null;
    }

    public static int[] clone(final int[] array) {
      return null;
    }

    public static long[] clone(final long[] array) {
      return null;
    }

    public static short[] clone(final short[] array) {
      return null;
    }

    public static <T> T[] clone(final T[] array) {
      return null;
    }

    public static boolean contains(final boolean[] array, final boolean valueToFind) {
      return false;
    }

    public static boolean contains(final byte[] array, final byte valueToFind) {
      return false;
    }

    public static boolean contains(final char[] array, final char valueToFind) {
      return false;
    }

    public static boolean contains(final double[] array, final double valueToFind) {
      return false;
    }

    public static boolean contains(final double[] array, final double valueToFind, final double tolerance) {
      return false;
    }

    public static boolean contains(final float[] array, final float valueToFind) {
      return false;
    }

    public static boolean contains(final int[] array, final int valueToFind) {
      return false;
    }

    public static boolean contains(final long[] array, final long valueToFind) {
      return false;
    }

    public static boolean contains(final Object[] array, final Object objectToFind) {
      return false;
    }

    public static boolean contains(final short[] array, final short valueToFind) {
      return false;
    }

    public static <T> T get(final T[] array, final int index) {
      return null;
    }

    public static <T> T get(final T[] array, final int index, final T defaultValue) {
      return null;
    }

    public static int getLength(final Object array) {
      return 0;
    }

    public static int hashCode(final Object array) {
      return 0;
    }

    public static BitSet indexesOf(final boolean[] array, final boolean valueToFind) {
      return null;
    }

    public static BitSet indexesOf(final boolean[] array, final boolean valueToFind, int startIndex) {
      return null;
    }

    public static BitSet indexesOf(final byte[] array, final byte valueToFind) {
      return null;
    }

    public static BitSet indexesOf(final byte[] array, final byte valueToFind, int startIndex) {
      return null;
    }

    public static BitSet indexesOf(final char[] array, final char valueToFind) {
      return null;
    }

    public static BitSet indexesOf(final char[] array, final char valueToFind, int startIndex) {
      return null;
    }

    public static BitSet indexesOf(final double[] array, final double valueToFind) {
      return null;
    }

    public static BitSet indexesOf(final double[] array, final double valueToFind, final double tolerance) {
      return null;
    }

    public static BitSet indexesOf(final double[] array, final double valueToFind, int startIndex) {
      return null;
    }

    public static BitSet indexesOf(final double[] array, final double valueToFind, int startIndex, final double tolerance) {
      return null;
    }

    public static BitSet indexesOf(final float[] array, final float valueToFind) {
      return null;
    }

    public static BitSet indexesOf(final float[] array, final float valueToFind, int startIndex) {
      return null;
    }

    public static BitSet indexesOf(final int[] array, final int valueToFind) {
      return null;
    }

    public static BitSet indexesOf(final int[] array, final int valueToFind, int startIndex) {
      return null;
    }

    public static BitSet indexesOf(final long[] array, final long valueToFind) {
      return null;
    }

    public static BitSet indexesOf(final long[] array, final long valueToFind, int startIndex) {
      return null;
    }

    public static BitSet indexesOf(final Object[] array, final Object objectToFind) {
      return null;
    }

    public static BitSet indexesOf(final Object[] array, final Object objectToFind, int startIndex) {
      return null;
    }

    public static BitSet indexesOf(final short[] array, final short valueToFind) {
      return null;
    }

    public static BitSet indexesOf(final short[] array, final short valueToFind, int startIndex) {
      return null;
    }

    public static int indexOf(final boolean[] array, final boolean valueToFind) {
      return 0;
    }

    public static int indexOf(final boolean[] array, final boolean valueToFind, int startIndex) {
      return 0;
    }

    public static int indexOf(final byte[] array, final byte valueToFind) {
      return 0;
    }

    public static int indexOf(final byte[] array, final byte valueToFind, int startIndex) {
      return 0;
    }

    public static int indexOf(final char[] array, final char valueToFind) {
      return 0;
    }

    public static int indexOf(final char[] array, final char valueToFind, int startIndex) {
      return 0;
    }

    public static int indexOf(final double[] array, final double valueToFind) {
      return 0;
    }

    public static int indexOf(final double[] array, final double valueToFind, final double tolerance) {
      return 0;
    }

    public static int indexOf(final double[] array, final double valueToFind, int startIndex) {
      return 0;
    }

    public static int indexOf(final double[] array, final double valueToFind, int startIndex, final double tolerance) {
      return 0;
    }

    public static int indexOf(final float[] array, final float valueToFind) {
      return 0;
    }

    public static int indexOf(final float[] array, final float valueToFind, int startIndex) {
      return 0;
    }

    public static int indexOf(final int[] array, final int valueToFind) {
      return 0;
    }

public static int indexOf(final int[] array, final int valueToFind, int startIndex) {
  return 0;
}

    public static int indexOf(final long[] array, final long valueToFind) {
      return 0;
    }

    public static int indexOf(final long[] array, final long valueToFind, int startIndex) {
      return 0;
    }

    public static int indexOf(final Object[] array, final Object objectToFind) {
      return 0;
    }

    public static int indexOf(final Object[] array, final Object objectToFind, int startIndex) {
      return 0;
    }

    public static int indexOf(final short[] array, final short valueToFind) {
      return 0;
    }

    public static int indexOf(final short[] array, final short valueToFind, int startIndex) {
      return 0;
    }

    public static boolean[] insert(final int index, final boolean[] array, final boolean... values) {
      return null;
    }

    public static byte[] insert(final int index, final byte[] array, final byte... values) {
      return null;
    }

    public static char[] insert(final int index, final char[] array, final char... values) {
      return null;
    }

    public static double[] insert(final int index, final double[] array, final double... values) {
      return null;
    }

    public static float[] insert(final int index, final float[] array, final float... values) {
      return null;
    }

    public static int[] insert(final int index, final int[] array, final int... values) {
      return null;
    }

    public static long[] insert(final int index, final long[] array, final long... values) {
      return null;
    }

    public static short[] insert(final int index, final short[] array, final short... values) {
      return null;
    }

    public static <T> T[] insert(final int index, final T[] array, final T... values) {
      return null;
    }

    public static <T> boolean isArrayIndexValid(final T[] array, final int index) {
      return false;
    }

    public static boolean isEmpty(final boolean[] array) {
      return false;
    }

    public static boolean isEmpty(final byte[] array) {
      return false;
    }

    public static boolean isEmpty(final char[] array) {
      return false;
    }

    public static boolean isEmpty(final double[] array) {
      return false;
    }

    public static boolean isEmpty(final float[] array) {
      return false;
    }

    public static boolean isEmpty(final int[] array) {
      return false;
    }

    public static boolean isEmpty(final long[] array) {
      return false;
    }

    public static boolean isEmpty(final Object[] array) {
      return false;
    }

    public static boolean isEmpty(final short[] array) {
      return false;
    }

    public static boolean isEquals(final Object array1, final Object array2) {
      return false;
    }

    public static boolean isNotEmpty(final boolean[] array) {
      return false;
    }

    public static boolean isNotEmpty(final byte[] array) {
      return false;
    }

    public static boolean isNotEmpty(final char[] array) {
      return false;
    }

    public static boolean isNotEmpty(final double[] array) {
      return false;
    }

    public static boolean isNotEmpty(final float[] array) {
      return false;
    }

    public static boolean isNotEmpty(final int[] array) {
      return false;
    }

    public static boolean isNotEmpty(final long[] array) {
      return false;
    }

    public static boolean isNotEmpty(final short[] array) {
      return false;
    }

     public static <T> boolean isNotEmpty(final T[] array) {
       return false;
     }

    public static boolean isSameLength(final boolean[] array1, final boolean[] array2) {
      return false;
    }

    public static boolean isSameLength(final byte[] array1, final byte[] array2) {
      return false;
    }

    public static boolean isSameLength(final char[] array1, final char[] array2) {
      return false;
    }

    public static boolean isSameLength(final double[] array1, final double[] array2) {
      return false;
    }

    public static boolean isSameLength(final float[] array1, final float[] array2) {
      return false;
    }

    public static boolean isSameLength(final int[] array1, final int[] array2) {
      return false;
    }

    public static boolean isSameLength(final long[] array1, final long[] array2) {
      return false;
    }

    public static boolean isSameLength(final Object array1, final Object array2) {
      return false;
    }

    public static boolean isSameLength(final Object[] array1, final Object[] array2) {
      return false;
    }

    public static boolean isSameLength(final short[] array1, final short[] array2) {
      return false;
    }

    public static boolean isSameType(final Object array1, final Object array2) {
      return false;
    }

    public static boolean isSorted(final boolean[] array) {
      return false;
    }

    public static boolean isSorted(final byte[] array) {
      return false;
    }

    public static boolean isSorted(final char[] array) {
      return false;
    }

    public static boolean isSorted(final double[] array) {
      return false;
    }

    public static boolean isSorted(final float[] array) {
      return false;
    }

    public static boolean isSorted(final int[] array) {
      return false;
    }

    public static boolean isSorted(final long[] array) {
      return false;
    }

    public static boolean isSorted(final short[] array) {
      return false;
    }

    public static <T extends Comparable<? super T>> boolean isSorted(final T[] array) {
      return false;
    }

    public static <T> boolean isSorted(final T[] array, final Comparator<T> comparator) {
      return false;
    }

    public static int lastIndexOf(final boolean[] array, final boolean valueToFind) {
      return 0;
    }

    public static int lastIndexOf(final boolean[] array, final boolean valueToFind, int startIndex) {
      return 0;
    }

    public static int lastIndexOf(final byte[] array, final byte valueToFind) {
      return 0;
    }

    public static int lastIndexOf(final byte[] array, final byte valueToFind, int startIndex) {
      return 0;
    }

    public static int lastIndexOf(final char[] array, final char valueToFind) {
      return 0;
    }

    public static int lastIndexOf(final char[] array, final char valueToFind, int startIndex) {
      return 0;
    }

    public static int lastIndexOf(final double[] array, final double valueToFind) {
      return 0;
    }

    public static int lastIndexOf(final double[] array, final double valueToFind, final double tolerance) {
      return 0;
    }

    public static int lastIndexOf(final double[] array, final double valueToFind, int startIndex) {
      return 0;
    }

    public static int lastIndexOf(final double[] array, final double valueToFind, int startIndex, final double tolerance) {
      return 0;
    }

    public static int lastIndexOf(final float[] array, final float valueToFind) {
      return 0;
    }

    public static int lastIndexOf(final float[] array, final float valueToFind, int startIndex) {
      return 0;
    }

    public static int lastIndexOf(final int[] array, final int valueToFind) {
      return 0;
    }

    public static int lastIndexOf(final int[] array, final int valueToFind, int startIndex) {
      return 0;
    }

    public static int lastIndexOf(final long[] array, final long valueToFind) {
      return 0;
    }

    public static int lastIndexOf(final long[] array, final long valueToFind, int startIndex) {
      return 0;
    }

    public static int lastIndexOf(final Object[] array, final Object objectToFind) {
      return 0;
    }

    public static int lastIndexOf(final Object[] array, final Object objectToFind, int startIndex) {
      return 0;
    }

    public static int lastIndexOf(final short[] array, final short valueToFind) {
      return 0;
    }

    public static int lastIndexOf(final short[] array, final short valueToFind, int startIndex) {
      return 0;
    }

    public static boolean[] nullToEmpty(final boolean[] array) {
      return null;
    }

    public static Boolean[] nullToEmpty(final Boolean[] array) {
      return null;
    }

    public static byte[] nullToEmpty(final byte[] array) {
      return null;
    }

    public static Byte[] nullToEmpty(final Byte[] array) {
      return null;
    }

    public static char[] nullToEmpty(final char[] array) {
      return null;
    }

    public static Character[] nullToEmpty(final Character[] array) {
      return null;
    }

    public static Class<?>[] nullToEmpty(final Class<?>[] array) {
      return null;
    }

    public static double[] nullToEmpty(final double[] array) {
      return null;
    }

    public static Double[] nullToEmpty(final Double[] array) {
      return null;
    }

    public static float[] nullToEmpty(final float[] array) {
      return null;
    }

    public static Float[] nullToEmpty(final Float[] array) {
      return null;
    }

    public static int[] nullToEmpty(final int[] array) {
      return null;
    }

    public static Integer[] nullToEmpty(final Integer[] array) {
      return null;
    }

    public static long[] nullToEmpty(final long[] array) {
      return null;
    }

    public static Long[] nullToEmpty(final Long[] array) {
      return null;
    }

    public static Object[] nullToEmpty(final Object[] array) {
      return null;
    }

    public static short[] nullToEmpty(final short[] array) {
      return null;
    }

    public static Short[] nullToEmpty(final Short[] array) {
      return null;
    }

    public static String[] nullToEmpty(final String[] array) {
      return null;
    }

    public static <T> T[] nullToEmpty(final T[] array, final Class<T[]> type) {
      return null;
    }

    public static boolean[] remove(final boolean[] array, final int index) {
      return null;
    }

    public static byte[] remove(final byte[] array, final int index) {
      return null;
    }

    public static char[] remove(final char[] array, final int index) {
      return null;
    }

    public static double[] remove(final double[] array, final int index) {
      return null;
    }

    public static float[] remove(final float[] array, final int index) {
      return null;
    }

    public static int[] remove(final int[] array, final int index) {
      return null;
    }

    public static long[] remove(final long[] array, final int index) {
      return null;
    }

    public static short[] remove(final short[] array, final int index) {
      return null;
    }

    public static <T> T[] remove(final T[] array, final int index) {
      return null;
    }

    public static boolean[] removeAll(final boolean[] array, final int... indices) {
      return null;
    }

    public static byte[] removeAll(final byte[] array, final int... indices) {
      return null;
    }

    public static char[] removeAll(final char[] array, final int... indices) {
      return null;
    }

    public static double[] removeAll(final double[] array, final int... indices) {
      return null;
    }

    public static float[] removeAll(final float[] array, final int... indices) {
      return null;
    }

    public static int[] removeAll(final int[] array, final int... indices) {
      return null;
    }

    public static long[] removeAll(final long[] array, final int... indices) {
      return null;
    }

    public static short[] removeAll(final short[] array, final int... indices) {
      return null;
    }

    public static <T> T[] removeAll(final T[] array, final int... indices) {
      return null;
    }

    public static boolean[] removeAllOccurences(final boolean[] array, final boolean element) {
      return null;
    }

    public static byte[] removeAllOccurences(final byte[] array, final byte element) {
      return null;
    }

    public static char[] removeAllOccurences(final char[] array, final char element) {
      return null;
    }

    public static double[] removeAllOccurences(final double[] array, final double element) {
      return null;
    }

    public static float[] removeAllOccurences(final float[] array, final float element) {
      return null;
    }

    public static int[] removeAllOccurences(final int[] array, final int element) {
      return null;
    }

    public static long[] removeAllOccurences(final long[] array, final long element) {
      return null;
    }

    public static short[] removeAllOccurences(final short[] array, final short element) {
      return null;
    }

    public static <T> T[] removeAllOccurences(final T[] array, final T element) {
      return null;
    }

    public static boolean[] removeAllOccurrences(final boolean[] array, final boolean element) {
      return null;
    }

    public static byte[] removeAllOccurrences(final byte[] array, final byte element) {
      return null;
    }

    public static char[] removeAllOccurrences(final char[] array, final char element) {
      return null;
    }

    public static double[] removeAllOccurrences(final double[] array, final double element) {
      return null;
    }

    public static float[] removeAllOccurrences(final float[] array, final float element) {
      return null;
    }

    public static int[] removeAllOccurrences(final int[] array, final int element) {
      return null;
    }

    public static long[] removeAllOccurrences(final long[] array, final long element) {
      return null;
    }

    public static short[] removeAllOccurrences(final short[] array, final short element) {
      return null;
    }

    public static <T> T[] removeAllOccurrences(final T[] array, final T element) {
      return null;
    }

    public static boolean[] removeElement(final boolean[] array, final boolean element) {
      return null;
    }

    public static byte[] removeElement(final byte[] array, final byte element) {
      return null;
    }

    public static char[] removeElement(final char[] array, final char element) {
      return null;
    }

    public static double[] removeElement(final double[] array, final double element) {
      return null;
    }

    public static float[] removeElement(final float[] array, final float element) {
      return null;
    }

    public static int[] removeElement(final int[] array, final int element) {
      return null;
    }

    public static long[] removeElement(final long[] array, final long element) {
      return null;
    }

    public static short[] removeElement(final short[] array, final short element) {
      return null;
    }

    public static <T> T[] removeElement(final T[] array, final Object element) {
      return null;
    }

    public static boolean[] removeElements(final boolean[] array, final boolean... values) {
      return null;
    }

    public static byte[] removeElements(final byte[] array, final byte... values) {
      return null;
    }

    public static char[] removeElements(final char[] array, final char... values) {
      return null;
    }

    public static double[] removeElements(final double[] array, final double... values) {
      return null;
    }

    public static float[] removeElements(final float[] array, final float... values) {
      return null;
    }

    public static int[] removeElements(final int[] array, final int... values) {
      return null;
    }

    public static long[] removeElements(final long[] array, final long... values) {
      return null;
    }

    public static short[] removeElements(final short[] array, final short... values) {
      return null;
    }

    public static <T> T[] removeElements(final T[] array, final T... values) {
      return null;
    }

    public static void reverse(final boolean[] array) {
    }

    public static void reverse(final boolean[] array, final int startIndexInclusive, final int endIndexExclusive) {
    }

    public static void reverse(final byte[] array) {
    }

    public static void reverse(final byte[] array, final int startIndexInclusive, final int endIndexExclusive) {
    }

    public static void reverse(final char[] array) {
    }

    public static void reverse(final char[] array, final int startIndexInclusive, final int endIndexExclusive) {
    }

    public static void reverse(final double[] array) {
    }

    public static void reverse(final double[] array, final int startIndexInclusive, final int endIndexExclusive) {
    }

    public static void reverse(final float[] array) {
    }

    public static void reverse(final float[] array, final int startIndexInclusive, final int endIndexExclusive) {
    }

    public static void reverse(final int[] array) {
    }

    public static void reverse(final int[] array, final int startIndexInclusive, final int endIndexExclusive) {
    }

    public static void reverse(final long[] array) {
    }

    public static void reverse(final long[] array, final int startIndexInclusive, final int endIndexExclusive) {
    }

    public static void reverse(final Object[] array) {
    }

    public static void reverse(final Object[] array, final int startIndexInclusive, final int endIndexExclusive) {
    }

    public static void reverse(final short[] array) {
    }

    public static void reverse(final short[] array, final int startIndexInclusive, final int endIndexExclusive) {
    }

    public static void shift(final boolean[] array, final int offset) {
    }

    public static void shift(final boolean[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
    }

    public static void shift(final byte[] array, final int offset) {
    }

    public static void shift(final byte[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
    }

    public static void shift(final char[] array, final int offset) {
    }

    public static void shift(final char[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
    }

    public static void shift(final double[] array, final int offset) {
    }

    public static void shift(final double[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
    }

    public static void shift(final float[] array, final int offset) {
    }

    public static void shift(final float[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
    }

    public static void shift(final int[] array, final int offset) {
    }

    public static void shift(final int[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
    }

    public static void shift(final long[] array, final int offset) {
    }

    public static void shift(final long[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
    }

    public static void shift(final Object[] array, final int offset) {
    }

    public static void shift(final Object[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
    }

    public static void shift(final short[] array, final int offset) {
    }

    public static void shift(final short[] array, int startIndexInclusive, int endIndexExclusive, int offset) {
    }

    public static void shuffle(final boolean[] array) {
    }

    public static void shuffle(final boolean[] array, final Random random) {
    }

    public static void shuffle(final byte[] array) {
    }

    public static void shuffle(final byte[] array, final Random random) {
    }

    public static void shuffle(final char[] array) {
    }

    public static void shuffle(final char[] array, final Random random) {
    }

    public static void shuffle(final double[] array) {
    }

    public static void shuffle(final double[] array, final Random random) {
    }

    public static void shuffle(final float[] array) {
    }

    public static void shuffle(final float[] array, final Random random) {
    }

    public static void shuffle(final int[] array) {
    }

    public static void shuffle(final int[] array, final Random random) {
    }

    public static void shuffle(final long[] array) {
    }

    public static void shuffle(final long[] array, final Random random) {
    }

    public static void shuffle(final Object[] array) {
    }

    public static void shuffle(final Object[] array, final Random random) {
    }

    public static void shuffle(final short[] array) {
    }

    public static void shuffle(final short[] array, final Random random) {
    }

    public static boolean[] subarray(final boolean[] array, int startIndexInclusive, int endIndexExclusive) {
      return null;
    }

    public static byte[] subarray(final byte[] array, int startIndexInclusive, int endIndexExclusive) {
      return null;
    }

    public static char[] subarray(final char[] array, int startIndexInclusive, int endIndexExclusive) {
      return null;
    }

    public static double[] subarray(final double[] array, int startIndexInclusive, int endIndexExclusive) {
      return null;
    }

    public static float[] subarray(final float[] array, int startIndexInclusive, int endIndexExclusive) {
      return null;
    }

    public static int[] subarray(final int[] array, int startIndexInclusive, int endIndexExclusive) {
      return null;
    }

    public static long[] subarray(final long[] array, int startIndexInclusive, int endIndexExclusive) {
      return null;
    }

    public static short[] subarray(final short[] array, int startIndexInclusive, int endIndexExclusive) {
      return null;
    }

    public static <T> T[] subarray(final T[] array, int startIndexInclusive, int endIndexExclusive) {
      return null;
    }

    public static void swap(final boolean[] array, final int offset1, final int offset2) {
    }

    public static void swap(final boolean[] array, int offset1, int offset2, int len) {
    }

    public static void swap(final byte[] array, final int offset1, final int offset2) {
    }

    public static void swap(final byte[] array, int offset1, int offset2, int len) {
    }

    public static void swap(final char[] array, final int offset1, final int offset2) {
    }

    public static void swap(final char[] array, int offset1, int offset2, int len) {
    }

    public static void swap(final double[] array, final int offset1, final int offset2) {
    }

    public static void swap(final double[] array,  int offset1, int offset2, int len) {
    }

    public static void swap(final float[] array, final int offset1, final int offset2) {
    }

    public static void swap(final float[] array, int offset1, int offset2, int len) {
    }

    public static void swap(final int[] array, final int offset1, final int offset2) {
    }

    public static void swap(final int[] array,  int offset1, int offset2, int len) {
    }

    public static void swap(final long[] array, final int offset1, final int offset2) {
    }

    public static void swap(final long[] array,  int offset1, int offset2, int len) {
    }

    public static void swap(final Object[] array, final int offset1, final int offset2) {
    }

    public static void swap(final Object[] array,  int offset1, int offset2, int len) {
    }

    public static void swap(final short[] array, final int offset1, final int offset2) {
    }

        public static void swap(final short[] array,  int offset1, int offset2, int len) {
        }

    public static <T> T[] toArray(@SuppressWarnings("unchecked") final T... items) {
      return null;
    }

    public static Map<Object, Object> toMap(final Object[] array) {
      return null;
    }

    public static Boolean[] toObject(final boolean[] array) {
      return null;
    }

    public static Byte[] toObject(final byte[] array) {
      return null;
    }

    public static Character[] toObject(final char[] array) {
      return null;
    }

    public static Double[] toObject(final double[] array) {
      return null;
    }

    public static Float[] toObject(final float[] array) {
      return null;
    }

    public static Integer[] toObject(final int[] array) {
      return null;
    }

    public static Long[] toObject(final long[] array) {
      return null;
    }

    public static Short[] toObject(final short[] array) {
      return null;
    }

    public static boolean[] toPrimitive(final Boolean[] array) {
      return null;
    }

    public static boolean[] toPrimitive(final Boolean[] array, final boolean valueForNull) {
      return null;
    }

    public static byte[] toPrimitive(final Byte[] array) {
      return null;
    }

    public static byte[] toPrimitive(final Byte[] array, final byte valueForNull) {
      return null;
    }

    public static char[] toPrimitive(final Character[] array) {
      return null;
    }

    public static char[] toPrimitive(final Character[] array, final char valueForNull) {
      return null;
    }

    public static double[] toPrimitive(final Double[] array) {
      return null;
    }

    public static double[] toPrimitive(final Double[] array, final double valueForNull) {
      return null;
    }

    public static float[] toPrimitive(final Float[] array) {
      return null;
    }

    public static float[] toPrimitive(final Float[] array, final float valueForNull) {
      return null;
    }

    public static int[] toPrimitive(final Integer[] array) {
      return null;
    }

    public static int[] toPrimitive(final Integer[] array, final int valueForNull) {
      return null;
    }

    public static long[] toPrimitive(final Long[] array) {
      return null;
    }

    public static long[] toPrimitive(final Long[] array, final long valueForNull) {
      return null;
    }

    public static Object toPrimitive(final Object array) {
      return null;
    }

    public static short[] toPrimitive(final Short[] array) {
      return null;
    }

    public static short[] toPrimitive(final Short[] array, final short valueForNull) {
      return null;
    }

    public static String toString(final Object array) {
      return null;
    }

    public static String toString(final Object array, final String stringIfNull) {
      return null;
    }

    public static String[] toStringArray(final Object[] array) {
      return null;
    }

    public static String[] toStringArray(final Object[] array, final String valueForNullElements) {
      return null;
    }

    public ArrayUtils() {
    }

}
