fv := reflect.ValueOf(eqFunc)
	ft := fv.Type()
	if ft.Kind() != reflect.Func {
		return fmt.Errorf("expected func, got: %v", ft)
	}
	if ft.NumIn() != 2 {
		return fmt.Errorf("expected two 'in' params, got: %v", ft)
	}
	if ft.NumOut() != 1 {
		return fmt.Errorf("expected one 'out' param, got: %v", ft)
	}
	if ft.In(0) != ft.In(1) {

	for i := 0; i < st.NumField(); i++ {
		field := sv.Field(i)
		tag, omitempty := jsonTag(st.Field(i))
		if len(tag) == 0 {
			continue
		}
		ft := field.Type()

		kind := ft.Kind()
		if isPointerKind(kind) {
			ft = ft.Elem()
			kind = ft.Kind()
			if !field.IsNil() {
				field = reflect.Indirect(field)
				// If the field is non-nil, it should be added to params

	badPtr = uintptr(unsafe.Pointer(&b[len(b)-1])) + 1
}

type ft func() *int

var fn ft

func rf([]reflect.Value) []reflect.Value {
	a := reflect.ValueOf((*int)(nil))
	return []reflect.Value{a}
}

const N = 1000

func main() {
	fn = reflect.MakeFunc(reflect.TypeOf(fn), rf).Interface().(ft)

	// Keep running GC so the write barrier is on.
	go func() {
		for i := 0; i < N; i++ {

type S int

func (s S) M() { println("S.M") }

type I interface{ M() }

type T float64

func (t T) F(s S) {}

func main() {
	var t T
	meth, _ := reflect.TypeOf(t).MethodByName("F")
	ft := meth.Type
	at := ft.In(1)
	v := reflect.New(at).Elem()
	v.Interface().(I).M()

	src := inputString(s)
	ft := formTable[f]
	n, ok := ft.quickSpan(src, 0, len(s), true)
	if ok {
		return s
	}
	out := make([]byte, n, len(s))
	copy(out, s[0:n])
	rb := reorderBuffer{f: *ft, src: src, nsrc: len(s), out: out, flushF: appendFlush}
	return string(doAppendInner(&rb, n))
}

// IsNormal returns true if b == f(b).
func (f Form) IsNormal(b []byte) bool {
	src := inputBytes(b)
	ft := formTable[f]

	fl := flag(Func)
	mtyp := t.typeOff(p.Mtyp)
	ft := (*funcType)(unsafe.Pointer(mtyp))
	in := make([]Type, 0, 1+ft.NumIn())
	in = append(in, t)
	for _, arg := range ft.InSlice() {
		in = append(in, toRType(arg))
	}
	out := make([]Type, 0, ft.NumOut())
	for _, ret := range ft.OutSlice() {
		out = append(out, toRType(ret))
	}
	mt := FuncOf(in, out, ft.IsVariadic())
	m.Type = mt
	tfn := t.textOff(p.Tfn)

func (s S) M() { println("S.M") }

func (s S) N() { println("S.N") }

type T float64

func (t T) F(s S) {}

func main() {
	var t T
	meth, _ := reflect.TypeOf(t).MethodByName("F")
	ft := meth.Type
	at := ft.In(1)
	v := reflect.New(at).Elem()
	methV := v.MethodByName("M")
	methV.Call([]reflect.Value{v})

package main

import "reflect"

type S int

func (s S) M() { println("S.M") }

type I interface{ M() }

type T float64

func (t T) F(s S) {}

func main() {
	var t T
	ft := reflect.TypeOf(t).Method(0).Type
	at := ft.In(1)
	v := reflect.New(at).Elem()
	v.Interface().(I).M()

	src := inputString(s)
	ft := formTable[f]
	n, ok := ft.quickSpan(src, 0, len(s), true)
	if ok {
		return s
	}
	out := make([]byte, n, len(s))
	copy(out, s[0:n])
	rb := reorderBuffer{f: *ft, src: src, nsrc: len(s), out: out, flushF: appendFlush}
	return string(doAppendInner(&rb, n))
}

// IsNormal returns true if b == f(b).
func (f Form) IsNormal(b []byte) bool {
	src := inputBytes(b)
	ft := formTable[f]

				index := make([]int, len(f.index)+1)
				copy(index, f.index)
				index[len(f.index)] = i

				ft := sf.Type
				if ft.Name() == "" && ft.Kind() == reflect.Pointer {
					// Follow pointer.
					ft = ft.Elem()
				}

				// Record found field and index sequence.
				if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
					tagged := name != ""
					if name == "" {
						name = sf.Name
					}