{"VMOVD", testvmovd, 0x7040201008040201, 0},
		{"VMOVQ", testvmovq, 0x7040201008040201, 0x3040201008040201},
	}
	for _, test := range tests {
		gotA, gotB := test.vmovFunc()
		if gotA != test.wantA || gotB != test.wantB {
			t.Errorf("%v: got: a=0x%x, b=0x%x, want: a=0x%x, b=0x%x", test.op, gotA, gotB, test.wantA, test.wantB)
		}
	}
}

func testmovk() uint64

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

//go:build plan9

package os

import (
	"internal/itoa"
	"syscall"
)

func executable() (string, error) {
	fn := "/proc/" + itoa.Itoa(Getpid()) + "/text"
	f, err := Open(fn)
	if err != nil {
		return "", err
	}
	defer f.Close()
	return syscall.Fd2path(int(f.Fd()))

// TCP socket options for plan9

package net

import (
	"internal/itoa"
	"syscall"
	"time"
)

func setNoDelay(_ *netFD, _ bool) error {
	return syscall.EPLAN9
}

// Set keep alive period.
func setKeepAliveIdle(fd *netFD, d time.Duration) error {
	if d < 0 {
		return nil
	}

	cmd := "keepalive " + itoa.Itoa(int(d/time.Millisecond))
	_, e := fd.ctl.WriteAt([]byte(cmd), 0)
	return e
}

	for {
		v := <-right
		stdio.Stdout.WriteString(strconv.Itoa(v) + "\n")
		left <- 1 + v
	}
}

func main() {
	leftmost := make(chan int)
	var left chan int
	right := leftmost
	for i := 0; i < N; i++ {
		left, right = right, make(chan int)
		go link(left, right)
	}
	for i := 0; i < R; i++ {
		right <- 0
		x := <-leftmost
		stdio.Stdout.WriteString(strconv.Itoa(x) + "\n")
	}

// type StringInt[T Ints] T
//
// //go:noinline
// func (m StringInt[T]) String() string {
// 	return strconv.Itoa(int(m))
// }

type StringStruct[T Ints] struct {
	f T
}

func (m StringStruct[T]) String() string {
	return strconv.Itoa(int(m.f))
}

func main() {
	x := []myint{myint(1), myint(2), myint(3)}

func mapper[F, T any](s []F, f func(F) T) []T {
	r := make([]T, len(s))
	for i, v := range s {
		r[i] = f(v)
	}
	return r
}

func main() {
	got := mapper([]int{1, 2, 3}, strconv.Itoa)
	want := []string{"1", "2", "3"}
	if !reflect.DeepEqual(got, want) {
		panic(fmt.Sprintf("got %s, want %s", got, want))
	}

	fgot := mapper([]float64{2.5, 2.3, 3.5}, func(f float64) string {

// invalid code point, the conversion cannot be statically rejected.
//
// For conversions that intend on using the code point, consider replacing them
// with string(rune(x)). Otherwise, strconv.Itoa and its equivalents return the
// string representation of the value in the desired base.

	}
	if state.goarch != a.state.goarch {
		a.state.goarch = ""
	}
}

func (a *argstate) ArgsSummary() map[string]string {
	m := make(map[string]string)
	if len(a.state.osargs) != 0 {
		m["argc"] = strconv.Itoa(len(a.state.osargs))
		for k, a := range a.state.osargs {
			m[fmt.Sprintf("argv%d", k)] = a
		}
	}
	if a.state.goos != "" {
		m["GOOS"] = a.state.goos
	}
	if a.state.goarch != "" {

	})
	if err == syscall.ENOENT || (err == nil && !found) {
		return nil, UnknownGroupIdError(strconv.Itoa(gid))
	}
	if err != nil {
		return nil, fmt.Errorf("user: lookup groupid %d: %v", gid, err)
	}
	return buildGroup(&grp), nil
}

func buildGroup(grp *_C_struct_group) *Group {
	g := &Group{
		Gid:  strconv.Itoa(int(_C_gr_gid(grp))),
		Name: _C_GoString(_C_gr_name(grp)),
	}
	return g
}

	enc [28 + 32]uint32
	dec [28 + 32]uint32
}

type KeySizeError int

func (k KeySizeError) Error() string {
	return "crypto/aes: invalid key size " + strconv.Itoa(int(k))
}

// NewCipher creates and returns a new [cipher.Block].
// The key argument should be the AES key,
// either 16, 24, or 32 bytes to select
// AES-128, AES-192, or AES-256.