assertTrue(broken.hasNext());
    // We can't retrieve even the known first element:
    assertThrows(SomeUncheckedException.class, broken::next);
    assertThrows(SomeUncheckedException.class, broken::next);
  }

  private static Iterator<Integer> newDoubler(int first, int last) {
    return new AbstractSequentialIterator<Integer>(first) {
      @Override
      protected @Nullable Integer computeNext(Integer previous) {

        this.value3 = value3;
        this.value4 = value4;
    }

    /**
     * Returns the first value.
     *
     * @return The first value
     */
    public T1 getValue1() {
        return value1;
    }

    /**
     * Sets the first value.
     *
     * @param value1
     *            The first value
     */
    public void setValue1(final T1 value1) {
        this.value1 = value1;
    }

        this.value5 = value5;
    }

    /**
     * Returns the first value.
     *
     * @return The first value
     */
    public T1 getValue1() {
        return value1;
    }

    /**
     * Sets the first value.
     *
     * @param value1
     *            The first value
     */
    public void setValue1(final T1 value1) {
        this.value1 = value1;
    }

    Converter<StringWrapper, Long> converter = first.andThen(STR_TO_LONG);

    assertEquals(LONG_VAL, converter.convert(new StringWrapper(STR_VAL)));
    assertEquals(STR_VAL, converter.reverse().convert(LONG_VAL).value);

    assertEquals("StringWrapper.andThen(string2long)", converter.toString());

    new EqualsTester()
        .addEqualityGroup(first.andThen(STR_TO_LONG), first.andThen(STR_TO_LONG))
        .testEquals();
  }

        return array;
    }

    /**
     * Returns the index of the first occurrence of the specified object in the array.
     *
     * @param <T>
     *            the type of the array elements
     * @param array
     *            the array
     * @param obj
     *            the object to search for
     * @return the index of the first occurrence of the object in the array
     */

     *
     * @param first the first entry of the table
     * @param entry the entry being removed from the table
     * @return the new first entry for the table
     */
    @GuardedBy("this")
    @Nullable E removeFromChain(E first, E entry) {
      int newCount = count;
      E newFirst = entry.getNext();
      for (E e = first; e != entry; e = e.getNext()) {

    }
  }

  /**
   * Constructs an {@code ImmutableSortedSet} from the first {@code n} elements of {@code contents}.
   * If {@code k} is the size of the returned {@code ImmutableSortedSet}, then the sorted unique
   * elements are in the first {@code k} positions of {@code contents}, and {@code contents[i] ==
   * null} for {@code k <= i < n}.
   *

$(function() {
  $('input[type="text"],select,textarea', ".login-box,section.content")
    .first()
    .focus();
  $(".form-group .has-error")
    .first()
    .next("input,select,textarea")
    .focus();

  $("section.content input").keypress(function(e) {
    var $submitButton;
    if (e.which === 13) {
      $submitButton = $("input#submit, button#submit");
      if ($submitButton.length > 0) {
        $submitButton[0].submit();
      }

        InvertibleCryptographer first = securityResourceProvider.providePrimaryInvertibleCryptographer();
        InvertibleCryptographer second = securityResourceProvider.providePrimaryInvertibleCryptographer();

        assertNotNull(first);
        assertNotNull(second);
        assertSame(first, second);
        assertSame(invertibleCryptographer, first);
    }

   *
   * <p><b>Note:</b> if {@code first} is represented as an {@link Optional}, this can be
   * accomplished with {@link Optional#or(Object) first.or(second)}. That approach also allows for
   * lazy evaluation of the fallback instance, using {@link Optional#or(Supplier)
   * first.or(supplier)}.
   *
   * <p><b>Java 9 users:</b> use {@code java.util.Objects.requireNonNullElse(first, second)}
   * instead.
   *