with `mask_zero=True` to automatically infer a correct padding mask.
        *   Added a `use_causal_mask` call time argument to the layer. Passing
            `use_causal_mask=True` will compute a causal attention mask, and
            optionally combine it with any `attention_mask` passed in directly
            when calling the layer.

      }
    }

    final boolean wasInterrupted;
    @CheckForNull final Throwable cause;

    Cancellation(boolean wasInterrupted, @CheckForNull Throwable cause) {
      this.wasInterrupted = wasInterrupted;
      this.cause = cause;
    }
  }

  /** A special value that encodes the 'setFuture' state. */

   *
   * <ul>
   *   <li>Any {@link ExecutionException} has its <i>cause</i> wrapped in an {@link
   *       UncheckedExecutionException} (if the cause is an {@code Exception}) or {@link
   *       ExecutionError} (if the cause is an {@code Error}).
   *   <li>Any {@link InterruptedException} causes a retry of the {@code get} call. The interrupt is
   *       restored before {@code getUnchecked} returns.

irrevocably and unconditionally waives, abandons, and surrenders all of
Affirmer's Copyright and Related Rights and associated claims and causes
of action, whether now known or unknown (including existing as well as
future claims and causes of action), in the Work (i) in all territories
worldwide, (ii) for the maximum duration provided by applicable law or

The [DNSError] type now wraps errors caused by timeouts or cancelation.
For example, `errors.Is(someDNSErr, context.DeadlineExceedeed)`

        } catch (ComponentLookupException e) {
            Throwable cause = e.getCause();
            while (cause != null && !(cause instanceof LinkageError) && !(cause instanceof ClassNotFoundException)) {
                cause = cause.getCause();
            }

            if ((cause instanceof NoClassDefFoundError) || (cause instanceof ClassNotFoundException)) {

    }

    /**
     * Creates a new exception with specified cause
     *
     * @param cause
     * @param groupId
     * @param artifactId
     * @param version
     */
    public ModelResolverException(Throwable cause, String groupId, String artifactId, String version) {
        super(cause);
        this.groupId = groupId;
        this.artifactId = artifactId;
        this.version = version;

    try {
      dns.lookup("google.com")
      fail<Any>()
    } catch (ioe: IOException) {
      assertThat(ioe.message).isEqualTo("google.com")
      val cause = ioe.cause!!
      assertThat(cause).isInstanceOf<IOException>()
      assertThat(cause).hasMessage("response size exceeds limit (65536 bytes): 65537 bytes")
    }
  }

  @Test
  fun failOnBadResponse() {
    server.enqueue(dnsResponse("00"))

// modified accidentally or maliciously.
type Error struct {
	msg   string
	cause error
}

// Errorf - formats according to a format specifier and returns
// the string as a value that satisfies error of type crypto.Error
func Errorf(format string, a ...interface{}) error {
	e := fmt.Errorf(format, a...)
	ee := Error{}
	ee.msg = e.Error()
	ee.cause = errors.Unwrap(e)
	return ee
}

// Unwrap the internal error.

    The new behavior strips invalid characters like `"` and `{` from the hostname before converting.

 *  Fix: Undo a performance regression introduced in OkHttp 4.0 caused by differences in behavior
    between Kotlin's `assert()` and Java's `assert()`. (Kotlin always evaluates the argument; Java
    only does when assertions are enabled.)