// List all kvs
	marker := ""
	for {
		res, err := objAPI.ListObjects(ctx, minioMetaBucket, minioConfigHistoryPrefix, marker, "", maxObjectList)
		if err != nil {
			return nil, err
		}
		for _, obj := range res.Objects {
			cfgEntry := madmin.ConfigHistoryEntry{
				RestoreID:  strings.TrimSuffix(path.Base(obj.Name), kvPrefix),
				CreateTime: obj.ModTime, // ModTime is createTime for config history entries.
			}
			if withData {

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            CombinationItem that = (CombinationItem) o;
            return Objects.equals(stringPart, that.stringPart) && Objects.equals(digitPart, that.digitPart);
        }

  private static <T> T newProxy(Class<T> interfaceType, InvocationHandler handler) {
    Object object =
        Proxy.newProxyInstance(
            interfaceType.getClassLoader(), new Class<?>[] {interfaceType}, handler);
    return interfaceType.cast(object);
  }

  @ParametricNullness
  private <T extends @Nullable Object> T callWithTimeout(

 *       (in a way that affects its {@link Object#equals} behavior) while it is contained in a
 *       collection. Undefined behavior and bugs will result. It's generally best to avoid using
 *       mutable objects as elements at all, as many users may expect your "immutable" object to be
 *       <i>deeply</i> immutable.
 * </ul>
 *
 * <h4>Performance notes</h4>
 *
 * <ul>

    private static final Map<ByteBuffer, Long> bufferAddresses = new ConcurrentHashMap<>();

    // DiSNI objects - would be actual DiSNI types in real implementation
    private final Object endpoint; // RdmaActiveEndpoint
    private Object memoryRegister; // IbvMr (memory register)

    /**
     * Create new DiSNI memory region
     *
     * @param buffer memory buffer to register

     */
    @SuppressWarnings("unchecked")
    public static Map<String, Object> getMap(final Map<String, Object> map, final String key) {
        final Object value = map.get(key);
        if (value instanceof Map) {
            return (Map<String, Object>) value;
        }
        return null;
    }

    /**

    }
    return false;
  }

  @Override
  public int hashCode() {
    return Objects.hashCode(function, resultEquivalence);
  }

  @Override
  public String toString() {
    return resultEquivalence + ".onResultOf(" + function + ")";
  }

            // Helper method for nested map handling
        }
    }

    // ScriptEngine implementation that returns objects
    private static class ObjectReturningScriptEngine implements ScriptEngine {
        @Override
        public Object evaluate(String template, Map<String, Object> paramMap) {
            if ("return object".equals(template)) {

    private final Object keys;
    private final Object values;

    SerializedForm(ImmutableMap<K, V> map) {
      if (USE_LEGACY_SERIALIZATION) {
        Object[] keys = new Object[map.size()];
        Object[] values = new Object[map.size()];
        int i = 0;
        // "extends Object" works around https://github.com/typetools/checker-framework/issues/3013

   * example, {@code [] < [0x01] < [0x01, 0x7F] < [0x01, 0x80] < [0x02]}. Values are treated as
   * unsigned.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link
   * java.util.Arrays#equals(byte[], byte[])}.
   *
   * <p><b>Java 9+ users:</b> Use {@link Arrays#compareUnsigned(byte[], byte[])