return Pair[T1, T2]{f1: v1, f2: v2}
}

func (p Pair[X1, _]) First() X1 {
	return p.f1
}

func (p Pair[_, X2]) Second() X2 {
	return p.f2
}

// Deprecated: Use something else.
func Clone[S ~[]T, T any](s S) S {
	return append(S(nil), s...)

    /** All pipe instances are busy */
    int NT_STATUS_PIPE_BUSY = 0xC00000ae;
    /** No process is on the other end of the pipe */
    int NT_STATUS_PIPE_DISCONNECTED = 0xC00000b0;
    /** The pipe is being closed */
    int NT_STATUS_PIPE_CLOSING = 0xC00000b1;
    /** Waiting for a process to open the other end of the pipe */
    int NT_STATUS_PIPE_LISTENING = 0xC00000b3;
    /** The file that was specified is a directory */

    }
  }

  /*
   * Notes on EnumSet and <E extends Enum<E>>:
   *
   * This class isn't an arbitrary ForwardingImmutableSet because we need to
   * know that calling {@code clone()} during deserialization will return an
   * object that no one else has a reference to, allowing us to guarantee
   * immutability. Hence, we support only {@link EnumSet}.
   */
  private final transient EnumSet<E> delegate;

        this.since = since;
    }

    /**
     * Creates a shallow copy of this parameter.
     */
    @Override
    public Parameter clone() {
        try {
            return (Parameter) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new UnsupportedOperationException(e);
        }
    }

import org.apache.maven.artifact.ArtifactScopeEnum;

/**
 * Default conflict resolver.Implements closer newer first policy by default, but could be configured via plexus
 *
 */
@Named
@Singleton
@Deprecated
public class DefaultGraphConflictResolver implements GraphConflictResolver {
    /**
     * artifact, closer to the entry point, is selected
     */
    @Inject
    protected GraphConflictResolutionPolicy policy;

      } catch (Throwable t) {
        threadUnexpectedException(t);
        return null;
      }
    }
  }

  <T> T serialClone(T o) {
    T clone = reserialize(o);
    assertThat(clone.getClass()).isEqualTo(o.getClass());
    return clone;
  }

 */
class AddressPolicy(
  /**
   * How many concurrent calls should be possible to make at any time.
   * The pool will routinely try to pre-emptively open connections to satisfy this minimum.
   * Connections will still be closed if they idle beyond the keep-alive but will be replaced.
   */
  @JvmField val minimumConcurrentCalls: Int = 0,
  /** How long to wait to retry pre-emptive connection attempts that fail. */

      for (inputHeader in headers) {
        val (key, value) = inputHeader.entries.iterator().next()
        result.add(Header(key, value))
      }
      return result
    }

  public override fun clone() = Case(seqno, this.wire, headers)

@NullUnmarked
public class PowerSetBenchmark {
  @Param({"2", "4", "8", "16"})
  int elements;

  Set<Set<Integer>> powerSet;

  @BeforeExperiment
  void setUp() {
    Set<Integer> set = ContiguousSet.create(Range.closed(1, elements), integers());
    powerSet = Sets.powerSet(set);
  }

  @Benchmark
  int iteration(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Set<Integer> subset : powerSet) {

}

// Enabled returns if LDAP is enabled.
func (l *Config) Enabled() bool {
	return l.LDAP.Enabled
}

// Clone returns a cloned copy of LDAP config.
func (l *Config) Clone() Config {
	if l == nil {
		return Config{}
	}
	cfg := Config{
		LDAP:              l.LDAP.Clone(),
		stsExpiryDuration: l.stsExpiryDuration,
	}
	return cfg
}

// LDAP keys and envs.
const (