return new Multisets.AbstractEntry<E>() {
      @Override
      @ParametricNullness
      public E getElement() {
        return baseEntry.getElement();
      }

      @Override
      public int getCount() {
        int result = baseEntry.getCount();
        if (result == 0) {
          return count(getElement());
        } else {
          return result;
        }
      }
    };
  }

        return this.getCount() == that.getCount()
            && Objects.equal(this.getElement(), that.getElement());
      }
      return false;
    }

    /**
     * Return this entry's hash code, following the behavior specified in {@link
     * Multiset.Entry#hashCode}.
     */
    @Override
    public int hashCode() {
      E e = getElement();
      return ((e == null) ? 0 : e.hashCode()) ^ getCount();
    }

        assertThat(indexed1.getElement(), is("aaa"));

        final Indexed<String> indexed2 = it.next();
        assertThat(indexed2.getIndex(), is(1));
        assertThat(indexed2.getElement(), is("bbb"));

        final Indexed<String> indexed3 = it.next();
        assertThat(indexed3.getIndex(), is(2));
        assertThat(indexed3.getElement(), is("ccc"));

        assertThat(it.hasNext(), is(not(true)));

        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        assertThat(list.getEntry(0).getElement(), is("1"));
        assertThat(list.getEntry(1).getElement(), is("2"));
        assertThat(list.getEntry(2).getElement(), is("3"));
        try {
            list.getEntry(-1);
            fail();
        } catch (final ClIndexOutOfBoundsException ex) {

      }

      @Override
      public E next() {
        if (remaining <= 0) {
          Entry<E> entry = entryIterator.next();
          element = entry.getElement();
          remaining = entry.getCount();
        }
        remaining--;
        /*
         * requireNonNull is safe because `remaining` starts at 0, forcing us to initialize

          ToOptionalState::new,
          (state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),
          ToOptionalState::combine,
          state -> {
            Object result = state.getElement();
            return (result == NULL_PLACEHOLDER) ? null : result;
          },
          Collector.Characteristics.UNORDERED);

  /**

 *     System.out.println(indexed.getElement());
 * }
 * </pre>
 *
 * <pre>
 * import static org.codelibs.core.collection.IndexedIterator.*;
 * import static org.codelibs.core.io.LineIterator.*;
 *
 * BufferedReader reader = ...;
 * for (Indexed&lt;String%gt; indexed : indexed(iterable(reader))) {
 *     System.out.println(indexed.getIndex());
 *     System.out.println(indexed.getElement());
 * }
 * </pre>
 *

     */
    public Indexed(final T element, final int index) {
        this.element = element;
        this.index = index;
    }

    /**
     * 要素を返します。
     *
     * @return 要素
     */
    public T getElement() {
        return element;
    }

    /**
     * インデックスを返します。
     *
     * @return インデックス
     */
    public int getIndex() {
        return index;
    }

      Collection<? extends Entry<? extends E>> entries) {
    ImmutableMultiset.Builder<E> builder = new ImmutableMultiset.Builder<E>(entries.size());
    for (Entry<? extends E> entry : entries) {
      builder.addCopies(entry.getElement(), entry.getCount());
    }
    return builder.build();
  }

  ImmutableMultiset() {}

  @Override
  public UnmodifiableIterator<E> iterator() {

            return expiredTask;
        }
        for (SLinkedList<TimeoutTask>.Entry e = timeoutTaskList.getFirstEntry(); e != null; e = e.getNext()) {
            final TimeoutTask task = e.getElement();
            if (task.isCanceled()) {
                e.remove();
            } else if (!task.isStopped() && task.isExpired()) {
                expiredTask.add(task);
                if (!task.isPermanent()) {