panic("uint8 != byte")
	}

	rune32 := false
	x = rune(3)
	switch x.(type) {
	case int:
		// ok
	case int32:
		// must be new code
		rune32 = true
	default:
		panic("rune != int and rune != int32")
	}

	if rune32 {
		x = int32(4)
	} else {
		x = int(5)
	}
	switch x.(type) {
	case rune:
		// ok
	default:
		panic("int (or int32) != rune")
	}

	checkRunes([]rune(mystring("")), `[]rune(mystring(""))`)
	checkRunes(myrunes(""), `myrunes("")`)
	checkRunes(myrunes(mystring("")), `myrunes(mystring(""))`)

Kuat <******@****.***> 1711363165 -0700

	if err != nil {
		t.Fatal(err)
	}
	if n != 3 {
		t.Fatalf("expected 3 items consumed, got %d", n)
	}
	if a.rune != '1' || b.rune != '2' || c.rune != '➂' {
		t.Errorf("bad scan rune: %q %q %q should be '1' '2' '➂'", a.rune, b.rune, c.rune)
	}
	if a.size != 1 || b.size != 1 || c.size != 3 {
		t.Errorf("bad scan size: %q %q %q should be 1 1 3", a.size, b.size, c.size)
	}
}

// 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 p

type T string

var (
	t = T("T")
	r = []rune(t)

	case OpLiteral:
		for _, r := range re.Rune {
			escape(b, r, false)
		}
	case OpCharClass:
		if len(re.Rune)%2 != 0 {
			b.WriteString(`[invalid char class]`)
			break
		}
		b.WriteRune('[')
		if len(re.Rune) == 0 {
			b.WriteString(`^\x00-\x{10FFFF}`)
		} else if re.Rune[0] == 0 && re.Rune[len(re.Rune)-1] == unicode.MaxRune && len(re.Rune) > 2 {
			// Contains 0 and MaxRune. Probably a negated class.

	"strings"
	"sync"
	"time"

	libcontainercgroups "github.com/opencontainers/runc/libcontainer/cgroups"
	"github.com/opencontainers/runc/libcontainer/cgroups/fscommon"
	"github.com/opencontainers/runc/libcontainer/cgroups/manager"
	cgroupsystemd "github.com/opencontainers/runc/libcontainer/cgroups/systemd"
	libcontainerconfigs "github.com/opencontainers/runc/libcontainer/configs"
	v1 "k8s.io/api/core/v1"
	"k8s.io/klog/v2"

// Copyright 2024 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 main

import (
	"./a"
	"reflect"
)

var s = []rune{0, 1, 2, 3}

func main() {
	m := map[any]int{}
	k := reflect.New(reflect.ArrayOf(4, reflect.TypeOf(int32(0)))).Elem().Interface()
	m[k] = 1
	a.F()

// run

// Copyright 2023 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 main

func g[P any](...P) P { var zero P; return zero }

var (
	_ int        = g(1, 2)
	_ rune       = g(1, 'a')
	_ float64    = g(1, 'a', 2.3)
	_ float64    = g('a', 2.3)
	_ complex128 = g(2.3, 'a', 1i)
)

	_ [float64(10)]int                // ERROR "invalid array bound|must be integer"
	_ [10 + 0i]int
	_ [complex(10, 0)]int
	_ [complex128(complex(10, 0))]int // ERROR "invalid array bound|must be integer"
	_ ['a']int
	_ [rune(65)]int