// * qn = quantized value for tensor n
// * sn = scale for tensor n
// * zn = zero point for tensor n
//
// r3 = r1 * r2
//    = s1 (q1 - z1) * s2 (q2 - z2)
//    = s1 s2 (q1 q2 - q1 z2 - q2 z1 + z1 z2)
//
// * z2 is zero, because it assumes symmetric quantization for the filter:
//
//    = s1 s2 (q1 q2 - q2 z1)
//
// In StableHLO text representation, the pattern is as the following
// (simplified):
//
// ```

	c := buildTestController(t, false)
	c.AddSecret("s0", "c0")
	c.AddSecret("s1", "c1")
	c.Run(stop)

	// before sync
	assert.EventuallyEqual(t, c.controller.ListRemoteClusters, []cluster.DebugInfo{
		{ID: "config", SyncStatus: "syncing"},
		{ID: "c0", SecretName: "istio-system/s0", SyncStatus: "syncing"},
		{ID: "c1", SecretName: "istio-system/s1", SyncStatus: "syncing"},
	})

    public val expression: KtExpression by validityAsserted(expression)

    /**
     * Whether safe navigation is used on this receiver. For example
     * ```
     * fun test(s1: String?, s2: String) {
     *   s1?.length // explicit receiver `s1` has `isSafeNavigation = true`
     *   s2.length // explicit receiver `s2` has `isSafeNavigation = false`
     * }
     * ```
     */

	_ = b[2]
	// arm64:`MOVH\sR[0-9]+,\s1\(R[0-9]+\)`,-`MOVB`
	// 386:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`
	// amd64:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`
	// ppc64le:`MOVH\s`,-`MOVB`
	// ppc64:`MOVHBR`,-`MOVB`
	b[1], b[2] = byte(val), byte(val>>8)
}

func store_le_byte_2_inv(b []byte, val uint16) {
	_ = b[2]
	// 386:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`
	// amd64:`MOVW\s[A-Z]+,\s1\([A-Z]+\)`,-`MOVB`

        "s1"                  | { property().tap { add("s1") } }               || "$collectionName(class ${String.name}, [s1])"
        "[s1, s2]"            | { property().value(["s1, s2"]) }               || "$collectionName(class ${String.name}, [s1, s2])"
        "s1 + s2"             | { property().tap { add("s1"); add("s2") } }    || "$collectionName(class ${String.name}, [s1] + [s2])"

	s11 = &v
	s12 = -(u + *t11) / *&v
	s13 = a /* ERROR "shifted operand" */ << d
	s14 = i << j
	s18 = math.Pi * 10.0
	s19 = s1 /* ERROR "cannot call" */ ()
 	s20 = f0 /* ERROR "no value" */ ()
	s21 = f6(1, s1, i)
	s22 = f6(1, s1, uu /* ERRORx `cannot use .* in argument` */ )

	t1 int = i + j
	t2 int = i /* ERROR "mismatched types" */ + x
	t3 int = c /* ERRORx `cannot use .* variable declaration` */ + d
	t4 string = s + t

	MinioEnv   map[string]string
}

// Diff - returns error on first difference found in two configs.
func (s1 *ServerSystemConfig) Diff(s2 *ServerSystemConfig) error {
	ns1 := s1.NEndpoints
	ns2 := s2.NEndpoints
	if ns1 != ns2 {
		return fmt.Errorf("Expected number of endpoints %d, seen %d", ns1, ns2)
	}

	for i, cmdLine := range s1.CmdLines {
		if cmdLine != s2.CmdLines[i] {

}

// make

func m1[
	S1 interface{ []int },
	S2 interface{ []int | chan int },

	M1 interface{ map[string]int },
	M2 interface{ map[string]int | chan int },

	C1 interface{ chan int },
	C2 interface{ chan int | chan string },
]() {
	type m1S0 []int
	type m1M0 map[string]int
	type m1C0 chan int

	_ = make([]int, 10)
	_ = make(m1S0, 10)
	_ = make(S1, 10)
	_ = make(S1, 10, 20)

// Floating point NaNs are not considered equal.
func Equal[E comparable](s1, s2 []E) bool {
	return slices.Equal(s1, s2)
}

// EqualUnordered reports whether two slices are equal, ignoring order
func EqualUnordered[E comparable](s1, s2 []E) bool {
	if len(s1) != len(s2) {
		return false
	}
	first := make(map[E]struct{}, len(s1))
	for _, c := range s1 {
		first[c] = struct{}{}
	}
	for _, c := range s2 {

    %3 = stablehlo.constant dense<4> : tensor<1x1x3xi32>  // Precalculated q2 * z1.
    %4 = stablehlo.constant dense<3.000000e+03> : tensor<1x1x3xf32>  // Merged scale: s1 * s2.
    %5 = stablehlo.constant dense<2.000000e+02> : tensor<1x1x1xf32>  // Output inverse scale.
    %6 = stablehlo.constant dense<2> : tensor<1x1x1xi8>  // Output zero point.