return t;
  }

  /** Returns {@code null} as any type, even one that does not include {@code null}. */
  @SuppressWarnings({"nullness", "TypeParameterUnusedInFormals", "ReturnMissingNullable"})
  // The warnings are legitimate. Each time we use this method, we document why.
  @ParametricNullness
  static <T extends @Nullable Object> T unsafeNull() {
    return null;
  }

  private NullnessCasts() {}

     * thread immediately fails with the same exception:
     *
     * Thread1: calls setException(), which returns true, context switch before it can CAS
     * seenExceptionsField to its exception
     *
     * Thread2: calls setException(), which returns false, CASes seenExceptionsField to its
     * exception, and wrongly believes that its exception is new (leading it to logging it when it
     * shouldn't)

     * The default returns 3000. Override in subclasses for provider-specific tuning.
     *
     * @return the maximum characters
     */
    protected int getIntentHistoryMaxChars() {
        return 3000;
    }

    /**
     * Gets the maximum characters for assistant message content in history.
     * The default returns 800. Override in subclasses for provider-specific tuning.
     *

    }

    /**
     * Returns the DCE/RPC error code associated with this exception
     *
     * @return the error code
     */
    public int getErrorCode() {
        return this.error;
    }

    /**
     *
     * @return the root cause
     * @deprecated use {@link #getCause()}
     */
    @Deprecated
    public Throwable getRootCause() {
        return getCause();
    }

  @Override
  public SampleElements<Object> samples() {
    return new Colliders();
  }

  @Override
  public Object[] createArray(int length) {
    return new Object[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<Object> order(List<Object> insertionOrder) {
    return insertionOrder;
  }

     * @return whether color styling is supported or not
     */
    boolean isColorEnabled();

    /**
     * Returns the terminal width or <code>-1</code> if not supported.
     * @return the terminal width
     */
    int getTerminalWidth();

    /**
     * Creates a new message builder.
     * @return a new message builder
     */
    @Nonnull

    assertLockHeld()
    if (executeCallCount > runCallCount) return // A thread is still starting.

    executeCallCount++
    backend.execute(this@TaskRunner, runnable)
  }

  fun newQueue(): TaskQueue {
    val name = this.withLock { nextQueueName++ }
    return TaskQueue(this, "Q$name")
  }

  /**
   * Returns a snapshot of queues that currently have tasks scheduled. The task runner does not

            return DoubleConversionUtil.toDouble(o);
        } else if (type == Long.class) {
            return LongConversionUtil.toLong(o);
        } else if (type == Float.class) {
            return FloatConversionUtil.toFloat(o);
        } else if (type == Short.class) {
            return ShortConversionUtil.toShort(o);
        } else if (type == BigInteger.class) {
            return BigIntegerConversionUtil.toBigInteger(o);

        delegate.setAddLocationInformation(addLocationInformation);
    }

    /**
     * Returns the state of the "add default entities" flag.
     *
     * @return boolean
     */
    public boolean getAddDefaultEntities() {
        return delegate.getAddDefaultEntities();
    } // -- boolean getAddDefaultEntities()

    /**
     * Sets the state of the "add default entities" flag.

  }

  /**
   * Override to return a chaining listenableFuture that returns the result of getSuccessfulResult()
   * when inputFuture returns VALID_INPUT_DATA, and sets the exception to EXCEPTION in all other
   * cases.
   */
  protected abstract ListenableFuture<T> buildChainingFuture(ListenableFuture<Integer> inputFuture);

  /**
   * Override to return the result when VALID_INPUT_DATA is passed in to the chaining