}
    int oldCount = backingMap.getValue(entryIndex);
    long newCount = (long) oldCount + (long) occurrences;
    checkArgument(newCount <= Integer.MAX_VALUE, "too many occurrences: %s", newCount);
    backingMap.setValue(entryIndex, (int) newCount);
    size += occurrences;
    return oldCount;
  }

  @CanIgnoreReturnValue
  @Override
  public final int remove(@CheckForNull Object element, int occurrences) {

            classes[publicType] = generated
        }
        return generated
    }

    interface SomeType {
        Integer getValue()

        void setValue(Integer value)
    }

    interface SpecializedType extends SomeType {}

    interface SpecializedType2 extends SomeType {}

    static class SomeTypeImpl implements SomeType {
        SomeType target

package org.gradle.internal.declarativedsl.mappingToJvm


fun interface DeclarativeRuntimePropertyGetter {
    fun getValue(receiver: Any): Any?
}


fun interface DeclarativeRuntimePropertySetter {
    fun setValue(receiver: Any, value: Any?)

    } finally {
      function = null;
    }

    /*
     * If set()/setValue() throws an Error, we let it propagate. Why? The most likely Error is a
     * StackOverflowError (from deep transform(..., directExecutor()) nesting), and calling
     * setException(stackOverflowError) would fail:
     *
     * - If the stack overflowed before set()/setValue() could even store the result in the output

        }
        if (values.size() > 1) {
            throw new IllegalStateException("Option has multiple values.");
        }
        return values.get(0);
    }

    public List<String> getValues() {
        return values;
    }

    public void addArgument(String argument) {
        values.add(argument);
    }

    public boolean hasValue() {
        return !values.isEmpty();
    }

import java.util.TreeSet;

public class ValueCollectingDiagnosticsVisitor implements DiagnosticsVisitor {
    private final TreeSet<String> values = new TreeSet<String>();

    public SortedSet<String> getValues() {
        return values;
    }

    @Override
    public DiagnosticsVisitor candidate(String displayName) {
        return this;
    }

    @Override

 */

package org.gradle.internal.reflect;

import javax.annotation.Nullable;

public interface PropertyMutator {
    String getName();

    Class<?> getType();

    void setValue(Object target, @Nullable Object value);

        tm1.addProvide("version", "1.5");
        tm1.addProvide("vendor", "sun");
        Xpp3Dom configuration1 = new Xpp3Dom("configuration");
        Xpp3Dom jdkHome1 = new Xpp3Dom("jdkHome");
        jdkHome1.setValue("${env.JAVA_HOME}");
        configuration1.addChild(jdkHome1);
        tm1.setConfiguration(configuration1);

        ToolchainModel tm2 = new ToolchainModel();
        tm1.setType("jdk");

  if (elem_type.isSignlessInteger() || elem_type.isUnsignedInteger()) {
    auto start_attr = start_tensor.getValues<IntegerAttr>()[0];
    auto limit_attr = limit_tensor.getValues<IntegerAttr>()[0];
    auto delta_attr = delta_tensor.getValues<IntegerAttr>()[0];
    int num_elements;
    if (elem_type.isUnsignedInteger()) {
      uint64_t start = start_attr.getUInt();

/**
 * Represents a Javadoc option.
 *
 * @param <T> The type which this option represents.
 */
@HasInternalProtocol
public interface OptionLessJavadocOptionFileOption<T> {
    T getValue();

    void setValue(T value);

    void write(JavadocOptionFileWriterContext writerContext) throws IOException;