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 {

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

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

func (*ZdsHello) ProtoMessage() {}

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

        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<>());
        }

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

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

func (*EchoRequest) ProtoMessage() {}

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

	YIELD
	YIELD_ZZ
)

var opstr = [...]string{
	ADC_EQ:            "ADC.EQ",
	ADC_NE:            "ADC.NE",
	ADC_CS:            "ADC.CS",
	ADC_CC:            "ADC.CC",
	ADC_MI:            "ADC.MI",
	ADC_PL:            "ADC.PL",
	ADC_VS:            "ADC.VS",
	ADC_VC:            "ADC.VC",
	ADC_HI:            "ADC.HI",
	ADC_LS:            "ADC.LS",
	ADC_GE:            "ADC.GE",

func (x *Authorization) ProtoReflect() protoreflect.Message {
	mi := &file_workloadapi_security_authorization_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Authorization.ProtoReflect.Descriptor instead.

	*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]

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

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

func (*Address) ProtoMessage() {}

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

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

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

func (*NameTable) ProtoMessage() {}

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