return right;
    }

    public static <L, R> Pair<L, R> of(@Nullable L left, @Nullable R right) {
        return new Pair<L, R>(left, right);
    }

    public <T> Pair<T, Pair<L, R>> pushLeft(T t) {
        return of(t, this);
    }

    public <T> Pair<Pair<L, R>, T> pushRight(T t) {
        return of(this, t);
    }

    public <T> Pair<Pair<T, L>, R> nestLeft(T t) {
        return of(of(t, left), right);

     */
    public static <T1, T2> Pair<T1, T2> pair(final T1 first, final T2 second) {
        return new Pair<>(first, second);
    }

    /**
     * インスタンスを構築します。
     */
    public Pair() {
    }

    /**
     * インスタンスを構築します。
     *
     * @param first
     *            1番目の値
     * @param second
     *            2番目の値
     */
    public Pair(final T1 first, final T2 second) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"unsafe"
)

type pair[F1, F2 any] struct {
	f1 F1
	f2 F2
}

func main() {
	p := pair[int32, int64]{1, 2}
	if got, want := unsafe.Sizeof(p.f1), uintptr(4); got != want {
		panic(fmt.Sprintf("unexpected f1 size == %d, want %d", got, want))
	}

	sink = box.pair
}

func sinkAfterSelfAssignment3(box *BoxedPair) { // ERROR "leaking param content: box"
	box.pair.p1 = box.pair.p2 // ERROR "ignoring self-assignment in box.pair.p1 = box.pair.p2"
	leakParam(box.pair.p2)
}

func sinkAfterSelfAssignment4(box *BoxedPair) { // ERROR "leaking param content: box"

package http

// A mapping is a collection of key-value pairs where the keys are unique.
// A zero mapping is empty and ready to use.
// A mapping tries to pick a representation that makes [mapping.find] most efficient.
type mapping[K comparable, V any] struct {
	s []entry[K, V] // for few pairs
	m map[K]V       // for many pairs
}

type entry[K comparable, V any] struct {
	key   K
	value V
}

        if ( pairs == null ) {
            return false;
        }
        for ( AvPair p : pairs ) {
            if ( p.getType() == type ) {
                return true;
            }
        }
        return false;
    }


    /**
     * 
     * @param pairs
     * @param type
     * @return first occurance of the given type
     */

        final Map<String, List<String>> paramListMap = new HashMap<>();
        final String[] pairs = queryString.split("&");
        try {
            for (final String pair : pairs) {
                final int pos = pair.indexOf('=');
                if (pos >= 0) {
                    final String key = urlCodec.decode(pair.substring(0, pos), enc);
                    List<String> list = paramListMap.get(key);

    assertThat(headers["e"]).isNull()
  }

  @Test fun iteratorOperator() {
    val headers = headersOf("a", "b", "c", "d")

    val pairs = mutableListOf<Pair<String, String>>()
    for ((name, value) in headers) {
      pairs += name to value
    }

    assertThat(pairs).containsExactly("a" to "b", "c" to "d")
  }

  @Test fun builderGetOperator() {
    val builder = Headers.Builder()
    builder.add("a", "b")

// license that can be found in the LICENSE file.

package diff

import (
	"bytes"
	"fmt"
	"sort"
	"strings"
)

// A pair is a pair of values tracked for both the x and y side of a diff.
// It is typically a pair of line indexes.
type pair struct{ x, y int }

// Diff returns an anchored diff of the two texts old and new
// in the “unified diff” format. If old and new are identical,

     * of mutually exclusive options to the {@link TaskOptions#mutuallyExclusiveOptions taskOptions} argument.
     */
    private static Map<String, OptionDescriptor> generateOppositeOptions(Object target, Map<String, OptionDescriptor> options, TaskOptions taskOptions) {
        Map<String, OptionDescriptor> oppositeOptions = new HashMap<>();