for _, mode := range []string{"noalias", "aliasX", "aliasY"} {
		t.Run(mode, func(t *testing.T) {
			for _, tt := range subMod2NTests {
				x0 := natFromString(tt.x)
				y0 := natFromString(tt.y)
				want := natFromString(tt.z)
				x := nat(nil).set(x0)
				y := nat(nil).set(y0)
				var z nat
				switch mode {
				case "aliasX":
					z = x
				case "aliasY":
					z = y
				}

	Alias8  = SliceFlag[[8]int]
	Alias9  = SliceFlag[[9]int]
	Alias10 = SliceFlag[[10]int]
	Alias11 = SliceFlag[[11]int]
	Alias12 = SliceFlag[[12]int]
	Alias13 = SliceFlag[[13]int]
	Alias14 = SliceFlag[[14]int]
	Alias15 = SliceFlag[[15]int]
	Alias16 = SliceFlag[[16]int]
	Alias17 = SliceFlag[[17]int]
	Alias18 = SliceFlag[[18]int]
	Alias19 = SliceFlag[[19]int]
	Alias20 = SliceFlag[[20]int]
)

// If a is not an instance of a generic alias, the result is nil.
func (a *Alias) TypeArgs() *TypeList { return a.targs }

// Rhs returns the type R on the right-hand side of an alias
// declaration "type A = R", which may be another alias.
func (a *Alias) Rhs() Type { return a.fromRHS }

// Unalias returns t if it is not an alias type;
// otherwise it follows t's alias chain until it

	actual  Type           // actual (aliased) type; never an alias
}

// NewAlias creates a new Alias type with the given type name and rhs.
// rhs must not be nil.
func NewAlias(obj *TypeName, rhs Type) *Alias {
	alias := (*Checker)(nil).newAlias(obj, rhs)
	// Ensure that alias.actual is set (#65455).
	alias.cleanup()
	return alias
}

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

package aliases

import (
	"go/token"
	"go/types"
)

// Package aliases defines backward compatible shims
// for the types.Alias type representation added in 1.22.
// This defines placeholders for x/tools until 1.26.

// NewAlias creates a new TypeName in Package pkg that
// is an alias for the type rhs.
//

package aliases

type (
	T0 [10]int
	T1 []byte
	T2 struct {
		x int
	}
	T3 interface {
		m() T2
	}
	T4 func(int, T0) chan T2
)

// basic aliases
type (
	Ai = int
	A0 = T0
	A1 = T1
	A2 = T2
	A3 = T3
	A4 = T4

	A10 = [10]int
	A11 = []byte
	A12 = struct {
		x int
	}
	A13 = interface {
		m() A2
	}
	A14 = func(int, A0) chan A2
)

// alias receiver types

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

// Test basic restrictions on type aliases.

package p

import (
	"reflect"
	. "reflect"
)

type T0 struct{}

// Valid type alias declarations.

type _ = T0
type _ = int
type _ = struct{}
type _ = reflect.Value
type _ = Value

type (
	A0 = T0
	A1 = int

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package alias implements memory aliasing tests.
// This code also exists as golang.org/x/crypto/internal/alias.
package alias

import "unsafe"

// AnyOverlap reports whether x and y share memory at any (not necessarily
// corresponding) index. The memory beyond the slice length is ignored.

# See the License for the specific language governing permissions and
# limitations under the License.

# This script verifies that all the imports have our preferred alias(es). The
# preferred aliases for imports are listed in `hack/.import-aliases`.
# Usage: `hack/verify-import-aliases.sh`.

set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
source "${KUBE_ROOT}/hack/lib/init.sh"

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !purego

// Package alias implements memory aliasing tests.
package alias

import "unsafe"

// AnyOverlap reports whether x and y share memory at any (not necessarily
// corresponding) index. The memory beyond the slice length is ignored.
func AnyOverlap(x, y []byte) bool {