@Override
  void setCountCheckReturnValue(E element, int count) {
    assertEquals(
        "multiset.setCount() should return the old count",
        getMultiset().count(element),
        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

  @CanIgnoreReturnValue
  private int setCount(E element, int count) {

    private final Map<K, Collection<? extends T>> elements = new HashMap<>();
    private final Multimap<K, K> targetToSource = LinkedHashMultimap.create();

    /**
     * Adds new element and returns a conflict instance if given element is conflicted. Element is conflicted when:
     *  - has more than 1 candidate
     *  - is in conflict with an existing element (via replacedBy relationship)
     *

  final transient E element;

  SingletonImmutableSet(E element) {
    this.element = Preconditions.checkNotNull(element);
  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  public boolean contains(@CheckForNull Object target) {
    return element.equals(target);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {

	x, y, z, t field.Element
}

type incomparable [0]func()

func checkInitialized(points ...*Point) {
	for _, p := range points {
		if p.x == (field.Element{}) && p.y == (field.Element{}) {
			panic("edwards25519: use of uninitialized Point")
		}
	}
}

type projCached struct {
	YplusX, YminusX, Z, T2d field.Element
}

type affineCached struct {

// insertAfterFunc find and insert an element after the found element.
// If the f function returns true, the returned value will be inserted after the found element.
func insertAfterFunc[E any](s []E, f func(e E) (bool, E)) ([]E, bool) {
	var toInsert E
	idx := -1
	for k, v := range s {
		if ok, r := f(v); ok {
			toInsert = r
			idx = k
			break
		}
	}

	if idx == -1 {
		return s, false
	}

    public Builder<E> add(E element) {
      super.add(element);
      return this;
    }

    /**
     * Adds each element of {@code elements} to the {@code ImmutableSortedSet}, ignoring duplicate
     * elements (only the first duplicate element is added).
     *
     * @param elements the elements to add
     * @return this {@code Builder} object
     * @throws NullPointerException if {@code elements} contains a null element

)

const (
	// Field indicates that the content of this path element is a field's name
	Field = "f"

	// Value indicates that the content of this path element is a field's value
	Value = "v"

	// Index indicates that the content of this path element is an index in an array
	Index = "i"

	// Key indicates that the content of this path element is a key value map
	Key = "k"

    /**
     * This default mode for combining a DOM node during merge means that where element names match, the process will
     * try to merge the element attributes and values, rather than overriding the recessive element completely with the
     * dominant one. This means that wherever the dominant element doesn't provide the value or a particular attribute,
     * that value or attribute will be set from the recessive DOM node.

        @Override
        public String getName(ProjectState element) {
            return element.getName();
        }

        @Override
        public String getIdentityName(ProjectState element) {
            String identityName = element.getIdentityPath().getName();
            return identityName != null ? identityName : element.getName();
        }

        @Override

    }

    def "has intervening lifecycle task as dependency when set"() {
        when:
        element.builtBy(dependedOn1)
        element.setBuildTask(lifecycleTask)
        element.builtBy(dependedOn2)

        then:
        element.getBuildDependencies().getDependencies(Stub(Task)) == [lifecycleTask] as Set

        and: