return new String(c);
    }

    /**
     * Converts a long value to a hexadecimal string representation with specified padding.
     *
     * @param val the long value to convert to hexadecimal
     * @param size the desired length of the resulting hex string (will be left-padded with zeros)
     * @return a hexadecimal string representation of the value, padded to the specified size
     */

                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**
     * Converts a TermQuery to a QueryBuilder with the given boost value.
     *
     * @param context the query context
     * @param termQuery the term query to convert
     * @param boost the boost value to apply
     * @return the converted QueryBuilder
     */

      Class<@NonNull T> type, @ParametricNullness T value) {
    return trustedPut(TypeToken.of(type), value);
  }

  @Override
  @CanIgnoreReturnValue
  public <T extends B> @Nullable T putInstance(
      TypeToken<@NonNull T> type, @ParametricNullness T value) {
    return this.<T>trustedPut(type.rejectTypeVariables(), value);
  }

  /**
   * Not supported. Use {@link #putInstance} instead.
   *

        }

        val name = parameter.groups[1]?.value
        if (name == null) {
          s = parameter.range.last + 1
          continue
        }

        val token = parameter.groups[2]?.value
        val value =
          when {
            token == null -> {
              // Value is "double-quoted". That's valid and our regex group already strips the quotes.

    SerializableTester.reserializeAndAssert(Equivalence.identity());
  }

  private static class IntValue {
    private final int value;

    IntValue(int value) {
      this.value = value;
    }

    @Override
    public String toString() {
      return "value = " + value;
    }
  }

  public void testOnResultOf() {
    EquivalenceTester.of(Equivalence.equals().onResultOf(Functions.toStringFunction()))

    SerializableTester.reserializeAndAssert(Equivalence.identity());
  }

  private static class IntValue {
    private final int value;

    IntValue(int value) {
      this.value = value;
    }

    @Override
    public String toString() {
      return "value = " + value;
    }
  }

  public void testOnResultOf() {
    EquivalenceTester.of(Equivalence.equals().onResultOf(Functions.toStringFunction()))

    protected void checkEsInvalidAggregation(String name, Object value) {
        if (value == null || (value instanceof String && ((String) value).isEmpty())) {
            String msg = "Cannot register null or empty aggregation: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

        result.add(element != null ? element.value : null);
      }
      return unmodifiableList(result);
    }
  }

  /** The result of a successful {@code Future}. */
  private static final class Present<V extends @Nullable Object> {
    @ParametricNullness final V value;

    Present(@ParametricNullness V value) {
      this.value = value;
    }
  }

	if err != nil {
		return 0, 0, err
	}

	start = h.Start
	if h.IsSuffixLength {
		start = max(resourceSize+h.Start, 0)
	}
	return start, length, nil
}

// Parse a HTTP range header value into a HTTPRangeSpec
func parseRequestRangeSpec(rangeString string) (hrange *HTTPRangeSpec, err error) {
	// Return error if given range string doesn't start with byte range prefix.

    }

    @Override
    public boolean containsValue(@Nullable Object value) {
      return map.containsValue(value);
    }

    @Override
    public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
      return map.entrySet().contains(Maps.immutableEntry(key, value));
    }

    @Override
    public Set<V> get(@ParametricNullness K key) {