listName := leaf.name
			addList := func(cond int, c *boringCertificate) {
				if cond != 0 {
					list = append(list, c.der)
					listName += "," + c.name
					if reachable[c.org] {
						reachable[c.parentOrg] = true
					}
					if reachableFIPS[c.org] && c.fipsOK {
						reachableFIPS[c.parentOrg] = true
					}
				}
			}
			addList(i&1, I_R1)
			addList(i&2, I_R2)
			addList(i&4, I_M1)

	case mergeDirective:
		diffOptions.BuildRetainKeysDirective = retainKeys
		addList, deletionList, setOrderList, err := diffLists(originalValue, modifiedValue, subschema, patchMeta.GetPatchMergeKey(), diffOptions)
		if err != nil {
			return err
		}
		if len(addList) > 0 {
			patch[key] = addList
		}
		// generate a parallel list for deletion
		if len(deletionList) > 0 {

			}
			if opcodeTable[v.Op].resultInArg0 || v.Op == OpAMD64ADDQconst || v.Op == OpAMD64ADDLconst || v.Op == OpSelect0 {
				if opcodeTable[v.Op].commutative {
					desired.addList(v.Args[1].ID, prefs)
				}
				desired.addList(v.Args[0].ID, prefs)
			}
			// Save desired registers for this value.
			dinfo[i].out = prefs
			for j, a := range v.Args {
				if j >= len(dinfo[i].in) {
					break
				}

    public void testRemove() throws Exception {
        list.addLast(null);
        list.addLast("1");
        list.addLast("2");
        assertThat(list.remove("3"), is(not(true)));
        assertThat(list.remove("1"), is(true));
        assertThat(list.remove(null), is(true));
        list.clear();
        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        list.remove(1);

        given:
        def repo1 = Mock(ArtifactRepository) { getName() >> "a" }
        def repo2 = Mock(ArtifactRepository) { getName() >> "b" }

        when:
        container.addFirst(repo1)
        container.addFirst(repo2)

        then:
        container == [repo2, repo1]
        container.collect { it } == [repo2, repo1]
        container.matching { true } == [repo2, repo1]

  protected ForwardingDeque() {}

  @Override
  protected abstract Deque<E> delegate();

  @Override
  public void addFirst(@ParametricNullness E e) {
    delegate().addFirst(e);
  }

  @Override
  public void addLast(@ParametricNullness E e) {
    delegate().addLast(e);
  }

  @Override
  public Iterator<E> descendingIterator() {
    return delegate().descendingIterator();
  }

  @Override

  protected ForwardingDeque() {}

  @Override
  protected abstract Deque<E> delegate();

  @Override
  public void addFirst(@ParametricNullness E e) {
    delegate().addFirst(e);
  }

  @Override
  public void addLast(@ParametricNullness E e) {
    delegate().addLast(e);
  }

  @Override
  public Iterator<E> descendingIterator() {
    return delegate().descendingIterator();
  }

  @Override

            if (isEven(numberOfProjects)) {
                remaining = numberOfProjects - middle * 2
                layerSizes.addLast(middle)
                layerSizes.addFirst(middle)
            } else {
                remaining = numberOfProjects - middle
                layerSizes.addLast(middle)
            }

            def result = recursiveLayers(remaining, layerSizes)
            if (result) {

        assertArgumentNotNull("disposable", disposable);
        disposables.addLast(disposable);
    }

    /**
     * 破棄可能なリソースを先頭に登録します。
     * <p>
     * リソースは登録された逆順に破棄されるため、先頭に登録されたリソースは最後に破棄されることになります。
     * </p>
     *
     * @param disposable
     *            破棄可能なリソース。{@literal null}であってはいけません
     */
    public static synchronized void addFirst(final Disposable disposable) {

     *
     * @param repository The repository to add.
     */
    void addFirst(ArtifactRepository repository);

    /**
     * Adds a repository to this container, at the end of the repository sequence.
     *
     * @param repository The repository to add.
     */
    void addLast(ArtifactRepository repository);

    /**
     * {@inheritDoc}
     */
    @Override