return new Builder<K, V>(Ordering.natural())
        .put(k1, v1)
        .put(k2, v2)
        .put(k3, v3)
        .put(k4, v4)
        .put(k5, v5)
        .build();
  }

  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(
      K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6) {

	var v1_ func() int
	_ = v1_
	v1_ = f1 // ERROR "cannot infer P"
	v2 = f2  // ERROR "cannot infer P"

	v3 = f1
	v4 = f2
	v5 = f3
	v5 = f3[int]

	v6 = f4
	v7 = f4 // ERROR "inferred type func(int, int) for func(P, P) does not match type func(int, string) of v7"
	v8 = f5

                    { "module": "m4", "endorseStrictVersions": true, "version": { "strictly": "v5" }, "group": "g4"},
                    { "module": "m5", "version": { "prefers": "v5", "requires": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},
                    { "module": "m6", "group": "g6", "version": { "strictly": "v6" }, "reason": "v5 is buggy"}
                ],
                "name": "runtime"
            }
        ]
    }

  const T3 v3_;
  const T4 v4_;
};

template <typename T1, typename T2, typename T3, typename T4, typename T5>
class ValueArray5 {
 public:
  ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),
      v4_(v4), v5_(v5) {}

  template <typename T>
  operator ParamGenerator<T>() const {
    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),

        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
      - uses: actions/checkout@v4
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.11"
          # Issue ref: https://github.com/actions/setup-python/issues/436
          # cache: "pip"
          # cache-dependency-path: pyproject.toml

	// check that v2, v3, v4 is sorted after v5
	var ai, bi, ci, si int
	for i, v := range order {
		switch v.ID {
		case 2:
			ai = i
		case 3:
			bi = i
		case 4:
			ci = i
		case 5:
			si = i
		}
	}
	if ai < si || bi < si || ci < si {
		t.Logf("Func: %s", fun.f)
		t.Errorf("store order is wrong: got %v, want v2 v3 v4 after v5", order)
	}
}

            it
        }
        source.addPendingCollection(provider4)
        def provider5 = propertyFactory.listProperty(String).with {
            it.add(Providers.of("v5").withSideEffect(sideEffect5))
            it
        }
        source.addPendingCollection(provider5)

        then:
        0 * _ // no side effects until elements are realized

        when:

	// adds support for exit codes.
	StreamProtocolV4Name = "v4.channel.k8s.io"

	// The subprotocol "v5.channel.k8s.io" is used for remote command
	// attachment/execution. It is the 5th version of the subprotocol and
	// adds support for a CLOSE signal.
	StreamProtocolV5Name = "v5.channel.k8s.io"

	NonZeroExitCodeReason = metav1.StatusReason("NonZeroExitCode")
	ExitCodeCauseType     = metav1.CauseType("ExitCode")

	VLEG	$0, 48(R9), V18
	WFADB	V3, V5, V6
	LGDR	F3, R2
	WFMSDB	V2, V16, V6, V16
	FMOVD	40(R9), F1
	WFMADB	V2, V4, V16, V4
	FMOVD	32(R9), F7
	WFMDB	V4, V4, V3
	WFMADB	V4, V1, V20, V1
	WFMADB	V4, V7, V18, V7
	VLEG	$0, 24(R9), V16
	WFMADB	V1, V3, V7, V1
	FMOVD	16(R9), F5
	WFMADB	V4, V5, V16, V5
	RISBGZ	$57, $60, $3, R2, R4
	WFMADB	V3, V1, V5, V1
	MOVD	$·powtexp<>+0(SB), R3

	var v3 Tstruct[int]
	if got, want := unsafe.Offsetof(v3.f2), unsafe.Sizeof(v1); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	var v4 Tstruct[interface{}]
	var v5 interface{}
	if got, want := unsafe.Offsetof(v4.f2), unsafe.Sizeof(v5); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	if got, want := v3.offset(), unsafe.Offsetof(v3.f2); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))