return 0, 0
}

type C struct {
	calls []func(int) (int, int)
}

func makeC() Funcs {
	return &C{}
}

func (c *C) Add(fn func(int) (int, int)) Funcs {
	c.calls = append(c.calls, fn)
	return c
}

func (c *C) Call() {
	for _, fn := range c.calls {
		fn(0)
	}
}

type Funcs interface {
	Add(func(int) (int, int)) Funcs
	Call()
}

func main() {
	s := &S{}

	return syscall_SyscallN(fn, args[:nargs]...)
}

//go:linkname syscall_Syscall9 syscall.Syscall9
//go:nosplit
func syscall_Syscall9(fn, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) {
	args := [...]uintptr{a1, a2, a3, a4, a5, a6, a7, a8, a9}
	return syscall_SyscallN(fn, args[:nargs]...)
}

//go:linkname syscall_Syscall12 syscall.Syscall12
//go:nosplit

	for i := 0; i < count; i++ {
		fmt.Fprintf(&buf, fn, i, i + 1)
	}
	fmt.Fprintf(&buf, fnlast, count)

	dir, err := ioutil.TempDir("", "issue33555")
	if err != nil {
		return err
	}
	defer os.RemoveAll(dir)

	fn := filepath.Join(dir, "x.go")
	if err := ioutil.WriteFile(fn, buf.Bytes(), 0644); err != nil {
		return err
	}

	out, err := exec.Command("go", "run", fn).CombinedOutput()
	if err != nil {
		return err

			log.Fatalf("cannot find end of func %s", name)
		}
		fn := string(data[:x+len("\n}\n")])
		data = data[x+len("\n}"):]

		if strings.HasSuffix(name, "_32") {
			buf.WriteString(fix32.Replace(fn))
		}
		if strings.HasSuffix(name, "_8_32") {
			// x_8_32 -> x_8_64 done above
			fn = fix8_32.Replace(stripByteOnly(fn))
			buf.WriteString(fn)
			buf.WriteString(fix32.Replace(fn))
		}
	}

func BenchmarkServerMatch(b *testing.B) {
	fn := func(w ResponseWriter, r *Request) {
		fmt.Fprintf(w, "OK")
	}
	mux := NewServeMux()
	mux.HandleFunc("/", fn)
	mux.HandleFunc("/index", fn)
	mux.HandleFunc("/home", fn)
	mux.HandleFunc("/about", fn)
	mux.HandleFunc("/contact", fn)
	mux.HandleFunc("/robots.txt", fn)
	mux.HandleFunc("/products/", fn)
	mux.HandleFunc("/products/1", fn)
	mux.HandleFunc("/products/2", fn)

# limitations under the License.

set -e

ec=0
for fn in "$@"; do
  if ! grep -L -q -e "Apache License, Version 2" "${fn}"; then
    echo "Missing license: ${fn}"
    ec=1
  fi

  if ! grep -L -q -e "Copyright" "${fn}"; then
    echo "Missing copyright: ${fn}"
    ec=1
  fi
done

	MOVQ	BX, (AX)
	RET

TEXT crosscall2_trampoline<>(SB),NOSPLIT,$0-0
	JMP	crosscall2(SB)

// Called by C code generated by cmd/cgo.
// func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr)
// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
// This signature is known to SWIG, so we can't change it.
TEXT crosscall2(SB),NOSPLIT,$0-0
	PUSH_REGS_HOST_TO_ABI0()

	testCases := []struct {
		name string
		fn   func() int
		want int
	}{
		{
			name: "normal",
			fn:   normalFunc,
			want: 21,
		},
		{
			name: "multiline-declaration",
			fn:   multilineDeclarationFunc,
			want: 30,
		},
		{
			name: "blank-lines",
			fn:   blankLinesFunc,
			want: 35,
		},
		{
			name: "inline",
			fn:   inlineFunc,
			want: 49,
		},
		{

			}
		}
	}
	if err := c.Control(fn); err != nil {
		return err
	}
	return operr
}

func controlOnConnSetup(network string, address string, c syscall.RawConn) error {
	var operr error
	var fn func(uintptr)
	switch network {
	case "tcp", "udp", "ip":
		return errors.New("ambiguous network: " + network)
	default:
		switch network[len(network)-1] {
		case '4':
			fn = func(s uintptr) {

		call := node.(*ast.CallExpr)
		fn := typeutil.StaticCallee(pass.TypesInfo, call)
		if fn == nil {
			return // not a static call
		}
		if call.Ellipsis != token.NoPos {
			return // skip calls with "..." args
		}
		skipArgs, ok := kvFuncSkipArgs(fn)
		if !ok {
			// Not a slog function that takes key-value pairs.
			return
		}
		// Here we know that fn.Pkg() is "log/slog".
		if attrType == nil {