package main

import (
	"log"
	"reflect"
	"sort"
)

func main() {
	const length = 257
	x := make([]int64, length)
	for i := 0; i < length; i++ {
		x[i] = int64(i) * 27644437 % int64(length)
	}

	isLessStatic := func(i, j int) bool {
		return x[i] < x[j]
	}

	isLessReflect := reflect.MakeFunc(reflect.TypeOf(isLessStatic), func(args []reflect.Value) []reflect.Value {
		i := args[0].Int()

// reflect.Value.Call.

package main

import (
	"reflect"
)

type Empty struct {
	f1, f2 *byte
	empty struct{}
}

func F(e Empty, s []string) {
	if len(s) != 1 || s[0] != "hi" {
		panic("bad slice")
	}
}

func main() {
	reflect.ValueOf(F).Call([]reflect.Value{
		reflect.ValueOf(Empty{}),
		reflect.ValueOf([]string{"hi"}),
	})

	Go2(a);
	if (a[0] != 42) {
		abort();
	}
}
*/
import "C"

import (
	"reflect"
	"unsafe"
)

//export Go1
func Go1(p *C.int) {
	reflect.ValueOf(p).Elem().Set(reflect.ValueOf(C.int(42)))
}

//export Go2
func Go2(p *C.char) {
	a := (*[2]byte)(unsafe.Pointer(p))
	reflect.Copy(reflect.ValueOf(a[:1]), reflect.ValueOf(a[1:]))
}

func main() {
	C.C1()
	C.C2()

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "reflect"

func main() {
	_ = reflect.StructOf([]reflect.StructField{
		{Name: "_", PkgPath: "main", Type: reflect.TypeOf(int(0))},
		{Name: "_", PkgPath: "main", Type: reflect.TypeOf(int(0))},
	})

package callbacks

import (
	"reflect"

	"gorm.io/gorm"
)

func callMethod(db *gorm.DB, fc func(value interface{}, tx *gorm.DB) bool) {
	tx := db.Session(&gorm.Session{NewDB: true})
	if called := fc(db.Statement.ReflectValue.Interface(), tx); !called {
		switch db.Statement.ReflectValue.Kind() {
		case reflect.Slice, reflect.Array:
			db.Statement.CurDestIndex = 0
			for i := 0; i < db.Statement.ReflectValue.Len(); i++ {

	m := &certificateStatusMsg{}
	m.response = randomBytes(rand.Intn(10)+1, rand)
	return reflect.ValueOf(m)
}

func (*clientKeyExchangeMsg) Generate(rand *rand.Rand, size int) reflect.Value {
	m := &clientKeyExchangeMsg{}
	m.ciphertext = randomBytes(rand.Intn(1000)+1, rand)
	return reflect.ValueOf(m)
}

func (*finishedMsg) Generate(rand *rand.Rand, size int) reflect.Value {
	m := &finishedMsg{}

		VersionAliases: []string{
			"v1",
		},
		Proto: "istio.security.v1beta1.AuthorizationPolicy", StatusProto: "istio.meta.v1alpha1.IstioStatus",
		ReflectType: reflect.TypeOf(&istioioapisecurityv1beta1.AuthorizationPolicy{}).Elem(), StatusType: reflect.TypeOf(&istioioapimetav1alpha1.IstioStatus{}).Elem(),
		ProtoPackage: "istio.io/api/security/v1beta1", StatusPackage: "istio.io/api/meta/v1alpha1",
		ClusterScoped: false,

import org.junit.Test
import kotlin.reflect.KCallable
import kotlin.reflect.KClass
import kotlin.reflect.KFunction
import kotlin.reflect.KMutableProperty
import kotlin.reflect.KParameter
import kotlin.reflect.KProperty
import kotlin.reflect.KType
import kotlin.reflect.KTypeProjection
import kotlin.reflect.KVariance
import kotlin.reflect.KVisibility
import kotlin.reflect.full.createType

	return nil
}

func nativeTypeToCELType(t *testing.T, nativeType reflect.Type, field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) *apiservercel.DeclType {
	switch nativeType {
	case reflect.TypeOf(""):
		return apiservercel.StringType
	case reflect.TypeOf([]string{}):

package main

import "reflect"

type T struct{}

func (T) M() {
}

func F(args []reflect.Value) (results []reflect.Value) {
	return nil
}

func main() {
	done := make(chan bool)
	go func() {
		// Test reflect.makeFuncStub.
		t := reflect.TypeOf((func())(nil))
		f := reflect.MakeFunc(t, F).Interface().(func())
		defer f()
		growstack(10000)