//	}
	SLL	R1, R2, R3	// 00221804
	SLLV	R10, R22, R21	// 0156a814
	SRL	R27, R6, R17	// 03668806
	SRLV	R27, R6, R17	// 03668816
	SRA	R11, R19, R20	// 0173a007
	SRAV	R20, R19, R19	// 02939817
	ROTR	R19, R18, R20	// 0272a046
	ROTRV	R9, R13, R16	// 012d8056

//	LSHW rreg ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	SLL	R1, R2		// 00221004
	SLLV	R10, R22	// 0156b014
	SRL	R27, R6   	// 03663006

		context = ctxExpr
	}
	if context == ctxEmbedType {
		error_(sel.Pos(), "cannot embed C type")
	}
	goname := sel.Sel.Name
	if goname == "errno" {
		error_(sel.Pos(), "cannot refer to errno directly; see documentation")
		return
	}
	if goname == "_CMalloc" {
		error_(sel.Pos(), "cannot refer to C._CMalloc; use C.malloc")
		return
	}
	if goname == "malloc" {
		goname = "_CMalloc"
	}

pkg syscall (netbsd-arm64-cgo), const RUSAGE_CHILDREN = -1
pkg syscall (netbsd-arm64-cgo), const RUSAGE_CHILDREN ideal-int
pkg syscall (netbsd-arm64-cgo), const RUSAGE_SELF = 0
pkg syscall (netbsd-arm64-cgo), const RUSAGE_SELF ideal-int
pkg syscall (netbsd-arm64-cgo), const S_ARCH1 = 65536
pkg syscall (netbsd-arm64-cgo), const S_ARCH1 ideal-int
pkg syscall (netbsd-arm64-cgo), const S_ARCH2 = 131072

// one.

import (
	"bytes"
	"debug/elf"
	"os"
	"testing"
)

func testBuildID(t *testing.T) {
	f, err := elf.Open("/proc/self/exe")
	if err != nil {
		if os.IsNotExist(err) {
			t.Skip("no /proc/self/exe")
		}
		t.Fatal("opening /proc/self/exe: ", err)
	}
	defer f.Close()

	c := 0
sections:
	for i, s := range f.Sections {
		if s.Type != elf.SHT_NOTE {
			continue
		}

	SBFX $2, R27, $54, R7                      // 67df4293
	SDIVW R22, R14, R9                         // c90dd61a
	SDIV R13, R21, R9                          // a90ecd9a
	SEV                                        // 9f2003d5
	SEVL                                       // bf2003d5
	SMADDL R3, R7, R11, R9                     // 691d239b
	SMSUBL R5, R19, R11, R29                   // 7dcd259b

	needsUnsafe := false
	f.walk(arg, ctxExpr, func(f *File, arg interface{}, context astContext) {
		px, ok := arg.(*ast.Expr)
		if !ok {
			return
		}
		sel, ok := (*px).(*ast.SelectorExpr)
		if ok {
			if l, ok := sel.X.(*ast.Ident); !ok || l.Name != "C" {
				return
			}

			for _, r := range f.Ref {
				if r.Expr == px {
					*px = p.rewriteName(f, r, addPosition)

pkg syscall (darwin-386), const RTV_SPIPE ideal-int
pkg syscall (darwin-386), const RTV_SSTHRESH ideal-int
pkg syscall (darwin-386), const RUSAGE_CHILDREN ideal-int
pkg syscall (darwin-386), const RUSAGE_SELF ideal-int
pkg syscall (darwin-386), const SCM_CREDS ideal-int
pkg syscall (darwin-386), const SCM_RIGHTS ideal-int
pkg syscall (darwin-386), const SCM_TIMESTAMP ideal-int

pkg syscall (darwin-arm64), const RUSAGE_CHILDREN = -1
pkg syscall (darwin-arm64), const RUSAGE_CHILDREN ideal-int
pkg syscall (darwin-arm64), const RUSAGE_SELF = 0
pkg syscall (darwin-arm64), const RUSAGE_SELF ideal-int
pkg syscall (darwin-arm64), const SCM_CREDS = 3
pkg syscall (darwin-arm64), const SCM_CREDS ideal-int
pkg syscall (darwin-arm64), const SCM_RIGHTS = 1

pkg syscall (freebsd-arm64), const RUSAGE_CHILDREN = -1
pkg syscall (freebsd-arm64), const RUSAGE_CHILDREN ideal-int
pkg syscall (freebsd-arm64), const RUSAGE_SELF = 0
pkg syscall (freebsd-arm64), const RUSAGE_SELF ideal-int
pkg syscall (freebsd-arm64), const RUSAGE_THREAD = 1
pkg syscall (freebsd-arm64), const RUSAGE_THREAD ideal-int
pkg syscall (freebsd-arm64), const S_IFMT = 61440

		}
	}
}

func tenRunes(r rune) string {
	runes := make([]rune, 10)
	for i := range runes {
		runes[i] = r
	}
	return string(runes)
}

// User-defined self-inverse mapping function
func rot13(r rune) rune {
	const step = 13
	if r >= 'a' && r <= 'z' {
		return ((r - 'a' + step) % 26) + 'a'
	}
	if r >= 'A' && r <= 'Z' {
		return ((r - 'A' + step) % 26) + 'A'