}

    @Override
    protected SortedMap<K, V> delegate() {
      return backingSortedMap;
    }

    @Override
    public boolean containsKey(Object key) {
      return standardContainsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
      return standardContainsValue(value);
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> map) {

    protected final long queryTime;

    /** Flag indicating whether the search results are partial due to timeout or other constraints. */
    protected final boolean partialResults;

    /** The facet response containing aggregated facet information for the search results. */
    protected final FacetResponse facetResponse;

    /**

    host: String,
    session: SSLSession,
  ): Boolean =
    if (!host.isAscii()) {
      false
    } else {
      try {
        verify(host, session.peerCertificates[0] as X509Certificate)
      } catch (_: SSLException) {
        false
      }
    }

  fun verify(
    host: String,
    certificate: X509Certificate,
  ): Boolean =
    when {

        if (colno >= str.length()) {
            return -1;
        }
        return str.charAt(colno++);
    }

    private void initVal() {
        sval = null;
    }

    private boolean processEOF() {
        if (peekc < 0) {
            ttype = TT_EOF;
            return true;
        }
        if (peekc == NEED_CHAR) {
            peekc = read();
            if (peekc < 0) {

  }

  static String formatCompact4Digits(double value) {
    return String.format(Locale.ROOT, "%.4g", value);
  }

  static boolean stringIsNullOrEmpty(@Nullable String string) {
    return string == null || string.isEmpty();
  }

  /**
   * Returns the string if it is not null, or an empty string otherwise.
   *

      } else {
        break
      }
    }

    return result.readUtf8()
  }

  private fun encodeLabel(
    string: String,
    pos: Int,
    limit: Int,
    result: Buffer,
  ): Boolean {
    if (!string.requiresEncode(pos, limit)) {
      result.writeUtf8(string, pos, limit)
      return true
    }

    result.write(PREFIX)

    val input = string.codePoints(pos, limit)

  @AndroidIncompatible // Android doesn't understand suites whose tests lack default constructors.
  public static TestSuite suite() {
    TestSuite suite = new TestSuite();
    for (boolean asByteSource : new boolean[] {false, true}) {
      suite.addTest(
          CharSourceTester.tests(
              "CharSource.wrap[CharSequence]",
              SourceSinkFactories.stringCharSourceFactory(),
              asByteSource));

    /** Map of loggers keyed by class */
    protected static final Map<Class<?>, Logger> loggers = newHashMap();

    /** Flag indicating initialization is complete. */
    private static boolean initialized;

    /** Logger adapter. */
    private final LoggerAdapter log;

    /**
     * Returns a {@link Logger}.
     *
     * @param clazz

    }

    /**
     * Retrieve a boolean value. If the property is not found, the value of <code>def</code> is returned.
     *
     * @param props the properties to search in
     * @param key the property key to look up
     * @param def the default value to return if key is not found
     * @return the boolean value of the property or the default value
     */

     * @return {@literal true} if the arguments are suitable for the parameter types
     */
    protected boolean isSuitable(final Class<?>[] paramTypes, final Object[] args, final boolean adjustNumber) {
        if (args == null) {
            return paramTypes.length == 0;
        }
        if (paramTypes.length != args.length) {
            return false;