Entity authorized to submit on behalf of the copyright owner. For the 
purposes of this definition, "submitted" means any form of electronic, 
verbal, or written communication sent to the Licensor or its 
representatives, including but not limited to communication on electronic 
mailing lists, source code control systems, and issue tracking systems that 
are managed by, or on behalf of, the Licensor for the purpose of discussing 

    private final CoreExtension extension;

    public ExtensionResolutionException(CoreExtension extension, Throwable cause) {
        super(
                "Extension " + extension.getId() + " or one of its dependencies could not be resolved: "
                        + cause.getMessage(),
                cause);
        this.extension = extension;
    }

    public CoreExtension getExtension() {
        return extension;

import com.google.common.annotations.GwtCompatible;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NavigableSet;
import org.jspecify.annotations.Nullable;

/**
 * A sorted multiset which forwards all its method calls to another sorted multiset. Subclasses
 * should override one or more methods to modify the behavior of the backing multiset as desired per
 * the <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.

func (p *Parser) getRegister(prog *obj.Prog, op obj.As, addr *obj.Addr) int16 {
	if addr.Type != obj.TYPE_REG || addr.Offset != 0 || addr.Name != 0 || addr.Index != 0 {
		p.errorf("%s: expected register; found %s", op, obj.Dconv(prog, addr))
	}
	return addr.Reg
}

// getSpecial checks that addr represents a special operand and returns its value.

     *
     * @return the value type if the return type of the method is a parameterized {@link Map}, otherwise {@literal null}
     */
    Class<?> getValueClassOfMap();

    /**
     * Invokes the method and returns its result.
     *
     * @param <T>
     *            the return type of the method
     * @param target
     *            the target object. Must not be {@literal null}
     * @param args

If the nested type is a managed type (Gradle can generate its implementation), you can define a nested property with:
```
interface NestedType {
    Property<String> getSomeProperty()
}
class Example {
    @Nested
    NestedType getNestedProperty()
}
```

 *
 * <ul>
 *   <li>{@link #reset} is called (removing the data in this stream and deleting the file), or...
 *   <li>this stream (or, more precisely, its {@link #asByteSource} view) is garbage collected,
 *       <strong>AND</strong> this stream was constructed with {@linkplain
 *       #FileBackedOutputStream(int, boolean) the two-arg constructor} with {@code true} for the

	if sepIndex == -1 {
		return nil, fmt.Errorf("'%s' does not have a valid range value", rangeString)
	}

	offsetBeginString := byteRangeString[:sepIndex]
	offsetBegin := int64(-1)
	// Convert offsetBeginString only if its not empty.
	if len(offsetBeginString) > 0 {
		if offsetBeginString[0] == '+' {
			return nil, fmt.Errorf("Byte position ('%s') must not have a sign", offsetBeginString)

// errDiskFull - cannot create volume or files when disk is full.
var errDiskFull = StorageErr("drive path full")

// errDiskNotDir - cannot use storage disk if its not a directory
var errDiskNotDir = StorageErr("drive is not directory or mountpoint")

// errDiskNotFound - cannot find the underlying configured disk anymore.
var errDiskNotFound = StorageErr("drive not found")

 public:
  using GradientTape<AbstractTensorHandle, GradientFunction,
                     TapeTensor>::GradientTape;
  // Returns whether the tape is persistent, i.e., whether the tape will hold
  // onto its internal state after a call to `ComputeGradient`.
  using GradientTape<AbstractTensorHandle, GradientFunction,
                     TapeTensor>::IsPersistent;

  // Adds this tensor to the list of watched tensors.
  //