func (v Value) FieldByIndex(index []int) Value {
	return value_FieldByIndex(v, index)
}
FieldByIndex returns the nested field corresponding to index.
It panics if v's Kind is not struct.
package reflect
import (
	"reflect"
	"unsafe"
)
type Type = *rtype
type rtype struct{}
type flag uintptr
const (
	flagKindWidth        = 5  
	flagKindMask    flag = 1<<flagKindWidth - 1
	flagStickyRO    flag = 1 << 5
	flagEmbedRO     flag = 1 << 6
	flagIndir       flag = 1 << 7
	flagAddr        flag = 1 << 8
	flagMethod      flag = 1 << 9
	flagMethodShift      = 10
	flagRO          flag = flagStickyRO | flagEmbedRO
)
type Kind = reflect.Kind
const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Ptr
	Slice
	String
	Struct
	UnsafePointer
)
const (
	_             SelectDir = iota
	SelectSend               
	SelectRecv               
	SelectDefault            
)
type StructTag = reflect.StructTag
type ChanDir = reflect.ChanDir
const (
	RecvDir ChanDir             = 1 << iota  
	SendDir                                  
	BothDir = RecvDir | SendDir              
)
type MapIter = reflect.MapIter
type ValueError = reflect.ValueError
type SliceHeader = reflect.SliceHeader
type StringHeader = reflect.StringHeader
type SelectCase struct {
	Dir  SelectDir  
	Chan Value      
	Send Value      
}
type SelectDir = reflect.SelectDir
type Value struct {
	typ Type
	ptr unsafe.Pointer
	flag
}
type Method struct {
	Name    string
	PkgPath string
	Type  Type   
	Func  Value  
	Index int    
}
type StructField struct {
	Name string
	PkgPath string
	Type      Type       
	Tag       StructTag  
	Offset    uintptr    
	Index     []int      
	Anonymous bool       
}
func ArrayOf(count int, elem Type) Type {
	return arrayOf(count, elem)
}
func ChanOf(dir ChanDir, t Type) Type {
	return chanOf(dir, t)
}
func FuncOf(in, out []Type, variadic bool) Type {
	return funcOf(in, out, variadic)
}
func MapOf(key, elem Type) Type {
	return mapOf(key, elem)
}
func PtrTo(t Type) Type {
	return ptrTo(t)
}
func SliceOf(t Type) Type {
	return sliceOf(t)
}
func StructOf(fields []StructField) Type {
	return structOf(fields)
}
func TypeOf(v interface{}) Type {
	value := (*Value)(unsafe.Pointer(&v))
	return value.typ
}
func TypeID(v interface{}) uintptr {
	return uintptr(unsafe.Pointer(TypeOf(v)))
}
func valueOf(v interface{}) Value {
	if v == nil {
		return Value{}
	}
	valueLayout := (*Value)(unsafe.Pointer(&v))
	value := Value{}
	value.typ = valueLayout.typ
	value.ptr = valueLayout.ptr
	f := flag(value.typ.Kind())
	if ifaceIndir(value.typ) {
		f |= flagIndir
	}
	value.flag = f
	return value
}
func TypeAndPtrOf(v interface{}) (Type, unsafe.Pointer) {
	value := (*Value)(unsafe.Pointer(&v))
	return value.typ, value.ptr
}
func ValueOf(v interface{}) Value {
	escape(v)
	return valueOf(v)
}
func ValueNoEscapeOf(v interface{}) Value {
	return valueOf(v)
}
func ToReflectType(t Type) reflect.Type {
	return toRT(t)
}
func ToReflectValue(v Value) reflect.Value {
	return toRV(v)
}
func ToType(t reflect.Type) Type {
	return toT(t)
}
func ToValue(v reflect.Value) Value {
	return toV(v)
}
func Copy(dst, src Value) int {
	return value_Copy(dst, src)
}
func DeepEqual(x, y interface{}) bool {
	return reflect.DeepEqual(x, y)
}
func Swapper(slice interface{}) func(i, j int) {
	return reflect.Swapper(slice)
}
func Append(s Value, x ...Value) Value {
	return value_Append(s, x...)
}
func AppendSlice(s, t Value) Value {
	return value_AppendSlice(s, t)
}
func Indirect(v Value) Value {
	return value_Indirect(v)
}
func MakeChan(typ Type, buffer int) Value {
	return value_MakeChan(typ, buffer)
}
func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
	return value_MakeFunc(typ, fn)
}
func MakeMap(typ Type) Value {
	return value_MakeMap(typ)
}
func MakeMapWithSize(typ Type, n int) Value {
	return value_MakeMapWithSize(typ, n)
}
func MakeSlice(typ Type, len, cap int) Value {
	return value_MakeSlice(typ, len, cap)
}
func New(typ Type) Value {
	return value_New(typ)
}
func NewAt(typ Type, p unsafe.Pointer) Value {
	return value_NewAt(typ, p)
}
func Select(cases []SelectCase) (int, Value, bool) {
	return value_Select(cases)
}
func Zero(typ Type) Value {
	return value_Zero(typ)
}
func (t *rtype) Align() int {
	return type_Align(t)
}
func (t *rtype) FieldAlign() int {
	return type_FieldAlign(t)
}
func (t *rtype) Method(a0 int) Method {
	return toM(type_Method(t, a0))
}
func (t *rtype) MethodByName(a0 string) (Method, bool) {
	mtd, ok := type_MethodByName(t, a0)
	return toM(mtd), ok
}
func (t *rtype) NumMethod() int {
	return type_NumMethod(t)
}
func (t *rtype) Name() string {
	return type_Name(t)
}
func (t *rtype) PkgPath() string {
	return type_PkgPath(t)
}
func (t *rtype) Size() uintptr {
	return type_Size(t)
}
func (t *rtype) String() string {
	return type_String(t)
}
func (t *rtype) Kind() Kind {
	return type_Kind(t)
}
func (t *rtype) Implements(u Type) bool {
	return type_Implements(t, toRT(u))
}
func (t *rtype) AssignableTo(u Type) bool {
	return type_AssignableTo(t, toRT(u))
}
func (t *rtype) ConvertibleTo(u Type) bool {
	return type_ConvertibleTo(t, toRT(u))
}
func (t *rtype) Comparable() bool {
	return type_Comparable(t)
}
func (t *rtype) Bits() int {
	return type_Bits(t)
}
func (t *rtype) ChanDir() ChanDir {
	return type_ChanDir(t)
}
func (t *rtype) IsVariadic() bool {
	return type_IsVariadic(t)
}
func (t *rtype) Elem() Type {
	return ToType(type_Elem(t))
}
func (t *rtype) Field(i int) StructField {
	return toSF(type_Field(t, i))
}
func (t *rtype) FieldByIndex(index []int) StructField {
	return toSF(type_FieldByIndex(t, index))
}
func (t *rtype) FieldByName(name string) (StructField, bool) {
	field, ok := type_FieldByName(t, name)
	return toSF(field), ok
}
func (t *rtype) FieldByNameFunc(match func(string) bool) (StructField, bool) {
	field, ok := type_FieldByNameFunc(t, match)
	return toSF(field), ok
}
func (t *rtype) In(i int) Type {
	return ToType(type_In(t, i))
}
func (t *rtype) Key() Type {
	return ToType(type_Key(t))
}
func (t *rtype) Len() int {
	return type_Len(t)
}
func (t *rtype) NumField() int {
	return type_NumField(t)
}
func (t *rtype) NumIn() int {
	return type_NumIn(t)
}
func (t *rtype) NumOut() int {
	return type_NumOut(t)
}
func (t *rtype) Out(i int) Type {
	return toT(type_Out(t, i))
}
func (v Value) Addr() Value {
	return value_Addr(v)
}
func (v Value) Bool() bool {
	return value_Bool(v)
}
func (v Value) Bytes() []byte {
	return value_Bytes(v)
}
func (v Value) Call(in []Value) []Value {
	return value_Call(v, in)
}
func (v Value) CallSlice(in []Value) []Value {
	return value_CallSlice(v, in)
}
func (v Value) CanAddr() bool {
	return value_CanAddr(v)
}
func (v Value) CanInterface() bool {
	return value_CanInterface(v)
}
func (v Value) CanSet() bool {
	return value_CanSet(v)
}
func (v Value) Cap() int {
	return value_Cap(v)
}
func (v Value) Close() {
	value_Close(v)
}
func (v Value) Complex() complex128 {
	return value_Complex(v)
}
func (v Value) Convert(t Type) Value {
	return value_Convert(v, t)
}
func (v Value) Elem() Value {
	return value_Elem(v)
}
func (v Value) Field(i int) Value {
	return value_Field(v, i)
}