type myInt struct {
	f *notInHeap
}

func (mi myInt) Get() int {
	return int(mi.f.i)
}

type embed struct {
	*myInt
}

var val = 1234

var valNotInHeap = notInHeap{i: val}

func main() {
	i := val
	check(i)
	mi := myInt{f: &valNotInHeap}
	check(mi.Get())
	ifv := iface(mi)
	check(ifv.Get())
	ifv = iface(&mi)
	check(ifv.Get())
	em := embed{&mi}
	check(em.Get())
	ifv = em

	}
	for i = range f7 {
		_ = i
	}
	for mi, _ := range f8 {
		_ = mi
	}
	for mi, _ = range f8 {
		_ = mi
	}
	for mi, ms := range f8 {
		_, _ = mi, ms
	}
	for i /* ERROR "cannot use i (value of type MyInt) as int value in assignment" */, s /* ERROR "cannot use s (value of type MyString) as string value in assignment" */ = range f8 {
		_, _ = mi, ms
	}
	for mi, ms := range f8 {

        ModuleIdentifier mi = module(group, name);
        return moduleWithVersion(mi, version);
    }

    @Override
    public ModuleVersionIdentifier moduleWithVersion(ModuleIdentifier mi, String version) {
        Map<String, ModuleVersionIdentifier> byVersion = idToVersions.get(mi);
        if (byVersion == null) {
            byVersion = idToVersions.computeIfAbsent(mi, k -> new ConcurrentHashMap<>());
        }

	*x = MockConfig{}
	if protoimpl.UnsafeEnabled {
		mi := &file_pkg_test_config_mock_config_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *MockConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MockConfig) ProtoMessage() {}

func (x *MockConfig) ProtoReflect() protoreflect.Message {
	mi := &file_pkg_test_config_mock_config_proto_msgTypes[0]

	F[*MyMer](&mm)
	F[struct{ MyMer }](ms2)
	F[struct{ *MyMer }](ms3)
	F[*struct{ MyMer }](&ms2)
	F[*struct{ *MyMer }](&ms3)

	// Testing G with a concrete type args
	mi := MyInt(-3)
	G[MyInt,MyInt](mi)

	// Interface Abs[MyInt] holding an mi.
	intMi := Abs[MyInt](mi)
	// First type arg here is Abs[MyInt], an interface type.
	G[Abs[MyInt],MyInt](intMi)

	}
	if r.Move(-N) != r {
		t.Errorf("r.Move(%d) != r", -N)
	}
	for i := 0; i < 10; i++ {
		ni := N + i
		mi := ni % N
		if r.Move(ni) != r.Move(mi) {
			t.Errorf("r.Move(%d) != r.Move(%d)", ni, mi)
		}
		if r.Move(-ni) != r.Move(-mi) {
			t.Errorf("r.Move(%d) != r.Move(%d)", -ni, -mi)
		}
	}
}

func TestCornerCases(t *testing.T) {
	var (
		r0 *Ring
		r1 Ring
	)
	// Basics

func ModSort(list []module.Version) {
	sort.Slice(list, func(i, j int) bool {
		mi := list[i]
		mj := list[j]
		if mi.Path != mj.Path {
			return mi.Path < mj.Path
		}
		// To help go.sum formatting, allow version/file.
		// Compare semver prefix by semver rules,
		// file by string order.
		vi := mi.Version
		vj := mj.Version
		var fi, fj string
		if k := strings.Index(vi, "/"); k >= 0 {

	}

	var i int
	var mi MyInt
	for i := range 10 {
		_ = i
	}
	for i = range 10 {
		_ = i
	}
	for i, j /* ERROR "range over 10 (untyped int constant) permits only one iteration variable" */ := range 10 {
		_, _ = i, j
	}
	for i = range MyInt /* ERROR "cannot use MyInt(10) (constant 10 of type MyInt) as int value in range clause" */ (10) {
		_ = i
	}
	for mi := range MyInt(10) {
		_ = mi
	}

    /**
     * for compatibility reasons with testng 6.9.10
     */
    void onBeforeClass(ITestClass testClass, IMethodInstance mi);

    void onAfterClass(ITestClass testClass);

    /**
     * for compatibility reasons with testng 6.9.10
     */
    void onAfterClass(ITestClass testClass, IMethodInstance mi);

// license that can be found in the LICENSE file.

// constant conversions

package const1

import "math"

const(
	mi = ^int(0)
	mu = ^uint(0)
	mp = ^uintptr(0)

	logSizeofInt     = uint(mi>>8&1 + mi>>16&1 + mi>>32&1)
	logSizeofUint    = uint(mu>>8&1 + mu>>16&1 + mu>>32&1)
	logSizeofUintptr = uint(mp>>8&1 + mp>>16&1 + mp>>32&1)
)

const (
	minInt8 = -1<<(8<<iota - 1)