return Integer.valueOf(3);
        }

        /**
         * @param arg1
         * @param arg2
         * @return int
         */
        public int add2(final int arg1, final int arg2) {
            return arg1 + arg2;
        }

        /**
         * @param arg
         * @return Integer
         */

        securityDescriptorBytes[3] = 0;
        // No owner (offset 0)
        for (int i = 4; i < 8; i++)
            securityDescriptorBytes[i] = 0;
        // No group (offset 0)
        for (int i = 8; i < 12; i++)
            securityDescriptorBytes[i] = 0;
        // No SACL (offset 0)
        for (int i = 12; i < 16; i++)
            securityDescriptorBytes[i] = 0;
        // DACL at offset 20

        message[62] = 0x00;
        message[63] = 0x00;

        // Add dummy LM response (24 zeros at offset 64)
        for (int i = 0; i < 24; i++) {
            message[64 + i] = 0;
        }

        // Add dummy NT response (24 zeros at offset 88)
        for (int i = 0; i < 24; i++) {
            message[88 + i] = 0;
        }

        // Add Domain "DOMAIN" in Unicode at offset 112

    }

    @Override
    public int count(@Nullable Object element) {
      return standardCount(element);
    }

    @Override
    public boolean equals(@Nullable Object object) {
      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override

  final Map<E, N> inEdgeMap;

  /** Keys are edges outgoing from the origin node, values are the target node. */
  final Map<E, N> outEdgeMap;

  private int selfLoopCount;

  AbstractDirectedNetworkConnections(Map<E, N> inEdgeMap, Map<E, N> outEdgeMap, int selfLoopCount) {
    this.inEdgeMap = checkNotNull(inEdgeMap);
    this.outEdgeMap = checkNotNull(outEdgeMap);
    this.selfLoopCount = checkNonNegative(selfLoopCount);

@NullUnmarked
@AndroidIncompatible // test-suite builders
public class DoubleArrayAsListTest extends TestCase {

  private static List<Double> asList(Double[] values) {
    double[] temp = new double[values.length];
    for (int i = 0; i < values.length; i++) {
      temp[i] = checkNotNull(values[i]); // checkNotNull for GWT (do not optimize).
    }
    return Doubles.asList(temp);
  }

  @J2ktIncompatible
  @GwtIncompatible // suite

   * or the least double greater than or equal to the precise value of x.
   */
  abstract double roundToDoubleArbitrarily(X x);

  /** Returns the sign of x: either -1, 0, or 1. */
  abstract int sign(X x);

  /** Returns d's value as an X, rounded with the specified mode. */
  abstract X toX(double d, RoundingMode mode);

  /** Returns a - b, guaranteed that both arguments are nonnegative. */

@J2ktIncompatible
@GwtCompatible
public final class MapMaker {
  private static final int DEFAULT_INITIAL_CAPACITY = 16;
  private static final int DEFAULT_CONCURRENCY_LEVEL = 4;

  static final int UNSET_INT = -1;

  // TODO(kevinb): dispense with this after benchmarking
  boolean useCustomMap;

  int initialCapacity = UNSET_INT;
  int concurrencyLevel = UNSET_INT;

  @Nullable Strength keyStrength;

                .getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
    sort(entries, Helpers.<K, V>entryComparator(navigableMap.comparator()));
    for (int i = 0; i < entries.size(); i++) {
      for (int j = i + 1; j < entries.size(); j++) {
        assertEqualInOrder(
            entries.subList(i, j),
            navigableMap.subMap(entries.get(i).getKey(), entries.get(j).getKey()).entrySet());

  Hasher putBytes(byte[] bytes);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(byte[] bytes, int off, int len);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(ByteBuffer bytes);

  @CanIgnoreReturnValue
  @Override
  Hasher putShort(short s);

  @CanIgnoreReturnValue
  @Override
  Hasher putInt(int i);

  @CanIgnoreReturnValue
  @Override
  Hasher putLong(long l);