optional bool bool = 2;

  // IntValue is a 64-bit integer.
  optional int64 int = 7;

  // IntSliceValue is an array of 64-bit integers.
  optional NamedResourcesIntSlice intSlice = 8;

  // StringValue is a string.
  optional string string = 5;

  // StringSliceValue is an array of strings.
  optional NamedResourcesStringSlice stringSlice = 9;

		{"(Float64Slice).Search", Method, 0},
		{"(Float64Slice).Sort", Method, 0},
		{"(Float64Slice).Swap", Method, 0},
		{"(IntSlice).Len", Method, 0},
		{"(IntSlice).Less", Method, 0},
		{"(IntSlice).Search", Method, 0},
		{"(IntSlice).Sort", Method, 0},
		{"(IntSlice).Swap", Method, 0},
		{"(StringSlice).Len", Method, 0},
		{"(StringSlice).Less", Method, 0},
		{"(StringSlice).Search", Method, 0},

	// Access Go pointer out of bounds.
	int c = a[5];        // BOOM
	// We shouldn't get here; asan should stop us first.
	printf("a[5]=%d\n", c);
}
*/
import "C"

func main() {
	cIntSlice := []C.int{200, 201, 203, 203, 204}
	C.test(&cIntSlice[0])

package main

import "fmt"

type IntLike interface {
	~int | ~int64 | ~int32 | ~int16 | ~int8
}

func Reduce[T any, U any, Uslice ~[]U](function func(T, U) T, sequence Uslice, initial T) T {
	result := initial
	for _, x := range sequence {
		result = function(result, x)
	}
	return result
}

func min[T IntLike](x, y T) T {
	if x < y {
		return x
	}
	return y
}

func InitAddr(n *ir.Name, noff int64, lsym *obj.LSym) {
	InitAddrOffset(n, noff, lsym, 0)
}

// InitSlice writes a static slice symbol {lsym, lencap, lencap} to n+noff, it does not modify n.
// It's the caller responsibility to make sure lsym is from ONAME node.
func InitSlice(n *ir.Name, noff int64, lsym *obj.LSym, lencap int64) {
	s := n.Linksym()
	s.WriteAddr(base.Ctxt, noff, types.PtrSize, lsym, 0)

	case abi.Func:
		ft := (*functype)(unsafe.Pointer(t))
		fv := (*functype)(unsafe.Pointer(v))
		if ft.OutCount != fv.OutCount || ft.InCount != fv.InCount {
			return false
		}
		tin, vin := ft.InSlice(), fv.InSlice()
		for i := 0; i < len(tin); i++ {
			if !typesEqual(tin[i], vin[i], seen) {
				return false
			}
		}
		tout, vout := ft.OutSlice(), fv.OutSlice()
		for i := 0; i < len(tout); i++ {

	}
	if value.Type().AssignableTo(argType) {
		return value, nil
	}
	if intLike(value.Kind()) && intLike(argType.Kind()) && value.Type().ConvertibleTo(argType) {
		value = value.Convert(argType)
		return value, nil
	}
	return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
}

func intLike(typ reflect.Kind) bool {
	switch typ {

}

func (t *FuncType) In(i int) *Type {
	return t.InSlice()[i]
}

func (t *FuncType) NumIn() int {
	return int(t.InCount)
}

func (t *FuncType) NumOut() int {
	return int(t.OutCount & (1<<15 - 1))
}

func (t *FuncType) Out(i int) *Type {
	return (t.OutSlice()[i])
}

func (t *FuncType) InSlice() []*Type {
	uadd := unsafe.Sizeof(*t)
	if t.TFlag&TFlagUncommon != 0 {

pkg sort, method (Float64Slice) Sort()
pkg sort, method (Float64Slice) Swap(int, int)
pkg sort, method (IntSlice) Len() int
pkg sort, method (IntSlice) Less(int, int) bool
pkg sort, method (IntSlice) Search(int) int
pkg sort, method (IntSlice) Sort()
pkg sort, method (IntSlice) Swap(int, int)
pkg sort, method (StringSlice) Len() int
pkg sort, method (StringSlice) Less(int, int) bool

func (t rtype) Elem() Type {
	return toType(elem(t.common()))
}

func (t rtype) In(i int) Type {
	tt := t.Type.FuncType()
	if tt == nil {
		panic("reflect: In of non-func type")
	}
	return toType(tt.InSlice()[i])
}

func (t rtype) Key() Type {
	tt := t.Type.MapType()
	if tt == nil {
		panic("reflect: Key of non-map type")
	}
	return toType(tt.Key)
}

func (t rtype) Len() int {