github.com/onosproject/onos-api/go@v0.10.32/onos/topo/ran.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: onos/topo/ran.proto

package topo

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// TODO: Deprecate! Use language specific constant definitions instead.
// Kinds of RAN entities
type RANEntityKinds int32

const (
	RANEntityKinds_E2NODE RANEntityKinds = 0
	RANEntityKinds_E2CELL RANEntityKinds = 1
	RANEntityKinds_E2T    RANEntityKinds = 3
	RANEntityKinds_XAPP   RANEntityKinds = 4
	RANEntityKinds_A1T    RANEntityKinds = 5
)

var RANEntityKinds_name = map[int32]string{
	0: "E2NODE",
	1: "E2CELL",
	3: "E2T",
	4: "XAPP",
	5: "A1T",
}

var RANEntityKinds_value = map[string]int32{
	"E2NODE": 0,
	"E2CELL": 1,
	"E2T":    3,
	"XAPP":   4,
	"A1T":    5,
}

func (x RANEntityKinds) String() string {
	return proto.EnumName(RANEntityKinds_name, int32(x))
}

func (RANEntityKinds) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{0}
}

// TODO: Deprecate! Use language specific constant definitions instead.
// Kinds of RAN relations
type RANRelationKinds int32

const (
	RANRelationKinds_CONTROLS  RANRelationKinds = 0
	RANRelationKinds_CONTAINS  RANRelationKinds = 1
	RANRelationKinds_NEIGHBORS RANRelationKinds = 2
)

var RANRelationKinds_name = map[int32]string{
	0: "CONTROLS",
	1: "CONTAINS",
	2: "NEIGHBORS",
}

var RANRelationKinds_value = map[string]int32{
	"CONTROLS":  0,
	"CONTAINS":  1,
	"NEIGHBORS": 2,
}

func (x RANRelationKinds) String() string {
	return proto.EnumName(RANRelationKinds_name, int32(x))
}

func (RANRelationKinds) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{1}
}

type CellGlobalIDType int32

const (
	CellGlobalIDType_NRCGI CellGlobalIDType = 0
	CellGlobalIDType_ECGI  CellGlobalIDType = 1
)

var CellGlobalIDType_name = map[int32]string{
	0: "NRCGI",
	1: "ECGI",
}

var CellGlobalIDType_value = map[string]int32{
	"NRCGI": 0,
	"ECGI":  1,
}

func (x CellGlobalIDType) String() string {
	return proto.EnumName(CellGlobalIDType_name, int32(x))
}

func (CellGlobalIDType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{2}
}

// NodeType is for use in encoding node type in topo Entity URI identifier; see section 9.2.6 of ORAN E2AP v02.00 spec
type NodeType int32

const (
	NodeType_NT_NONE   NodeType = 0
	NodeType_NT_GNB    NodeType = 1
	NodeType_NT_EN_GNB NodeType = 2
	NodeType_NT_NG_ENB NodeType = 3
	NodeType_NT_ENB    NodeType = 4
)

var NodeType_name = map[int32]string{
	0: "NT_NONE",
	1: "NT_GNB",
	2: "NT_EN_GNB",
	3: "NT_NG_ENB",
	4: "NT_ENB",
}

var NodeType_value = map[string]int32{
	"NT_NONE":   0,
	"NT_GNB":    1,
	"NT_EN_GNB": 2,
	"NT_NG_ENB": 3,
	"NT_ENB":    4,
}

func (x NodeType) String() string {
	return proto.EnumName(NodeType_name, int32(x))
}

func (NodeType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{3}
}

// ComponentType is for use in encoding node component type in topo Entity URI identifier; see section 9.2.6 of ORAN E2AP v02.00 spec
type ComponentType int32

const (
	ComponentType_CT_NONE  ComponentType = 0
	ComponentType_CT_CU    ComponentType = 1
	ComponentType_CT_CU_UP ComponentType = 2
	ComponentType_CT_DU    ComponentType = 3
	ComponentType_CT_ENB   ComponentType = 4
)

var ComponentType_name = map[int32]string{
	0: "CT_NONE",
	1: "CT_CU",
	2: "CT_CU_UP",
	3: "CT_DU",
	4: "CT_ENB",
}

var ComponentType_value = map[string]int32{
	"CT_NONE":  0,
	"CT_CU":    1,
	"CT_CU_UP": 2,
	"CT_DU":    3,
	"CT_ENB":   4,
}

func (x ComponentType) String() string {
	return proto.EnumName(ComponentType_name, int32(x))
}

func (ComponentType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{4}
}

type E2SmRsmCommand int32

const (
	E2SmRsmCommand_E2_SM_RSM_COMMAND_SLICE_CREATE   E2SmRsmCommand = 0
	E2SmRsmCommand_E2_SM_RSM_COMMAND_SLICE_UPDATE   E2SmRsmCommand = 1
	E2SmRsmCommand_E2_SM_RSM_COMMAND_SLICE_DELETE   E2SmRsmCommand = 2
	E2SmRsmCommand_E2_SM_RSM_COMMAND_UE_ASSOCIATE   E2SmRsmCommand = 3
	E2SmRsmCommand_E2_SM_RSM_COMMAND_EVENT_TRIGGERS E2SmRsmCommand = 4
)

var E2SmRsmCommand_name = map[int32]string{
	0: "E2_SM_RSM_COMMAND_SLICE_CREATE",
	1: "E2_SM_RSM_COMMAND_SLICE_UPDATE",
	2: "E2_SM_RSM_COMMAND_SLICE_DELETE",
	3: "E2_SM_RSM_COMMAND_UE_ASSOCIATE",
	4: "E2_SM_RSM_COMMAND_EVENT_TRIGGERS",
}

var E2SmRsmCommand_value = map[string]int32{
	"E2_SM_RSM_COMMAND_SLICE_CREATE":   0,
	"E2_SM_RSM_COMMAND_SLICE_UPDATE":   1,
	"E2_SM_RSM_COMMAND_SLICE_DELETE":   2,
	"E2_SM_RSM_COMMAND_UE_ASSOCIATE":   3,
	"E2_SM_RSM_COMMAND_EVENT_TRIGGERS": 4,
}

func (x E2SmRsmCommand) String() string {
	return proto.EnumName(E2SmRsmCommand_name, int32(x))
}

func (E2SmRsmCommand) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{5}
}

type RSMSlicingType int32

const (
	RSMSlicingType_SLICING_TYPE_STATIC  RSMSlicingType = 0
	RSMSlicingType_SLICING_TYPE_DYNAMIC RSMSlicingType = 1
)

var RSMSlicingType_name = map[int32]string{
	0: "SLICING_TYPE_STATIC",
	1: "SLICING_TYPE_DYNAMIC",
}

var RSMSlicingType_value = map[string]int32{
	"SLICING_TYPE_STATIC":  0,
	"SLICING_TYPE_DYNAMIC": 1,
}

func (x RSMSlicingType) String() string {
	return proto.EnumName(RSMSlicingType_name, int32(x))
}

func (RSMSlicingType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{6}
}

type RSMSchedulerType int32

const (
	RSMSchedulerType_SCHEDULER_TYPE_ROUND_ROBIN         RSMSchedulerType = 0
	RSMSchedulerType_SCHEDULER_TYPE_PROPORTIONALLY_FAIR RSMSchedulerType = 1
	RSMSchedulerType_SCHEDULER_TYPE_QOS_BASED           RSMSchedulerType = 2
)

var RSMSchedulerType_name = map[int32]string{
	0: "SCHEDULER_TYPE_ROUND_ROBIN",
	1: "SCHEDULER_TYPE_PROPORTIONALLY_FAIR",
	2: "SCHEDULER_TYPE_QOS_BASED",
}

var RSMSchedulerType_value = map[string]int32{
	"SCHEDULER_TYPE_ROUND_ROBIN":         0,
	"SCHEDULER_TYPE_PROPORTIONALLY_FAIR": 1,
	"SCHEDULER_TYPE_QOS_BASED":           2,
}

func (x RSMSchedulerType) String() string {
	return proto.EnumName(RSMSchedulerType_name, int32(x))
}

func (RSMSchedulerType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{7}
}

type RSMSliceType int32

const (
	RSMSliceType_SLICE_TYPE_DL_SLICE RSMSliceType = 0
	RSMSliceType_SLICE_TYPE_UL_SLICE RSMSliceType = 1
)

var RSMSliceType_name = map[int32]string{
	0: "SLICE_TYPE_DL_SLICE",
	1: "SLICE_TYPE_UL_SLICE",
}

var RSMSliceType_value = map[string]int32{
	"SLICE_TYPE_DL_SLICE": 0,
	"SLICE_TYPE_UL_SLICE": 1,
}

func (x RSMSliceType) String() string {
	return proto.EnumName(RSMSliceType_name, int32(x))
}

func (RSMSliceType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{8}
}

type UeIdType int32

const (
	UeIdType_UE_ID_TYPE_CU_UE_F1_AP_ID  UeIdType = 0
	UeIdType_UE_ID_TYPE_DU_UE_F1_AP_ID  UeIdType = 1
	UeIdType_UE_ID_TYPE_RAN_UE_NGAP_ID  UeIdType = 2
	UeIdType_UE_ID_TYPE_AMF_UE_NGAP_ID  UeIdType = 3
	UeIdType_UE_ID_TYPE_ENB_UE_S1_AP_ID UeIdType = 4
)

var UeIdType_name = map[int32]string{
	0: "UE_ID_TYPE_CU_UE_F1_AP_ID",
	1: "UE_ID_TYPE_DU_UE_F1_AP_ID",
	2: "UE_ID_TYPE_RAN_UE_NGAP_ID",
	3: "UE_ID_TYPE_AMF_UE_NGAP_ID",
	4: "UE_ID_TYPE_ENB_UE_S1_AP_ID",
}

var UeIdType_value = map[string]int32{
	"UE_ID_TYPE_CU_UE_F1_AP_ID":  0,
	"UE_ID_TYPE_DU_UE_F1_AP_ID":  1,
	"UE_ID_TYPE_RAN_UE_NGAP_ID":  2,
	"UE_ID_TYPE_AMF_UE_NGAP_ID":  3,
	"UE_ID_TYPE_ENB_UE_S1_AP_ID": 4,
}

func (x UeIdType) String() string {
	return proto.EnumName(UeIdType_name, int32(x))
}

func (UeIdType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{9}
}

type NrScs int32

const (
	NrScs_SCS_UNKNOWN NrScs = 0
	NrScs_SCS_15      NrScs = 1
	NrScs_SCS_30      NrScs = 2
	NrScs_SCS_50      NrScs = 3
	NrScs_SCS_120     NrScs = 4
)

var NrScs_name = map[int32]string{
	0: "SCS_UNKNOWN",
	1: "SCS_15",
	2: "SCS_30",
	3: "SCS_50",
	4: "SCS_120",
}

var NrScs_value = map[string]int32{
	"SCS_UNKNOWN": 0,
	"SCS_15":      1,
	"SCS_30":      2,
	"SCS_50":      3,
	"SCS_120":     4,
}

func (x NrScs) String() string {
	return proto.EnumName(NrScs_name, int32(x))
}

func (NrScs) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{10}
}

type Nrb int32

const (
	Nrb_NRB_UNKNOWN Nrb = 0
	Nrb_NRB_11      Nrb = 1
	Nrb_NRB_18      Nrb = 2
	Nrb_NRB_24      Nrb = 3
	Nrb_NRB_25      Nrb = 4
	Nrb_NRB_31      Nrb = 5
	Nrb_NRB_32      Nrb = 6
	Nrb_NRB_38      Nrb = 7
	Nrb_NRB_51      Nrb = 8
	Nrb_NRB_52      Nrb = 9
	Nrb_NRB_65      Nrb = 10
	Nrb_NRB_66      Nrb = 11
	Nrb_NRB_78      Nrb = 12
	Nrb_NRB_79      Nrb = 13
	Nrb_NRB_93      Nrb = 14
	Nrb_NRB_106     Nrb = 15
	Nrb_NRB_107     Nrb = 16
	Nrb_NRB_121     Nrb = 17
	Nrb_NRB_132     Nrb = 18
	Nrb_NRB_133     Nrb = 19
	Nrb_NRB_135     Nrb = 20
	Nrb_NRB_160     Nrb = 21
	Nrb_NRB_162     Nrb = 22
	Nrb_NRB_189     Nrb = 23
	Nrb_NRB_216     Nrb = 24
	Nrb_NRB_217     Nrb = 25
	Nrb_NRB_245     Nrb = 26
	Nrb_NRB_264     Nrb = 27
	Nrb_NRB_270     Nrb = 28
	Nrb_NRB_273     Nrb = 29
)

var Nrb_name = map[int32]string{
	0:  "NRB_UNKNOWN",
	1:  "NRB_11",
	2:  "NRB_18",
	3:  "NRB_24",
	4:  "NRB_25",
	5:  "NRB_31",
	6:  "NRB_32",
	7:  "NRB_38",
	8:  "NRB_51",
	9:  "NRB_52",
	10: "NRB_65",
	11: "NRB_66",
	12: "NRB_78",
	13: "NRB_79",
	14: "NRB_93",
	15: "NRB_106",
	16: "NRB_107",
	17: "NRB_121",
	18: "NRB_132",
	19: "NRB_133",
	20: "NRB_135",
	21: "NRB_160",
	22: "NRB_162",
	23: "NRB_189",
	24: "NRB_216",
	25: "NRB_217",
	26: "NRB_245",
	27: "NRB_264",
	28: "NRB_270",
	29: "NRB_273",
}

var Nrb_value = map[string]int32{
	"NRB_UNKNOWN": 0,
	"NRB_11":      1,
	"NRB_18":      2,
	"NRB_24":      3,
	"NRB_25":      4,
	"NRB_31":      5,
	"NRB_32":      6,
	"NRB_38":      7,
	"NRB_51":      8,
	"NRB_52":      9,
	"NRB_65":      10,
	"NRB_66":      11,
	"NRB_78":      12,
	"NRB_79":      13,
	"NRB_93":      14,
	"NRB_106":     15,
	"NRB_107":     16,
	"NRB_121":     17,
	"NRB_132":     18,
	"NRB_133":     19,
	"NRB_135":     20,
	"NRB_160":     21,
	"NRB_162":     22,
	"NRB_189":     23,
	"NRB_216":     24,
	"NRB_217":     25,
	"NRB_245":     26,
	"NRB_264":     27,
	"NRB_270":     28,
	"NRB_273":     29,
}

func (x Nrb) String() string {
	return proto.EnumName(Nrb_name, int32(x))
}

func (Nrb) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{11}
}

type EnDcSupport int32

const (
	EnDcSupport_EN_DC_SUPPORT_UNKNOWN       EnDcSupport = 0
	EnDcSupport_EN_DC_SUPPORT_SUPPORTED     EnDcSupport = 1
	EnDcSupport_EN_DC_SUPPORT_NOT_SUPPORTED EnDcSupport = 2
)

var EnDcSupport_name = map[int32]string{
	0: "EN_DC_SUPPORT_UNKNOWN",
	1: "EN_DC_SUPPORT_SUPPORTED",
	2: "EN_DC_SUPPORT_NOT_SUPPORTED",
}

var EnDcSupport_value = map[string]int32{
	"EN_DC_SUPPORT_UNKNOWN":       0,
	"EN_DC_SUPPORT_SUPPORTED":     1,
	"EN_DC_SUPPORT_NOT_SUPPORTED": 2,
}

func (x EnDcSupport) String() string {
	return proto.EnumName(EnDcSupport_name, int32(x))
}

func (EnDcSupport) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{12}
}

type Interface_Type int32

const (
	Interface_INTERFACE_UNKNOWN Interface_Type = 0
	Interface_INTERFACE_E2T     Interface_Type = 1
	Interface_INTERFACE_E2AP101 Interface_Type = 2
	Interface_INTERFACE_E2AP200 Interface_Type = 3
	Interface_INTERFACE_A1_XAPP Interface_Type = 4
	Interface_INTERFACE_A1AP    Interface_Type = 5
)

var Interface_Type_name = map[int32]string{
	0: "INTERFACE_UNKNOWN",
	1: "INTERFACE_E2T",
	2: "INTERFACE_E2AP101",
	3: "INTERFACE_E2AP200",
	4: "INTERFACE_A1_XAPP",
	5: "INTERFACE_A1AP",
}

var Interface_Type_value = map[string]int32{
	"INTERFACE_UNKNOWN": 0,
	"INTERFACE_E2T":     1,
	"INTERFACE_E2AP101": 2,
	"INTERFACE_E2AP200": 3,
	"INTERFACE_A1_XAPP": 4,
	"INTERFACE_A1AP":    5,
}

func (x Interface_Type) String() string {
	return proto.EnumName(Interface_Type_name, int32(x))
}

func (Interface_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{14, 0}
}

type Location struct {
	// Legacy Geographical location; expected value type of "location" aspect
	Lat float64 `protobuf:"fixed64,1,opt,name=lat,proto3" json:"lat,omitempty"` // Deprecated: Do not use.
	Lng float64 `protobuf:"fixed64,2,opt,name=lng,proto3" json:"lng,omitempty"` // Deprecated: Do not use.
	// Types that are valid to be assigned to Ext:
	//	*Location_Wgs84
	//	*Location_Cartesian
	Ext isLocation_Ext `protobuf_oneof:"ext"`
}

func (m *Location) Reset()         { *m = Location{} }
func (m *Location) String() string { return proto.CompactTextString(m) }
func (*Location) ProtoMessage()    {}
func (*Location) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{0}
}
func (m *Location) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Location.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Location) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Location.Merge(m, src)
}
func (m *Location) XXX_Size() int {
	return m.Size()
}
func (m *Location) XXX_DiscardUnknown() {
	xxx_messageInfo_Location.DiscardUnknown(m)
}

var xxx_messageInfo_Location proto.InternalMessageInfo

type isLocation_Ext interface {
	isLocation_Ext()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Location_Wgs84 struct {
	Wgs84 *Wgs84Location `protobuf:"bytes,3,opt,name=wgs84,proto3,oneof" json:"wgs84,omitempty"`
}
type Location_Cartesian struct {
	Cartesian *CartesianLocation `protobuf:"bytes,4,opt,name=cartesian,proto3,oneof" json:"cartesian,omitempty"`
}

func (*Location_Wgs84) isLocation_Ext()     {}
func (*Location_Cartesian) isLocation_Ext() {}

func (m *Location) GetExt() isLocation_Ext {
	if m != nil {
		return m.Ext
	}
	return nil
}

// Deprecated: Do not use.
func (m *Location) GetLat() float64 {
	if m != nil {
		return m.Lat
	}
	return 0
}

// Deprecated: Do not use.
func (m *Location) GetLng() float64 {
	if m != nil {
		return m.Lng
	}
	return 0
}

func (m *Location) GetWgs84() *Wgs84Location {
	if x, ok := m.GetExt().(*Location_Wgs84); ok {
		return x.Wgs84
	}
	return nil
}

func (m *Location) GetCartesian() *CartesianLocation {
	if x, ok := m.GetExt().(*Location_Cartesian); ok {
		return x.Cartesian
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Location) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Location_Wgs84)(nil),
		(*Location_Cartesian)(nil),
	}
}

type Wgs84Location struct {
	// Latitude in degrees, between +/- 90.
	LatitudeDeg float64 `protobuf:"fixed64,1,opt,name=latitude_deg,json=latitudeDeg,proto3" json:"latitude_deg,omitempty"`
	// Longitude in degrees, between +/- 180.
	LongitudeDeg float64 `protobuf:"fixed64,2,opt,name=longitude_deg,json=longitudeDeg,proto3" json:"longitude_deg,omitempty"`
	// Altitude in meters, from the surface of the WGS-84 ellipsoid.
	AltitudeM float64 `protobuf:"fixed64,3,opt,name=altitude_m,json=altitudeM,proto3" json:"altitude_m,omitempty"`
}

func (m *Wgs84Location) Reset()         { *m = Wgs84Location{} }
func (m *Wgs84Location) String() string { return proto.CompactTextString(m) }
func (*Wgs84Location) ProtoMessage()    {}
func (*Wgs84Location) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{1}
}
func (m *Wgs84Location) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Wgs84Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Wgs84Location.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Wgs84Location) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Wgs84Location.Merge(m, src)
}
func (m *Wgs84Location) XXX_Size() int {
	return m.Size()
}
func (m *Wgs84Location) XXX_DiscardUnknown() {
	xxx_messageInfo_Wgs84Location.DiscardUnknown(m)
}

var xxx_messageInfo_Wgs84Location proto.InternalMessageInfo

func (m *Wgs84Location) GetLatitudeDeg() float64 {
	if m != nil {
		return m.LatitudeDeg
	}
	return 0
}

func (m *Wgs84Location) GetLongitudeDeg() float64 {
	if m != nil {
		return m.LongitudeDeg
	}
	return 0
}

func (m *Wgs84Location) GetAltitudeM() float64 {
	if m != nil {
		return m.AltitudeM
	}
	return 0
}

// ECEF-compatible cartesian coordinates.
type CartesianLocation struct {
	// X, Y, and Z coordinates in meters.
	XM float64 `protobuf:"fixed64,1,opt,name=x_m,json=xM,proto3" json:"x_m,omitempty"`
	YM float64 `protobuf:"fixed64,2,opt,name=y_m,json=yM,proto3" json:"y_m,omitempty"`
	ZM float64 `protobuf:"fixed64,3,opt,name=z_m,json=zM,proto3" json:"z_m,omitempty"`
}

func (m *CartesianLocation) Reset()         { *m = CartesianLocation{} }
func (m *CartesianLocation) String() string { return proto.CompactTextString(m) }
func (*CartesianLocation) ProtoMessage()    {}
func (*CartesianLocation) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{2}
}
func (m *CartesianLocation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CartesianLocation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CartesianLocation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CartesianLocation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CartesianLocation.Merge(m, src)
}
func (m *CartesianLocation) XXX_Size() int {
	return m.Size()
}
func (m *CartesianLocation) XXX_DiscardUnknown() {
	xxx_messageInfo_CartesianLocation.DiscardUnknown(m)
}

var xxx_messageInfo_CartesianLocation proto.InternalMessageInfo

func (m *CartesianLocation) GetXM() float64 {
	if m != nil {
		return m.XM
	}
	return 0
}

func (m *CartesianLocation) GetYM() float64 {
	if m != nil {
		return m.YM
	}
	return 0
}

func (m *CartesianLocation) GetZM() float64 {
	if m != nil {
		return m.ZM
	}
	return 0
}

type AzElOrientation struct {
	// Azimuth angle in degrees.
	AzimuthDeg float64 `protobuf:"fixed64,1,opt,name=azimuth_deg,json=azimuthDeg,proto3" json:"azimuth_deg,omitempty"`
	// Elevation angle in degrees.
	ElevationDeg float64 `protobuf:"fixed64,2,opt,name=elevation_deg,json=elevationDeg,proto3" json:"elevation_deg,omitempty"`
	// Rotation around boresight in degrees.
	RotationDeg float64 `protobuf:"fixed64,3,opt,name=rotation_deg,json=rotationDeg,proto3" json:"rotation_deg,omitempty"`
}

func (m *AzElOrientation) Reset()         { *m = AzElOrientation{} }
func (m *AzElOrientation) String() string { return proto.CompactTextString(m) }
func (*AzElOrientation) ProtoMessage()    {}
func (*AzElOrientation) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{3}
}
func (m *AzElOrientation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AzElOrientation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AzElOrientation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AzElOrientation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AzElOrientation.Merge(m, src)
}
func (m *AzElOrientation) XXX_Size() int {
	return m.Size()
}
func (m *AzElOrientation) XXX_DiscardUnknown() {
	xxx_messageInfo_AzElOrientation.DiscardUnknown(m)
}

var xxx_messageInfo_AzElOrientation proto.InternalMessageInfo

func (m *AzElOrientation) GetAzimuthDeg() float64 {
	if m != nil {
		return m.AzimuthDeg
	}
	return 0
}

func (m *AzElOrientation) GetElevationDeg() float64 {
	if m != nil {
		return m.ElevationDeg
	}
	return 0
}

func (m *AzElOrientation) GetRotationDeg() float64 {
	if m != nil {
		return m.RotationDeg
	}
	return 0
}

type YprOrientation struct {
	// Yaw angle around z-axis.
	YawDeg float64 `protobuf:"fixed64,1,opt,name=yaw_deg,json=yawDeg,proto3" json:"yaw_deg,omitempty"`
	// Pitch angle around y-axix.
	PitchDeg float64 `protobuf:"fixed64,2,opt,name=pitch_deg,json=pitchDeg,proto3" json:"pitch_deg,omitempty"`
	// Roll angle around x-axis.
	RollDeg float64 `protobuf:"fixed64,3,opt,name=roll_deg,json=rollDeg,proto3" json:"roll_deg,omitempty"`
}

func (m *YprOrientation) Reset()         { *m = YprOrientation{} }
func (m *YprOrientation) String() string { return proto.CompactTextString(m) }
func (*YprOrientation) ProtoMessage()    {}
func (*YprOrientation) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{4}
}
func (m *YprOrientation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *YprOrientation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_YprOrientation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *YprOrientation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_YprOrientation.Merge(m, src)
}
func (m *YprOrientation) XXX_Size() int {
	return m.Size()
}
func (m *YprOrientation) XXX_DiscardUnknown() {
	xxx_messageInfo_YprOrientation.DiscardUnknown(m)
}

var xxx_messageInfo_YprOrientation proto.InternalMessageInfo

func (m *YprOrientation) GetYawDeg() float64 {
	if m != nil {
		return m.YawDeg
	}
	return 0
}

func (m *YprOrientation) GetPitchDeg() float64 {
	if m != nil {
		return m.PitchDeg
	}
	return 0
}

func (m *YprOrientation) GetRollDeg() float64 {
	if m != nil {
		return m.RollDeg
	}
	return 0
}

type Orientation struct {
	// Types that are valid to be assigned to Orientation:
	//	*Orientation_Azel
	//	*Orientation_Ypr
	Orientation isOrientation_Orientation `protobuf_oneof:"orientation"`
}

func (m *Orientation) Reset()         { *m = Orientation{} }
func (m *Orientation) String() string { return proto.CompactTextString(m) }
func (*Orientation) ProtoMessage()    {}
func (*Orientation) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{5}
}
func (m *Orientation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Orientation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Orientation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Orientation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Orientation.Merge(m, src)
}
func (m *Orientation) XXX_Size() int {
	return m.Size()
}
func (m *Orientation) XXX_DiscardUnknown() {
	xxx_messageInfo_Orientation.DiscardUnknown(m)
}

var xxx_messageInfo_Orientation proto.InternalMessageInfo

type isOrientation_Orientation interface {
	isOrientation_Orientation()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Orientation_Azel struct {
	Azel *AzElOrientation `protobuf:"bytes,1,opt,name=azel,proto3,oneof" json:"azel,omitempty"`
}
type Orientation_Ypr struct {
	Ypr *YprOrientation `protobuf:"bytes,2,opt,name=ypr,proto3,oneof" json:"ypr,omitempty"`
}

func (*Orientation_Azel) isOrientation_Orientation() {}
func (*Orientation_Ypr) isOrientation_Orientation()  {}

func (m *Orientation) GetOrientation() isOrientation_Orientation {
	if m != nil {
		return m.Orientation
	}
	return nil
}

func (m *Orientation) GetAzel() *AzElOrientation {
	if x, ok := m.GetOrientation().(*Orientation_Azel); ok {
		return x.Azel
	}
	return nil
}

func (m *Orientation) GetYpr() *YprOrientation {
	if x, ok := m.GetOrientation().(*Orientation_Ypr); ok {
		return x.Ypr
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Orientation) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Orientation_Azel)(nil),
		(*Orientation_Ypr)(nil),
	}
}

type Waypoint struct {
	Time     *types.Timestamp `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
	Location *Location        `protobuf:"bytes,2,opt,name=location,proto3" json:"location,omitempty"`
}

func (m *Waypoint) Reset()         { *m = Waypoint{} }
func (m *Waypoint) String() string { return proto.CompactTextString(m) }
func (*Waypoint) ProtoMessage()    {}
func (*Waypoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{6}
}
func (m *Waypoint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Waypoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Waypoint.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Waypoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Waypoint.Merge(m, src)
}
func (m *Waypoint) XXX_Size() int {
	return m.Size()
}
func (m *Waypoint) XXX_DiscardUnknown() {
	xxx_messageInfo_Waypoint.DiscardUnknown(m)
}

var xxx_messageInfo_Waypoint proto.InternalMessageInfo

func (m *Waypoint) GetTime() *types.Timestamp {
	if m != nil {
		return m.Time
	}
	return nil
}

func (m *Waypoint) GetLocation() *Location {
	if m != nil {
		return m.Location
	}
	return nil
}

// A set of waypoints that can be interpolated.
type Waypoints struct {
	Waypoint []*Waypoint `protobuf:"bytes,1,rep,name=waypoint,proto3" json:"waypoint,omitempty"`
}

func (m *Waypoints) Reset()         { *m = Waypoints{} }
func (m *Waypoints) String() string { return proto.CompactTextString(m) }
func (*Waypoints) ProtoMessage()    {}
func (*Waypoints) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{7}
}
func (m *Waypoints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Waypoints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Waypoints.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Waypoints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Waypoints.Merge(m, src)
}
func (m *Waypoints) XXX_Size() int {
	return m.Size()
}
func (m *Waypoints) XXX_DiscardUnknown() {
	xxx_messageInfo_Waypoints.DiscardUnknown(m)
}

var xxx_messageInfo_Waypoints proto.InternalMessageInfo

func (m *Waypoints) GetWaypoint() []*Waypoint {
	if m != nil {
		return m.Waypoint
	}
	return nil
}

// Minimal satellite orbit data, e.g. from a TLE, that can be propagated.
type OrbitData struct {
	Epoch *types.Timestamp `protobuf:"bytes,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
	// Orbit inclination in degrees.
	InclinationDeg float64 `protobuf:"fixed64,2,opt,name=inclination_deg,json=inclinationDeg,proto3" json:"inclination_deg,omitempty"`
	// Right ascension of the ascending node in degrees.
	RaanDeg float64 `protobuf:"fixed64,3,opt,name=raan_deg,json=raanDeg,proto3" json:"raan_deg,omitempty"`
	// Orbit eccentricity.
	E float64 `protobuf:"fixed64,4,opt,name=e,proto3" json:"e,omitempty"`
	// Argument of perigee in degrees.
	ArgumentDeg float64 `protobuf:"fixed64,5,opt,name=argument_deg,json=argumentDeg,proto3" json:"argument_deg,omitempty"`
	// Mean anomaly in degrees.
	AnomalyDeg float64 `protobuf:"fixed64,6,opt,name=anomaly_deg,json=anomalyDeg,proto3" json:"anomaly_deg,omitempty"`
	// Mean motion in revolutions per day.
	MeanMotion float64 `protobuf:"fixed64,7,opt,name=mean_motion,json=meanMotion,proto3" json:"mean_motion,omitempty"`
}

func (m *OrbitData) Reset()         { *m = OrbitData{} }
func (m *OrbitData) String() string { return proto.CompactTextString(m) }
func (*OrbitData) ProtoMessage()    {}
func (*OrbitData) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{8}
}
func (m *OrbitData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OrbitData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OrbitData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OrbitData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrbitData.Merge(m, src)
}
func (m *OrbitData) XXX_Size() int {
	return m.Size()
}
func (m *OrbitData) XXX_DiscardUnknown() {
	xxx_messageInfo_OrbitData.DiscardUnknown(m)
}

var xxx_messageInfo_OrbitData proto.InternalMessageInfo

func (m *OrbitData) GetEpoch() *types.Timestamp {
	if m != nil {
		return m.Epoch
	}
	return nil
}

func (m *OrbitData) GetInclinationDeg() float64 {
	if m != nil {
		return m.InclinationDeg
	}
	return 0
}

func (m *OrbitData) GetRaanDeg() float64 {
	if m != nil {
		return m.RaanDeg
	}
	return 0
}

func (m *OrbitData) GetE() float64 {
	if m != nil {
		return m.E
	}
	return 0
}

func (m *OrbitData) GetArgumentDeg() float64 {
	if m != nil {
		return m.ArgumentDeg
	}
	return 0
}

func (m *OrbitData) GetAnomalyDeg() float64 {
	if m != nil {
		return m.AnomalyDeg
	}
	return 0
}

func (m *OrbitData) GetMeanMotion() float64 {
	if m != nil {
		return m.MeanMotion
	}
	return 0
}

type Motion struct {
	// Types that are valid to be assigned to Motion:
	//	*Motion_FixedLocation
	//	*Motion_Waypoints
	//	*Motion_Orbit
	Motion isMotion_Motion `protobuf_oneof:"motion"`
}

func (m *Motion) Reset()         { *m = Motion{} }
func (m *Motion) String() string { return proto.CompactTextString(m) }
func (*Motion) ProtoMessage()    {}
func (*Motion) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{9}
}
func (m *Motion) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Motion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Motion.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Motion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Motion.Merge(m, src)
}
func (m *Motion) XXX_Size() int {
	return m.Size()
}
func (m *Motion) XXX_DiscardUnknown() {
	xxx_messageInfo_Motion.DiscardUnknown(m)
}

var xxx_messageInfo_Motion proto.InternalMessageInfo

type isMotion_Motion interface {
	isMotion_Motion()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Motion_FixedLocation struct {
	FixedLocation *Location `protobuf:"bytes,1,opt,name=fixed_location,json=fixedLocation,proto3,oneof" json:"fixed_location,omitempty"`
}
type Motion_Waypoints struct {
	Waypoints *Waypoints `protobuf:"bytes,2,opt,name=waypoints,proto3,oneof" json:"waypoints,omitempty"`
}
type Motion_Orbit struct {
	Orbit *OrbitData `protobuf:"bytes,3,opt,name=orbit,proto3,oneof" json:"orbit,omitempty"`
}

func (*Motion_FixedLocation) isMotion_Motion() {}
func (*Motion_Waypoints) isMotion_Motion()     {}
func (*Motion_Orbit) isMotion_Motion()         {}

func (m *Motion) GetMotion() isMotion_Motion {
	if m != nil {
		return m.Motion
	}
	return nil
}

func (m *Motion) GetFixedLocation() *Location {
	if x, ok := m.GetMotion().(*Motion_FixedLocation); ok {
		return x.FixedLocation
	}
	return nil
}

func (m *Motion) GetWaypoints() *Waypoints {
	if x, ok := m.GetMotion().(*Motion_Waypoints); ok {
		return x.Waypoints
	}
	return nil
}

func (m *Motion) GetOrbit() *OrbitData {
	if x, ok := m.GetMotion().(*Motion_Orbit); ok {
		return x.Orbit
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Motion) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Motion_FixedLocation)(nil),
		(*Motion_Waypoints)(nil),
		(*Motion_Orbit)(nil),
	}
}

// Area of coverage; expected value type of "coverage" aspect
type Coverage struct {
	Height   int32 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	ArcWidth int32 `protobuf:"varint,2,opt,name=arc_width,json=arcWidth,proto3" json:"arc_width,omitempty"`
	Azimuth  int32 `protobuf:"varint,3,opt,name=azimuth,proto3" json:"azimuth,omitempty"`
	Tilt     int32 `protobuf:"varint,4,opt,name=tilt,proto3" json:"tilt,omitempty"`
}

func (m *Coverage) Reset()         { *m = Coverage{} }
func (m *Coverage) String() string { return proto.CompactTextString(m) }
func (*Coverage) ProtoMessage()    {}
func (*Coverage) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{10}
}
func (m *Coverage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Coverage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Coverage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Coverage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Coverage.Merge(m, src)
}
func (m *Coverage) XXX_Size() int {
	return m.Size()
}
func (m *Coverage) XXX_DiscardUnknown() {
	xxx_messageInfo_Coverage.DiscardUnknown(m)
}

var xxx_messageInfo_Coverage proto.InternalMessageInfo

func (m *Coverage) GetHeight() int32 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *Coverage) GetArcWidth() int32 {
	if m != nil {
		return m.ArcWidth
	}
	return 0
}

func (m *Coverage) GetAzimuth() int32 {
	if m != nil {
		return m.Azimuth
	}
	return 0
}

func (m *Coverage) GetTilt() int32 {
	if m != nil {
		return m.Tilt
	}
	return 0
}

// E2Node aspect; expected value type of "E2NODE" aspect and expected on entities of "E2NODE" kind
type E2Node struct {
	ServiceModels map[string]*ServiceModelInfo `protobuf:"bytes,1,rep,name=service_models,json=serviceModels,proto3" json:"service_models,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *E2Node) Reset()         { *m = E2Node{} }
func (m *E2Node) String() string { return proto.CompactTextString(m) }
func (*E2Node) ProtoMessage()    {}
func (*E2Node) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{11}
}
func (m *E2Node) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *E2Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_E2Node.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *E2Node) XXX_Merge(src proto.Message) {
	xxx_messageInfo_E2Node.Merge(m, src)
}
func (m *E2Node) XXX_Size() int {
	return m.Size()
}
func (m *E2Node) XXX_DiscardUnknown() {
	xxx_messageInfo_E2Node.DiscardUnknown(m)
}

var xxx_messageInfo_E2Node proto.InternalMessageInfo

func (m *E2Node) GetServiceModels() map[string]*ServiceModelInfo {
	if m != nil {
		return m.ServiceModels
	}
	return nil
}

// E2NodeConfig aspect tracks the managed configuration for an E2 node
type E2NodeConfig struct {
	Connections []Interface `protobuf:"bytes,1,rep,name=connections,proto3" json:"connections"`
	Version     uint64      `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
}

func (m *E2NodeConfig) Reset()         { *m = E2NodeConfig{} }
func (m *E2NodeConfig) String() string { return proto.CompactTextString(m) }
func (*E2NodeConfig) ProtoMessage()    {}
func (*E2NodeConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{12}
}
func (m *E2NodeConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *E2NodeConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_E2NodeConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *E2NodeConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_E2NodeConfig.Merge(m, src)
}
func (m *E2NodeConfig) XXX_Size() int {
	return m.Size()
}
func (m *E2NodeConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_E2NodeConfig.DiscardUnknown(m)
}

var xxx_messageInfo_E2NodeConfig proto.InternalMessageInfo

func (m *E2NodeConfig) GetConnections() []Interface {
	if m != nil {
		return m.Connections
	}
	return nil
}

func (m *E2NodeConfig) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

// Lease aspect with an expiration timestamp for RAN entities
type Lease struct {
	Expiration *time.Time `protobuf:"bytes,1,opt,name=expiration,proto3,stdtime" json:"expiration,omitempty"`
}

func (m *Lease) Reset()         { *m = Lease{} }
func (m *Lease) String() string { return proto.CompactTextString(m) }
func (*Lease) ProtoMessage()    {}
func (*Lease) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{13}
}
func (m *Lease) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Lease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Lease.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Lease) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Lease.Merge(m, src)
}
func (m *Lease) XXX_Size() int {
	return m.Size()
}
func (m *Lease) XXX_DiscardUnknown() {
	xxx_messageInfo_Lease.DiscardUnknown(m)
}

var xxx_messageInfo_Lease proto.InternalMessageInfo

func (m *Lease) GetExpiration() *time.Time {
	if m != nil {
		return m.Expiration
	}
	return nil
}

// Interface determines address and type of an endpoint interface
type Interface struct {
	Type Interface_Type `protobuf:"varint,1,opt,name=type,proto3,enum=onos.topo.Interface_Type" json:"type,omitempty"`
	IP   string         `protobuf:"bytes,2,opt,name=ip,proto3" json:"ip,omitempty"`
	Port uint32         `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
}

func (m *Interface) Reset()         { *m = Interface{} }
func (m *Interface) String() string { return proto.CompactTextString(m) }
func (*Interface) ProtoMessage()    {}
func (*Interface) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{14}
}
func (m *Interface) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Interface) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Interface.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Interface) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Interface.Merge(m, src)
}
func (m *Interface) XXX_Size() int {
	return m.Size()
}
func (m *Interface) XXX_DiscardUnknown() {
	xxx_messageInfo_Interface.DiscardUnknown(m)
}

var xxx_messageInfo_Interface proto.InternalMessageInfo

func (m *Interface) GetType() Interface_Type {
	if m != nil {
		return m.Type
	}
	return Interface_INTERFACE_UNKNOWN
}

func (m *Interface) GetIP() string {
	if m != nil {
		return m.IP
	}
	return ""
}

func (m *Interface) GetPort() uint32 {
	if m != nil {
		return m.Port
	}
	return 0
}

// E2TInfo E2T aspect;
type E2TInfo struct {
	Interfaces []*Interface `protobuf:"bytes,1,rep,name=interfaces,proto3" json:"interfaces,omitempty"`
}

func (m *E2TInfo) Reset()         { *m = E2TInfo{} }
func (m *E2TInfo) String() string { return proto.CompactTextString(m) }
func (*E2TInfo) ProtoMessage()    {}
func (*E2TInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{15}
}
func (m *E2TInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *E2TInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_E2TInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *E2TInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_E2TInfo.Merge(m, src)
}
func (m *E2TInfo) XXX_Size() int {
	return m.Size()
}
func (m *E2TInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_E2TInfo.DiscardUnknown(m)
}

var xxx_messageInfo_E2TInfo proto.InternalMessageInfo

func (m *E2TInfo) GetInterfaces() []*Interface {
	if m != nil {
		return m.Interfaces
	}
	return nil
}

type XAppInfo struct {
	Interfaces    []*Interface    `protobuf:"bytes,1,rep,name=interfaces,proto3" json:"interfaces,omitempty"`
	A1PolicyTypes []*A1PolicyType `protobuf:"bytes,2,rep,name=a1_policy_types,json=a1PolicyTypes,proto3" json:"a1_policy_types,omitempty"`
}

func (m *XAppInfo) Reset()         { *m = XAppInfo{} }
func (m *XAppInfo) String() string { return proto.CompactTextString(m) }
func (*XAppInfo) ProtoMessage()    {}
func (*XAppInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{16}
}
func (m *XAppInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *XAppInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_XAppInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *XAppInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_XAppInfo.Merge(m, src)
}
func (m *XAppInfo) XXX_Size() int {
	return m.Size()
}
func (m *XAppInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_XAppInfo.DiscardUnknown(m)
}

var xxx_messageInfo_XAppInfo proto.InternalMessageInfo

func (m *XAppInfo) GetInterfaces() []*Interface {
	if m != nil {
		return m.Interfaces
	}
	return nil
}

func (m *XAppInfo) GetA1PolicyTypes() []*A1PolicyType {
	if m != nil {
		return m.A1PolicyTypes
	}
	return nil
}

type A1PolicyType struct {
	ID          PolicyTypeID          `protobuf:"bytes,1,opt,name=id,proto3,casttype=PolicyTypeID" json:"id,omitempty"`
	Name        PolicyTypeName        `protobuf:"bytes,2,opt,name=name,proto3,casttype=PolicyTypeName" json:"name,omitempty"`
	Version     PolicyTypeVersion     `protobuf:"bytes,3,opt,name=version,proto3,casttype=PolicyTypeVersion" json:"version,omitempty"`
	Description PolicyTypeDescription `protobuf:"bytes,4,opt,name=description,proto3,casttype=PolicyTypeDescription" json:"description,omitempty"`
}

func (m *A1PolicyType) Reset()         { *m = A1PolicyType{} }
func (m *A1PolicyType) String() string { return proto.CompactTextString(m) }
func (*A1PolicyType) ProtoMessage()    {}
func (*A1PolicyType) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{17}
}
func (m *A1PolicyType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *A1PolicyType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_A1PolicyType.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *A1PolicyType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_A1PolicyType.Merge(m, src)
}
func (m *A1PolicyType) XXX_Size() int {
	return m.Size()
}
func (m *A1PolicyType) XXX_DiscardUnknown() {
	xxx_messageInfo_A1PolicyType.DiscardUnknown(m)
}

var xxx_messageInfo_A1PolicyType proto.InternalMessageInfo

func (m *A1PolicyType) GetID() PolicyTypeID {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *A1PolicyType) GetName() PolicyTypeName {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *A1PolicyType) GetVersion() PolicyTypeVersion {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *A1PolicyType) GetDescription() PolicyTypeDescription {
	if m != nil {
		return m.Description
	}
	return ""
}

type A1TInfo struct {
	Interfaces []*Interface `protobuf:"bytes,1,rep,name=interfaces,proto3" json:"interfaces,omitempty"`
}

func (m *A1TInfo) Reset()         { *m = A1TInfo{} }
func (m *A1TInfo) String() string { return proto.CompactTextString(m) }
func (*A1TInfo) ProtoMessage()    {}
func (*A1TInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{18}
}
func (m *A1TInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *A1TInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_A1TInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *A1TInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_A1TInfo.Merge(m, src)
}
func (m *A1TInfo) XXX_Size() int {
	return m.Size()
}
func (m *A1TInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_A1TInfo.DiscardUnknown(m)
}

var xxx_messageInfo_A1TInfo proto.InternalMessageInfo

func (m *A1TInfo) GetInterfaces() []*Interface {
	if m != nil {
		return m.Interfaces
	}
	return nil
}

type CellGlobalID struct {
	Value string           `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Type  CellGlobalIDType `protobuf:"varint,2,opt,name=type,proto3,enum=onos.topo.CellGlobalIDType" json:"type,omitempty"`
}

func (m *CellGlobalID) Reset()         { *m = CellGlobalID{} }
func (m *CellGlobalID) String() string { return proto.CompactTextString(m) }
func (*CellGlobalID) ProtoMessage()    {}
func (*CellGlobalID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{19}
}
func (m *CellGlobalID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CellGlobalID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CellGlobalID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CellGlobalID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CellGlobalID.Merge(m, src)
}
func (m *CellGlobalID) XXX_Size() int {
	return m.Size()
}
func (m *CellGlobalID) XXX_DiscardUnknown() {
	xxx_messageInfo_CellGlobalID.DiscardUnknown(m)
}

var xxx_messageInfo_CellGlobalID proto.InternalMessageInfo

func (m *CellGlobalID) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *CellGlobalID) GetType() CellGlobalIDType {
	if m != nil {
		return m.Type
	}
	return CellGlobalIDType_NRCGI
}

type NeighborCellID struct {
	CellGlobalID *CellGlobalID `protobuf:"bytes,1,opt,name=cell_global_id,json=cellGlobalId,proto3" json:"cell_global_id,omitempty"`
	PlmnID       string        `protobuf:"bytes,2,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"`
}

func (m *NeighborCellID) Reset()         { *m = NeighborCellID{} }
func (m *NeighborCellID) String() string { return proto.CompactTextString(m) }
func (*NeighborCellID) ProtoMessage()    {}
func (*NeighborCellID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{20}
}
func (m *NeighborCellID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NeighborCellID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NeighborCellID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NeighborCellID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NeighborCellID.Merge(m, src)
}
func (m *NeighborCellID) XXX_Size() int {
	return m.Size()
}
func (m *NeighborCellID) XXX_DiscardUnknown() {
	xxx_messageInfo_NeighborCellID.DiscardUnknown(m)
}

var xxx_messageInfo_NeighborCellID proto.InternalMessageInfo

func (m *NeighborCellID) GetCellGlobalID() *CellGlobalID {
	if m != nil {
		return m.CellGlobalID
	}
	return nil
}

func (m *NeighborCellID) GetPlmnID() string {
	if m != nil {
		return m.PlmnID
	}
	return ""
}

// E2Cell aspect; expected value type of "E2CELL" aspect and expected on entities of "E2CELL" kind
type E2Cell struct {
	CellObjectID     string            `protobuf:"bytes,1,opt,name=cell_object_id,json=cellObjectId,proto3" json:"cell_object_id,omitempty"`
	CellGlobalID     *CellGlobalID     `protobuf:"bytes,2,opt,name=cell_global_id,json=cellGlobalId,proto3" json:"cell_global_id,omitempty"`
	AntennaCount     uint32            `protobuf:"varint,3,opt,name=antenna_count,json=antennaCount,proto3" json:"antenna_count,omitempty"`
	ARFCN            uint32            `protobuf:"varint,4,opt,name=arfcn,proto3" json:"arfcn,omitempty"`
	CellType         string            `protobuf:"bytes,5,opt,name=cell_type,json=cellType,proto3" json:"cell_type,omitempty"`
	PCI              uint32            `protobuf:"varint,6,opt,name=pci,proto3" json:"pci,omitempty"`
	KpiReports       map[string]uint32 `protobuf:"bytes,7,rep,name=kpi_reports,json=kpiReports,proto3" json:"kpi_reports,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	NeighborCellIDs  []*NeighborCellID `protobuf:"bytes,8,rep,name=neighbor_cell_ids,json=neighborCellIds,proto3" json:"neighbor_cell_ids,omitempty"`
	GnbDuId          uint32            `protobuf:"varint,9,opt,name=gnb_du_id,json=gnbDuId,proto3" json:"gnb_du_id,omitempty"`
	LatestRrcVersion uint32            `protobuf:"varint,10,opt,name=latest_rrc_version,json=latestRrcVersion,proto3" json:"latest_rrc_version,omitempty"`
	PlmnId           uint32            `protobuf:"varint,11,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"`
	ServedPlmns      []uint32          `protobuf:"varint,12,rep,packed,name=served_plmns,json=servedPlmns,proto3" json:"served_plmns,omitempty"`
	// Types that are valid to be assigned to NrModeInfo:
	//
	//	*E2Cell_FddInfo
	//	*E2Cell_TddInfo
	NrModeInfo                     isE2Cell_NrModeInfo      `protobuf_oneof:"nr_mode_info"`
	MeasurementTimingConfiguration uint32                   `protobuf:"varint,15,opt,name=measurement_timing_configuration,json=measurementTimingConfiguration,proto3" json:"measurement_timing_configuration,omitempty"`
	GlobalNgRanNodeId              *GlobalNgRanNodeID       `protobuf:"bytes,16,opt,name=global_ng_ran_node_id,json=globalNgRanNodeId,proto3" json:"global_ng_ran_node_id,omitempty"`
	TaiSupportList                 *TaiSupportList          `protobuf:"bytes,17,opt,name=tai_support_list,json=taiSupportList,proto3" json:"tai_support_list,omitempty"`
	AmfRegionInformation           *AmfRegionInformation    `protobuf:"bytes,18,opt,name=amf_region_information,json=amfRegionInformation,proto3" json:"amf_region_information,omitempty"`
	ConnectivitySupport            *ConnectivitySupport     `protobuf:"bytes,19,opt,name=connectivity_support,json=connectivitySupport,proto3" json:"connectivity_support,omitempty"`
	NeighborInformationNrs         []*NeighborInformationNr `protobuf:"bytes,20,rep,name=neighbor_information_nrs,json=neighborInformationNrs,proto3" json:"neighbor_information_nrs,omitempty"`
}

func (m *E2Cell) Reset()         { *m = E2Cell{} }
func (m *E2Cell) String() string { return proto.CompactTextString(m) }
func (*E2Cell) ProtoMessage()    {}
func (*E2Cell) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{21}
}
func (m *E2Cell) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *E2Cell) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_E2Cell.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *E2Cell) XXX_Merge(src proto.Message) {
	xxx_messageInfo_E2Cell.Merge(m, src)
}
func (m *E2Cell) XXX_Size() int {
	return m.Size()
}
func (m *E2Cell) XXX_DiscardUnknown() {
	xxx_messageInfo_E2Cell.DiscardUnknown(m)
}

var xxx_messageInfo_E2Cell proto.InternalMessageInfo

type isE2Cell_NrModeInfo interface {
	isE2Cell_NrModeInfo()
	MarshalTo([]byte) (int, error)
	Size() int
}

type E2Cell_FddInfo struct {
	FddInfo *FDDInfo `protobuf:"bytes,13,opt,name=fdd_info,json=fddInfo,proto3,oneof" json:"fdd_info,omitempty"`
}
type E2Cell_TddInfo struct {
	TddInfo *TDDInfo `protobuf:"bytes,14,opt,name=tdd_info,json=tddInfo,proto3,oneof" json:"tdd_info,omitempty"`
}

func (*E2Cell_FddInfo) isE2Cell_NrModeInfo() {}
func (*E2Cell_TddInfo) isE2Cell_NrModeInfo() {}

func (m *E2Cell) GetNrModeInfo() isE2Cell_NrModeInfo {
	if m != nil {
		return m.NrModeInfo
	}
	return nil
}

func (m *E2Cell) GetCellObjectID() string {
	if m != nil {
		return m.CellObjectID
	}
	return ""
}

func (m *E2Cell) GetCellGlobalID() *CellGlobalID {
	if m != nil {
		return m.CellGlobalID
	}
	return nil
}

func (m *E2Cell) GetAntennaCount() uint32 {
	if m != nil {
		return m.AntennaCount
	}
	return 0
}

func (m *E2Cell) GetARFCN() uint32 {
	if m != nil {
		return m.ARFCN
	}
	return 0
}

func (m *E2Cell) GetCellType() string {
	if m != nil {
		return m.CellType
	}
	return ""
}

func (m *E2Cell) GetPCI() uint32 {
	if m != nil {
		return m.PCI
	}
	return 0
}

func (m *E2Cell) GetKpiReports() map[string]uint32 {
	if m != nil {
		return m.KpiReports
	}
	return nil
}

func (m *E2Cell) GetNeighborCellIDs() []*NeighborCellID {
	if m != nil {
		return m.NeighborCellIDs
	}
	return nil
}

func (m *E2Cell) GetGnbDuId() uint32 {
	if m != nil {
		return m.GnbDuId
	}
	return 0
}

func (m *E2Cell) GetLatestRrcVersion() uint32 {
	if m != nil {
		return m.LatestRrcVersion
	}
	return 0
}

func (m *E2Cell) GetPlmnId() uint32 {
	if m != nil {
		return m.PlmnId
	}
	return 0
}

func (m *E2Cell) GetServedPlmns() []uint32 {
	if m != nil {
		return m.ServedPlmns
	}
	return nil
}

func (m *E2Cell) GetFddInfo() *FDDInfo {
	if x, ok := m.GetNrModeInfo().(*E2Cell_FddInfo); ok {
		return x.FddInfo
	}
	return nil
}

func (m *E2Cell) GetTddInfo() *TDDInfo {
	if x, ok := m.GetNrModeInfo().(*E2Cell_TddInfo); ok {
		return x.TddInfo
	}
	return nil
}

func (m *E2Cell) GetMeasurementTimingConfiguration() uint32 {
	if m != nil {
		return m.MeasurementTimingConfiguration
	}
	return 0
}

func (m *E2Cell) GetGlobalNgRanNodeId() *GlobalNgRanNodeID {
	if m != nil {
		return m.GlobalNgRanNodeId
	}
	return nil
}

func (m *E2Cell) GetTaiSupportList() *TaiSupportList {
	if m != nil {
		return m.TaiSupportList
	}
	return nil
}

func (m *E2Cell) GetAmfRegionInformation() *AmfRegionInformation {
	if m != nil {
		return m.AmfRegionInformation
	}
	return nil
}

func (m *E2Cell) GetConnectivitySupport() *ConnectivitySupport {
	if m != nil {
		return m.ConnectivitySupport
	}
	return nil
}

func (m *E2Cell) GetNeighborInformationNrs() []*NeighborInformationNr {
	if m != nil {
		return m.NeighborInformationNrs
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*E2Cell) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*E2Cell_FddInfo)(nil),
		(*E2Cell_TddInfo)(nil),
	}
}

type ConnectivitySupport struct {
	EnDcSupport EnDcSupport `protobuf:"varint,1,opt,name=en_dc_support,json=enDcSupport,proto3,enum=onos.topo.EnDcSupport" json:"en_dc_support,omitempty"`
}

func (m *ConnectivitySupport) Reset()         { *m = ConnectivitySupport{} }
func (m *ConnectivitySupport) String() string { return proto.CompactTextString(m) }
func (*ConnectivitySupport) ProtoMessage()    {}
func (*ConnectivitySupport) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{22}
}
func (m *ConnectivitySupport) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConnectivitySupport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConnectivitySupport.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConnectivitySupport) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectivitySupport.Merge(m, src)
}
func (m *ConnectivitySupport) XXX_Size() int {
	return m.Size()
}
func (m *ConnectivitySupport) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectivitySupport.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectivitySupport proto.InternalMessageInfo

func (m *ConnectivitySupport) GetEnDcSupport() EnDcSupport {
	if m != nil {
		return m.EnDcSupport
	}
	return EnDcSupport_EN_DC_SUPPORT_UNKNOWN
}

type FDDInfo struct {
	UlFreqInfo              *FrequencyInfo         `protobuf:"bytes,1,opt,name=ul_freq_info,json=ulFreqInfo,proto3" json:"ul_freq_info,omitempty"`
	DlFreqInfo              *FrequencyInfo         `protobuf:"bytes,2,opt,name=dl_freq_info,json=dlFreqInfo,proto3" json:"dl_freq_info,omitempty"`
	UlTransmissionBandwidth *TransmissionBandwidth `protobuf:"bytes,3,opt,name=ul_transmission_bandwidth,json=ulTransmissionBandwidth,proto3" json:"ul_transmission_bandwidth,omitempty"`
	DlTransmissionBandwidth *TransmissionBandwidth `protobuf:"bytes,4,opt,name=dl_transmission_bandwidth,json=dlTransmissionBandwidth,proto3" json:"dl_transmission_bandwidth,omitempty"`
}

func (m *FDDInfo) Reset()         { *m = FDDInfo{} }
func (m *FDDInfo) String() string { return proto.CompactTextString(m) }
func (*FDDInfo) ProtoMessage()    {}
func (*FDDInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{23}
}
func (m *FDDInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FDDInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FDDInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FDDInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FDDInfo.Merge(m, src)
}
func (m *FDDInfo) XXX_Size() int {
	return m.Size()
}
func (m *FDDInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_FDDInfo.DiscardUnknown(m)
}

var xxx_messageInfo_FDDInfo proto.InternalMessageInfo

func (m *FDDInfo) GetUlFreqInfo() *FrequencyInfo {
	if m != nil {
		return m.UlFreqInfo
	}
	return nil
}

func (m *FDDInfo) GetDlFreqInfo() *FrequencyInfo {
	if m != nil {
		return m.DlFreqInfo
	}
	return nil
}

func (m *FDDInfo) GetUlTransmissionBandwidth() *TransmissionBandwidth {
	if m != nil {
		return m.UlTransmissionBandwidth
	}
	return nil
}

func (m *FDDInfo) GetDlTransmissionBandwidth() *TransmissionBandwidth {
	if m != nil {
		return m.DlTransmissionBandwidth
	}
	return nil
}

type TDDInfo struct {
	NrFreqInfo            *FrequencyInfo         `protobuf:"bytes,1,opt,name=nr_freq_info,json=nrFreqInfo,proto3" json:"nr_freq_info,omitempty"`
	TransmissionBandwidth *TransmissionBandwidth `protobuf:"bytes,2,opt,name=transmission_bandwidth,json=transmissionBandwidth,proto3" json:"transmission_bandwidth,omitempty"`
}

func (m *TDDInfo) Reset()         { *m = TDDInfo{} }
func (m *TDDInfo) String() string { return proto.CompactTextString(m) }
func (*TDDInfo) ProtoMessage()    {}
func (*TDDInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{24}
}
func (m *TDDInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TDDInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TDDInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TDDInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TDDInfo.Merge(m, src)
}
func (m *TDDInfo) XXX_Size() int {
	return m.Size()
}
func (m *TDDInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TDDInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TDDInfo proto.InternalMessageInfo

func (m *TDDInfo) GetNrFreqInfo() *FrequencyInfo {
	if m != nil {
		return m.NrFreqInfo
	}
	return nil
}

func (m *TDDInfo) GetTransmissionBandwidth() *TransmissionBandwidth {
	if m != nil {
		return m.TransmissionBandwidth
	}
	return nil
}

type FrequencyInfo struct {
	NrArfcn           uint32             `protobuf:"varint,1,opt,name=nr_arfcn,json=nrArfcn,proto3" json:"nr_arfcn,omitempty"`
	FrequencyBandList *FrequencyBandList `protobuf:"bytes,2,opt,name=frequency_band_list,json=frequencyBandList,proto3" json:"frequency_band_list,omitempty"`
}

func (m *FrequencyInfo) Reset()         { *m = FrequencyInfo{} }
func (m *FrequencyInfo) String() string { return proto.CompactTextString(m) }
func (*FrequencyInfo) ProtoMessage()    {}
func (*FrequencyInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{25}
}
func (m *FrequencyInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FrequencyInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FrequencyInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FrequencyInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FrequencyInfo.Merge(m, src)
}
func (m *FrequencyInfo) XXX_Size() int {
	return m.Size()
}
func (m *FrequencyInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_FrequencyInfo.DiscardUnknown(m)
}

var xxx_messageInfo_FrequencyInfo proto.InternalMessageInfo

func (m *FrequencyInfo) GetNrArfcn() uint32 {
	if m != nil {
		return m.NrArfcn
	}
	return 0
}

func (m *FrequencyInfo) GetFrequencyBandList() *FrequencyBandList {
	if m != nil {
		return m.FrequencyBandList
	}
	return nil
}

type TransmissionBandwidth struct {
	NrScs NrScs `protobuf:"varint,1,opt,name=nr_scs,json=nrScs,proto3,enum=onos.topo.NrScs" json:"nr_scs,omitempty"`
	Nrb   Nrb   `protobuf:"varint,2,opt,name=nrb,proto3,enum=onos.topo.Nrb" json:"nrb,omitempty"`
}

func (m *TransmissionBandwidth) Reset()         { *m = TransmissionBandwidth{} }
func (m *TransmissionBandwidth) String() string { return proto.CompactTextString(m) }
func (*TransmissionBandwidth) ProtoMessage()    {}
func (*TransmissionBandwidth) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{26}
}
func (m *TransmissionBandwidth) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TransmissionBandwidth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransmissionBandwidth.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TransmissionBandwidth) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransmissionBandwidth.Merge(m, src)
}
func (m *TransmissionBandwidth) XXX_Size() int {
	return m.Size()
}
func (m *TransmissionBandwidth) XXX_DiscardUnknown() {
	xxx_messageInfo_TransmissionBandwidth.DiscardUnknown(m)
}

var xxx_messageInfo_TransmissionBandwidth proto.InternalMessageInfo

func (m *TransmissionBandwidth) GetNrScs() NrScs {
	if m != nil {
		return m.NrScs
	}
	return NrScs_SCS_UNKNOWN
}

func (m *TransmissionBandwidth) GetNrb() Nrb {
	if m != nil {
		return m.Nrb
	}
	return Nrb_NRB_UNKNOWN
}

type FrequencyBandList struct {
	FrequencyBandItems []*FrequencyBandItem `protobuf:"bytes,1,rep,name=frequency_band_items,json=frequencyBandItems,proto3" json:"frequency_band_items,omitempty"`
}

func (m *FrequencyBandList) Reset()         { *m = FrequencyBandList{} }
func (m *FrequencyBandList) String() string { return proto.CompactTextString(m) }
func (*FrequencyBandList) ProtoMessage()    {}
func (*FrequencyBandList) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{27}
}
func (m *FrequencyBandList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FrequencyBandList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FrequencyBandList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FrequencyBandList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FrequencyBandList.Merge(m, src)
}
func (m *FrequencyBandList) XXX_Size() int {
	return m.Size()
}
func (m *FrequencyBandList) XXX_DiscardUnknown() {
	xxx_messageInfo_FrequencyBandList.DiscardUnknown(m)
}

var xxx_messageInfo_FrequencyBandList proto.InternalMessageInfo

func (m *FrequencyBandList) GetFrequencyBandItems() []*FrequencyBandItem {
	if m != nil {
		return m.FrequencyBandItems
	}
	return nil
}

type FrequencyBandItem struct {
	NrFrequencyBand uint32 `protobuf:"varint,1,opt,name=nr_frequency_band,json=nrFrequencyBand,proto3" json:"nr_frequency_band,omitempty"`
}

func (m *FrequencyBandItem) Reset()         { *m = FrequencyBandItem{} }
func (m *FrequencyBandItem) String() string { return proto.CompactTextString(m) }
func (*FrequencyBandItem) ProtoMessage()    {}
func (*FrequencyBandItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{28}
}
func (m *FrequencyBandItem) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FrequencyBandItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FrequencyBandItem.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FrequencyBandItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FrequencyBandItem.Merge(m, src)
}
func (m *FrequencyBandItem) XXX_Size() int {
	return m.Size()
}
func (m *FrequencyBandItem) XXX_DiscardUnknown() {
	xxx_messageInfo_FrequencyBandItem.DiscardUnknown(m)
}

var xxx_messageInfo_FrequencyBandItem proto.InternalMessageInfo

func (m *FrequencyBandItem) GetNrFrequencyBand() uint32 {
	if m != nil {
		return m.NrFrequencyBand
	}
	return 0
}

type GlobalNgRanNodeID struct {
	// Types that are valid to be assigned to GlobalNgRanNodeId:
	//
	//	*GlobalNgRanNodeID_GlobalGnbId
	//	*GlobalNgRanNodeID_GlobalNgEnbId
	GlobalNgRanNodeId isGlobalNgRanNodeID_GlobalNgRanNodeId `protobuf_oneof:"global_ng_ran_node_id"`
}

func (m *GlobalNgRanNodeID) Reset()         { *m = GlobalNgRanNodeID{} }
func (m *GlobalNgRanNodeID) String() string { return proto.CompactTextString(m) }
func (*GlobalNgRanNodeID) ProtoMessage()    {}
func (*GlobalNgRanNodeID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{29}
}
func (m *GlobalNgRanNodeID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalNgRanNodeID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalNgRanNodeID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GlobalNgRanNodeID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalNgRanNodeID.Merge(m, src)
}
func (m *GlobalNgRanNodeID) XXX_Size() int {
	return m.Size()
}
func (m *GlobalNgRanNodeID) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalNgRanNodeID.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalNgRanNodeID proto.InternalMessageInfo

type isGlobalNgRanNodeID_GlobalNgRanNodeId interface {
	isGlobalNgRanNodeID_GlobalNgRanNodeId()
	MarshalTo([]byte) (int, error)
	Size() int
}

type GlobalNgRanNodeID_GlobalGnbId struct {
	GlobalGnbId *GlobalGnbID `protobuf:"bytes,1,opt,name=global_gnb_id,json=globalGnbId,proto3,oneof" json:"global_gnb_id,omitempty"`
}
type GlobalNgRanNodeID_GlobalNgEnbId struct {
	GlobalNgEnbId *GlobalNgEnbID `protobuf:"bytes,2,opt,name=global_ng_enb_id,json=globalNgEnbId,proto3,oneof" json:"global_ng_enb_id,omitempty"`
}

func (*GlobalNgRanNodeID_GlobalGnbId) isGlobalNgRanNodeID_GlobalNgRanNodeId()   {}
func (*GlobalNgRanNodeID_GlobalNgEnbId) isGlobalNgRanNodeID_GlobalNgRanNodeId() {}

func (m *GlobalNgRanNodeID) GetGlobalNgRanNodeId() isGlobalNgRanNodeID_GlobalNgRanNodeId {
	if m != nil {
		return m.GlobalNgRanNodeId
	}
	return nil
}

func (m *GlobalNgRanNodeID) GetGlobalGnbId() *GlobalGnbID {
	if x, ok := m.GetGlobalNgRanNodeId().(*GlobalNgRanNodeID_GlobalGnbId); ok {
		return x.GlobalGnbId
	}
	return nil
}

func (m *GlobalNgRanNodeID) GetGlobalNgEnbId() *GlobalNgEnbID {
	if x, ok := m.GetGlobalNgRanNodeId().(*GlobalNgRanNodeID_GlobalNgEnbId); ok {
		return x.GlobalNgEnbId
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GlobalNgRanNodeID) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GlobalNgRanNodeID_GlobalGnbId)(nil),
		(*GlobalNgRanNodeID_GlobalNgEnbId)(nil),
	}
}

type GlobalGnbID struct {
	PlmnId   uint32 `protobuf:"varint,1,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"`
	GnbId    uint32 `protobuf:"varint,2,opt,name=gnb_id,json=gnbId,proto3" json:"gnb_id,omitempty"`
	GnbIdLen uint32 `protobuf:"varint,3,opt,name=gnb_id_len,json=gnbIdLen,proto3" json:"gnb_id_len,omitempty"`
}

func (m *GlobalGnbID) Reset()         { *m = GlobalGnbID{} }
func (m *GlobalGnbID) String() string { return proto.CompactTextString(m) }
func (*GlobalGnbID) ProtoMessage()    {}
func (*GlobalGnbID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{30}
}
func (m *GlobalGnbID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalGnbID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalGnbID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GlobalGnbID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalGnbID.Merge(m, src)
}
func (m *GlobalGnbID) XXX_Size() int {
	return m.Size()
}
func (m *GlobalGnbID) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalGnbID.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalGnbID proto.InternalMessageInfo

func (m *GlobalGnbID) GetPlmnId() uint32 {
	if m != nil {
		return m.PlmnId
	}
	return 0
}

func (m *GlobalGnbID) GetGnbId() uint32 {
	if m != nil {
		return m.GnbId
	}
	return 0
}

func (m *GlobalGnbID) GetGnbIdLen() uint32 {
	if m != nil {
		return m.GnbIdLen
	}
	return 0
}

type GlobalNgEnbID struct {
	PlmnId uint32 `protobuf:"varint,1,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"`
	// Types that are valid to be assigned to NgEnbId:
	//
	//	*GlobalNgEnbID_MacroNgEnbId
	//	*GlobalNgEnbID_ShortMacroNgEnbId
	//	*GlobalNgEnbID_LongMacroNgEnbId
	NgEnbId isGlobalNgEnbID_NgEnbId `protobuf_oneof:"ng_enb_id"`
}

func (m *GlobalNgEnbID) Reset()         { *m = GlobalNgEnbID{} }
func (m *GlobalNgEnbID) String() string { return proto.CompactTextString(m) }
func (*GlobalNgEnbID) ProtoMessage()    {}
func (*GlobalNgEnbID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{31}
}
func (m *GlobalNgEnbID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalNgEnbID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalNgEnbID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GlobalNgEnbID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalNgEnbID.Merge(m, src)
}
func (m *GlobalNgEnbID) XXX_Size() int {
	return m.Size()
}
func (m *GlobalNgEnbID) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalNgEnbID.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalNgEnbID proto.InternalMessageInfo

type isGlobalNgEnbID_NgEnbId interface {
	isGlobalNgEnbID_NgEnbId()
	MarshalTo([]byte) (int, error)
	Size() int
}

type GlobalNgEnbID_MacroNgEnbId struct {
	MacroNgEnbId uint32 `protobuf:"varint,2,opt,name=macro_ng_enb_id,json=macroNgEnbId,proto3,oneof" json:"macro_ng_enb_id,omitempty"`
}
type GlobalNgEnbID_ShortMacroNgEnbId struct {
	ShortMacroNgEnbId uint32 `protobuf:"varint,3,opt,name=short_macro_ng_enb_id,json=shortMacroNgEnbId,proto3,oneof" json:"short_macro_ng_enb_id,omitempty"`
}
type GlobalNgEnbID_LongMacroNgEnbId struct {
	LongMacroNgEnbId uint32 `protobuf:"varint,4,opt,name=long_macro_ng_enb_id,json=longMacroNgEnbId,proto3,oneof" json:"long_macro_ng_enb_id,omitempty"`
}

func (*GlobalNgEnbID_MacroNgEnbId) isGlobalNgEnbID_NgEnbId()      {}
func (*GlobalNgEnbID_ShortMacroNgEnbId) isGlobalNgEnbID_NgEnbId() {}
func (*GlobalNgEnbID_LongMacroNgEnbId) isGlobalNgEnbID_NgEnbId()  {}

func (m *GlobalNgEnbID) GetNgEnbId() isGlobalNgEnbID_NgEnbId {
	if m != nil {
		return m.NgEnbId
	}
	return nil
}

func (m *GlobalNgEnbID) GetPlmnId() uint32 {
	if m != nil {
		return m.PlmnId
	}
	return 0
}

func (m *GlobalNgEnbID) GetMacroNgEnbId() uint32 {
	if x, ok := m.GetNgEnbId().(*GlobalNgEnbID_MacroNgEnbId); ok {
		return x.MacroNgEnbId
	}
	return 0
}

func (m *GlobalNgEnbID) GetShortMacroNgEnbId() uint32 {
	if x, ok := m.GetNgEnbId().(*GlobalNgEnbID_ShortMacroNgEnbId); ok {
		return x.ShortMacroNgEnbId
	}
	return 0
}

func (m *GlobalNgEnbID) GetLongMacroNgEnbId() uint32 {
	if x, ok := m.GetNgEnbId().(*GlobalNgEnbID_LongMacroNgEnbId); ok {
		return x.LongMacroNgEnbId
	}
	return 0
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GlobalNgEnbID) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GlobalNgEnbID_MacroNgEnbId)(nil),
		(*GlobalNgEnbID_ShortMacroNgEnbId)(nil),
		(*GlobalNgEnbID_LongMacroNgEnbId)(nil),
	}
}

type TaiSupportList struct {
	TaiSupportItems []*TaiSupportItem `protobuf:"bytes,1,rep,name=tai_support_items,json=taiSupportItems,proto3" json:"tai_support_items,omitempty"`
}

func (m *TaiSupportList) Reset()         { *m = TaiSupportList{} }
func (m *TaiSupportList) String() string { return proto.CompactTextString(m) }
func (*TaiSupportList) ProtoMessage()    {}
func (*TaiSupportList) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{32}
}
func (m *TaiSupportList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TaiSupportList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TaiSupportList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TaiSupportList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaiSupportList.Merge(m, src)
}
func (m *TaiSupportList) XXX_Size() int {
	return m.Size()
}
func (m *TaiSupportList) XXX_DiscardUnknown() {
	xxx_messageInfo_TaiSupportList.DiscardUnknown(m)
}

var xxx_messageInfo_TaiSupportList proto.InternalMessageInfo

func (m *TaiSupportList) GetTaiSupportItems() []*TaiSupportItem {
	if m != nil {
		return m.TaiSupportItems
	}
	return nil
}

type TaiSupportItem struct {
	Tac            uint32             `protobuf:"varint,1,opt,name=tac,proto3" json:"tac,omitempty"`
	BroadcastPlmns []*XnBroadcastPlmn `protobuf:"bytes,2,rep,name=broadcast_plmns,json=broadcastPlmns,proto3" json:"broadcast_plmns,omitempty"`
}

func (m *TaiSupportItem) Reset()         { *m = TaiSupportItem{} }
func (m *TaiSupportItem) String() string { return proto.CompactTextString(m) }
func (*TaiSupportItem) ProtoMessage()    {}
func (*TaiSupportItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{33}
}
func (m *TaiSupportItem) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TaiSupportItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TaiSupportItem.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TaiSupportItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaiSupportItem.Merge(m, src)
}
func (m *TaiSupportItem) XXX_Size() int {
	return m.Size()
}
func (m *TaiSupportItem) XXX_DiscardUnknown() {
	xxx_messageInfo_TaiSupportItem.DiscardUnknown(m)
}

var xxx_messageInfo_TaiSupportItem proto.InternalMessageInfo

func (m *TaiSupportItem) GetTac() uint32 {
	if m != nil {
		return m.Tac
	}
	return 0
}

func (m *TaiSupportItem) GetBroadcastPlmns() []*XnBroadcastPlmn {
	if m != nil {
		return m.BroadcastPlmns
	}
	return nil
}

type XnBroadcastPlmn struct {
	PlmnId              uint32               `protobuf:"varint,1,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"`
	TaiSliceSupportList *TaiSliceSupportList `protobuf:"bytes,2,opt,name=tai_slice_support_list,json=taiSliceSupportList,proto3" json:"tai_slice_support_list,omitempty"`
}

func (m *XnBroadcastPlmn) Reset()         { *m = XnBroadcastPlmn{} }
func (m *XnBroadcastPlmn) String() string { return proto.CompactTextString(m) }
func (*XnBroadcastPlmn) ProtoMessage()    {}
func (*XnBroadcastPlmn) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{34}
}
func (m *XnBroadcastPlmn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *XnBroadcastPlmn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_XnBroadcastPlmn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *XnBroadcastPlmn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_XnBroadcastPlmn.Merge(m, src)
}
func (m *XnBroadcastPlmn) XXX_Size() int {
	return m.Size()
}
func (m *XnBroadcastPlmn) XXX_DiscardUnknown() {
	xxx_messageInfo_XnBroadcastPlmn.DiscardUnknown(m)
}

var xxx_messageInfo_XnBroadcastPlmn proto.InternalMessageInfo

func (m *XnBroadcastPlmn) GetPlmnId() uint32 {
	if m != nil {
		return m.PlmnId
	}
	return 0
}

func (m *XnBroadcastPlmn) GetTaiSliceSupportList() *TaiSliceSupportList {
	if m != nil {
		return m.TaiSliceSupportList
	}
	return nil
}

type TaiSliceSupportList struct {
	SliceSupportItems []*SliceSupportItem `protobuf:"bytes,1,rep,name=slice_support_items,json=sliceSupportItems,proto3" json:"slice_support_items,omitempty"`
}

func (m *TaiSliceSupportList) Reset()         { *m = TaiSliceSupportList{} }
func (m *TaiSliceSupportList) String() string { return proto.CompactTextString(m) }
func (*TaiSliceSupportList) ProtoMessage()    {}
func (*TaiSliceSupportList) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{35}
}
func (m *TaiSliceSupportList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TaiSliceSupportList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TaiSliceSupportList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TaiSliceSupportList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaiSliceSupportList.Merge(m, src)
}
func (m *TaiSliceSupportList) XXX_Size() int {
	return m.Size()
}
func (m *TaiSliceSupportList) XXX_DiscardUnknown() {
	xxx_messageInfo_TaiSliceSupportList.DiscardUnknown(m)
}

var xxx_messageInfo_TaiSliceSupportList proto.InternalMessageInfo

func (m *TaiSliceSupportList) GetSliceSupportItems() []*SliceSupportItem {
	if m != nil {
		return m.SliceSupportItems
	}
	return nil
}

type SliceSupportItem struct {
	SNssai *SNssai `protobuf:"bytes,1,opt,name=s_nssai,json=sNssai,proto3" json:"s_nssai,omitempty"`
}

func (m *SliceSupportItem) Reset()         { *m = SliceSupportItem{} }
func (m *SliceSupportItem) String() string { return proto.CompactTextString(m) }
func (*SliceSupportItem) ProtoMessage()    {}
func (*SliceSupportItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{36}
}
func (m *SliceSupportItem) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SliceSupportItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SliceSupportItem.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SliceSupportItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SliceSupportItem.Merge(m, src)
}
func (m *SliceSupportItem) XXX_Size() int {
	return m.Size()
}
func (m *SliceSupportItem) XXX_DiscardUnknown() {
	xxx_messageInfo_SliceSupportItem.DiscardUnknown(m)
}

var xxx_messageInfo_SliceSupportItem proto.InternalMessageInfo

func (m *SliceSupportItem) GetSNssai() *SNssai {
	if m != nil {
		return m.SNssai
	}
	return nil
}

type SNssai struct {
	Sst uint32 `protobuf:"varint,1,opt,name=sst,proto3" json:"sst,omitempty"`
	Sd  uint32 `protobuf:"varint,2,opt,name=sd,proto3" json:"sd,omitempty"`
}

func (m *SNssai) Reset()         { *m = SNssai{} }
func (m *SNssai) String() string { return proto.CompactTextString(m) }
func (*SNssai) ProtoMessage()    {}
func (*SNssai) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{37}
}
func (m *SNssai) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SNssai) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SNssai.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SNssai) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SNssai.Merge(m, src)
}
func (m *SNssai) XXX_Size() int {
	return m.Size()
}
func (m *SNssai) XXX_DiscardUnknown() {
	xxx_messageInfo_SNssai.DiscardUnknown(m)
}

var xxx_messageInfo_SNssai proto.InternalMessageInfo

func (m *SNssai) GetSst() uint32 {
	if m != nil {
		return m.Sst
	}
	return 0
}

func (m *SNssai) GetSd() uint32 {
	if m != nil {
		return m.Sd
	}
	return 0
}

type AmfRegionInformation struct {
	GlobalAmfRegionInformationItems []*GlobalAmfRegionInformationItem `protobuf:"bytes,1,rep,name=global_amf_region_information_items,json=globalAmfRegionInformationItems,proto3" json:"global_amf_region_information_items,omitempty"`
}

func (m *AmfRegionInformation) Reset()         { *m = AmfRegionInformation{} }
func (m *AmfRegionInformation) String() string { return proto.CompactTextString(m) }
func (*AmfRegionInformation) ProtoMessage()    {}
func (*AmfRegionInformation) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{38}
}
func (m *AmfRegionInformation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AmfRegionInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AmfRegionInformation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AmfRegionInformation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AmfRegionInformation.Merge(m, src)
}
func (m *AmfRegionInformation) XXX_Size() int {
	return m.Size()
}
func (m *AmfRegionInformation) XXX_DiscardUnknown() {
	xxx_messageInfo_AmfRegionInformation.DiscardUnknown(m)
}

var xxx_messageInfo_AmfRegionInformation proto.InternalMessageInfo

func (m *AmfRegionInformation) GetGlobalAmfRegionInformationItems() []*GlobalAmfRegionInformationItem {
	if m != nil {
		return m.GlobalAmfRegionInformationItems
	}
	return nil
}

type GlobalAmfRegionInformationItem struct {
	PlmnId      uint32 `protobuf:"varint,1,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"`
	AmfRegionId uint32 `protobuf:"varint,2,opt,name=amf_region_id,json=amfRegionId,proto3" json:"amf_region_id,omitempty"`
}

func (m *GlobalAmfRegionInformationItem) Reset()         { *m = GlobalAmfRegionInformationItem{} }
func (m *GlobalAmfRegionInformationItem) String() string { return proto.CompactTextString(m) }
func (*GlobalAmfRegionInformationItem) ProtoMessage()    {}
func (*GlobalAmfRegionInformationItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{39}
}
func (m *GlobalAmfRegionInformationItem) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GlobalAmfRegionInformationItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GlobalAmfRegionInformationItem.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GlobalAmfRegionInformationItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GlobalAmfRegionInformationItem.Merge(m, src)
}
func (m *GlobalAmfRegionInformationItem) XXX_Size() int {
	return m.Size()
}
func (m *GlobalAmfRegionInformationItem) XXX_DiscardUnknown() {
	xxx_messageInfo_GlobalAmfRegionInformationItem.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalAmfRegionInformationItem proto.InternalMessageInfo

func (m *GlobalAmfRegionInformationItem) GetPlmnId() uint32 {
	if m != nil {
		return m.PlmnId
	}
	return 0
}

func (m *GlobalAmfRegionInformationItem) GetAmfRegionId() uint32 {
	if m != nil {
		return m.AmfRegionId
	}
	return 0
}

type NeighborInformationNr struct {
	Pci   uint32          `protobuf:"varint,1,opt,name=pci,proto3" json:"pci,omitempty"`
	NrCgi *NeighborCellID `protobuf:"bytes,2,opt,name=nr_cgi,json=nrCgi,proto3" json:"nr_cgi,omitempty"`
	Tac   uint32          `protobuf:"varint,3,opt,name=tac,proto3" json:"tac,omitempty"`
	// Types that are valid to be assigned to NrModeInfo:
	//
	//	*NeighborInformationNr_FddInfo
	//	*NeighborInformationNr_TddInfo
	NrModeInfo                     isNeighborInformationNr_NrModeInfo `protobuf_oneof:"nr_mode_info"`
	ConnectivitySupport            *ConnectivitySupport               `protobuf:"bytes,6,opt,name=connectivity_support,json=connectivitySupport,proto3" json:"connectivity_support,omitempty"`
	MeasurementTimingConfiguration uint32                             `protobuf:"varint,7,opt,name=measurement_timing_configuration,json=measurementTimingConfiguration,proto3" json:"measurement_timing_configuration,omitempty"`
}

func (m *NeighborInformationNr) Reset()         { *m = NeighborInformationNr{} }
func (m *NeighborInformationNr) String() string { return proto.CompactTextString(m) }
func (*NeighborInformationNr) ProtoMessage()    {}
func (*NeighborInformationNr) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{40}
}
func (m *NeighborInformationNr) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NeighborInformationNr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NeighborInformationNr.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NeighborInformationNr) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NeighborInformationNr.Merge(m, src)
}
func (m *NeighborInformationNr) XXX_Size() int {
	return m.Size()
}
func (m *NeighborInformationNr) XXX_DiscardUnknown() {
	xxx_messageInfo_NeighborInformationNr.DiscardUnknown(m)
}

var xxx_messageInfo_NeighborInformationNr proto.InternalMessageInfo

type isNeighborInformationNr_NrModeInfo interface {
	isNeighborInformationNr_NrModeInfo()
	MarshalTo([]byte) (int, error)
	Size() int
}

type NeighborInformationNr_FddInfo struct {
	FddInfo *FDDInfo `protobuf:"bytes,4,opt,name=fdd_info,json=fddInfo,proto3,oneof" json:"fdd_info,omitempty"`
}
type NeighborInformationNr_TddInfo struct {
	TddInfo *TDDInfo `protobuf:"bytes,5,opt,name=tdd_info,json=tddInfo,proto3,oneof" json:"tdd_info,omitempty"`
}

func (*NeighborInformationNr_FddInfo) isNeighborInformationNr_NrModeInfo() {}
func (*NeighborInformationNr_TddInfo) isNeighborInformationNr_NrModeInfo() {}

func (m *NeighborInformationNr) GetNrModeInfo() isNeighborInformationNr_NrModeInfo {
	if m != nil {
		return m.NrModeInfo
	}
	return nil
}

func (m *NeighborInformationNr) GetPci() uint32 {
	if m != nil {
		return m.Pci
	}
	return 0
}

func (m *NeighborInformationNr) GetNrCgi() *NeighborCellID {
	if m != nil {
		return m.NrCgi
	}
	return nil
}

func (m *NeighborInformationNr) GetTac() uint32 {
	if m != nil {
		return m.Tac
	}
	return 0
}

func (m *NeighborInformationNr) GetFddInfo() *FDDInfo {
	if x, ok := m.GetNrModeInfo().(*NeighborInformationNr_FddInfo); ok {
		return x.FddInfo
	}
	return nil
}

func (m *NeighborInformationNr) GetTddInfo() *TDDInfo {
	if x, ok := m.GetNrModeInfo().(*NeighborInformationNr_TddInfo); ok {
		return x.TddInfo
	}
	return nil
}

func (m *NeighborInformationNr) GetConnectivitySupport() *ConnectivitySupport {
	if m != nil {
		return m.ConnectivitySupport
	}
	return nil
}

func (m *NeighborInformationNr) GetMeasurementTimingConfiguration() uint32 {
	if m != nil {
		return m.MeasurementTimingConfiguration
	}
	return 0
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*NeighborInformationNr) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*NeighborInformationNr_FddInfo)(nil),
		(*NeighborInformationNr_TddInfo)(nil),
	}
}

type ServiceModelInfo struct {
	OID            string       `protobuf:"bytes,1,opt,name=oid,proto3" json:"oid,omitempty"`
	Name           string       `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	RanFunctions   []*types.Any `protobuf:"bytes,3,rep,name=ran_functions,json=ranFunctions,proto3" json:"ran_functions,omitempty"`
	RanFunctionIDs []uint32     `protobuf:"varint,4,rep,packed,name=ranFunctionIDs,proto3" json:"ranFunctionIDs,omitempty"`
}

func (m *ServiceModelInfo) Reset()         { *m = ServiceModelInfo{} }
func (m *ServiceModelInfo) String() string { return proto.CompactTextString(m) }
func (*ServiceModelInfo) ProtoMessage()    {}
func (*ServiceModelInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{41}
}
func (m *ServiceModelInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ServiceModelInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ServiceModelInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ServiceModelInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceModelInfo.Merge(m, src)
}
func (m *ServiceModelInfo) XXX_Size() int {
	return m.Size()
}
func (m *ServiceModelInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceModelInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceModelInfo proto.InternalMessageInfo

func (m *ServiceModelInfo) GetOID() string {
	if m != nil {
		return m.OID
	}
	return ""
}

func (m *ServiceModelInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ServiceModelInfo) GetRanFunctions() []*types.Any {
	if m != nil {
		return m.RanFunctions
	}
	return nil
}

func (m *ServiceModelInfo) GetRanFunctionIDs() []uint32 {
	if m != nil {
		return m.RanFunctionIDs
	}
	return nil
}

type RCRanFunction struct {
	ID                 string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ReportStyles       []*RCReportStyle       `protobuf:"bytes,2,rep,name=report_styles,json=reportStyles,proto3" json:"report_styles,omitempty"`
	InsertStyles       []*RCInsertStyle       `protobuf:"bytes,3,rep,name=insert_styles,json=insertStyles,proto3" json:"insert_styles,omitempty"`
	EventTriggerStyles []*RCEventTriggerStyle `protobuf:"bytes,4,rep,name=event_trigger_styles,json=eventTriggerStyles,proto3" json:"event_trigger_styles,omitempty"`
	PolicyStyles       []*RCPolicyStyle       `protobuf:"bytes,5,rep,name=policy_styles,json=policyStyles,proto3" json:"policy_styles,omitempty"`
	ControlStyles      []*RCControlStyle      `protobuf:"bytes,6,rep,name=control_styles,json=controlStyles,proto3" json:"control_styles,omitempty"`
}

func (m *RCRanFunction) Reset()         { *m = RCRanFunction{} }
func (m *RCRanFunction) String() string { return proto.CompactTextString(m) }
func (*RCRanFunction) ProtoMessage()    {}
func (*RCRanFunction) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{42}
}
func (m *RCRanFunction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RCRanFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RCRanFunction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RCRanFunction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RCRanFunction.Merge(m, src)
}
func (m *RCRanFunction) XXX_Size() int {
	return m.Size()
}
func (m *RCRanFunction) XXX_DiscardUnknown() {
	xxx_messageInfo_RCRanFunction.DiscardUnknown(m)
}

var xxx_messageInfo_RCRanFunction proto.InternalMessageInfo

func (m *RCRanFunction) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *RCRanFunction) GetReportStyles() []*RCReportStyle {
	if m != nil {
		return m.ReportStyles
	}
	return nil
}

func (m *RCRanFunction) GetInsertStyles() []*RCInsertStyle {
	if m != nil {
		return m.InsertStyles
	}
	return nil
}

func (m *RCRanFunction) GetEventTriggerStyles() []*RCEventTriggerStyle {
	if m != nil {
		return m.EventTriggerStyles
	}
	return nil
}

func (m *RCRanFunction) GetPolicyStyles() []*RCPolicyStyle {
	if m != nil {
		return m.PolicyStyles
	}
	return nil
}

func (m *RCRanFunction) GetControlStyles() []*RCControlStyle {
	if m != nil {
		return m.ControlStyles
	}
	return nil
}

type MHORanFunction struct {
	ID           string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ReportStyles []*MHOReportStyle `protobuf:"bytes,2,rep,name=report_styles,json=reportStyles,proto3" json:"report_styles,omitempty"`
}

func (m *MHORanFunction) Reset()         { *m = MHORanFunction{} }
func (m *MHORanFunction) String() string { return proto.CompactTextString(m) }
func (*MHORanFunction) ProtoMessage()    {}
func (*MHORanFunction) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{43}
}
func (m *MHORanFunction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MHORanFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MHORanFunction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MHORanFunction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MHORanFunction.Merge(m, src)
}
func (m *MHORanFunction) XXX_Size() int {
	return m.Size()
}
func (m *MHORanFunction) XXX_DiscardUnknown() {
	xxx_messageInfo_MHORanFunction.DiscardUnknown(m)
}

var xxx_messageInfo_MHORanFunction proto.InternalMessageInfo

func (m *MHORanFunction) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *MHORanFunction) GetReportStyles() []*MHOReportStyle {
	if m != nil {
		return m.ReportStyles
	}
	return nil
}

type KPMRanFunction struct {
	ID           string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ReportStyles []*KPMReportStyle `protobuf:"bytes,2,rep,name=report_styles,json=reportStyles,proto3" json:"report_styles,omitempty"`
}

func (m *KPMRanFunction) Reset()         { *m = KPMRanFunction{} }
func (m *KPMRanFunction) String() string { return proto.CompactTextString(m) }
func (*KPMRanFunction) ProtoMessage()    {}
func (*KPMRanFunction) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{44}
}
func (m *KPMRanFunction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KPMRanFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KPMRanFunction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KPMRanFunction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KPMRanFunction.Merge(m, src)
}
func (m *KPMRanFunction) XXX_Size() int {
	return m.Size()
}
func (m *KPMRanFunction) XXX_DiscardUnknown() {
	xxx_messageInfo_KPMRanFunction.DiscardUnknown(m)
}

var xxx_messageInfo_KPMRanFunction proto.InternalMessageInfo

func (m *KPMRanFunction) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *KPMRanFunction) GetReportStyles() []*KPMReportStyle {
	if m != nil {
		return m.ReportStyles
	}
	return nil
}

type RSMRanFunction struct {
	ID                           string                          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	RicSlicingNodeCapabilityList []*RSMNodeSlicingCapabilityItem `protobuf:"bytes,2,rep,name=ric_slicing_node_capability_list,json=ricSlicingNodeCapabilityList,proto3" json:"ric_slicing_node_capability_list,omitempty"`
}

func (m *RSMRanFunction) Reset()         { *m = RSMRanFunction{} }
func (m *RSMRanFunction) String() string { return proto.CompactTextString(m) }
func (*RSMRanFunction) ProtoMessage()    {}
func (*RSMRanFunction) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{45}
}
func (m *RSMRanFunction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RSMRanFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RSMRanFunction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RSMRanFunction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RSMRanFunction.Merge(m, src)
}
func (m *RSMRanFunction) XXX_Size() int {
	return m.Size()
}
func (m *RSMRanFunction) XXX_DiscardUnknown() {
	xxx_messageInfo_RSMRanFunction.DiscardUnknown(m)
}

var xxx_messageInfo_RSMRanFunction proto.InternalMessageInfo

func (m *RSMRanFunction) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *RSMRanFunction) GetRicSlicingNodeCapabilityList() []*RSMNodeSlicingCapabilityItem {
	if m != nil {
		return m.RicSlicingNodeCapabilityList
	}
	return nil
}

type RCEventTriggerStyle struct {
	Name       string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type       int32  `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	FormatType int32  `protobuf:"varint,3,opt,name=format_type,json=formatType,proto3" json:"format_type,omitempty"`
}

func (m *RCEventTriggerStyle) Reset()         { *m = RCEventTriggerStyle{} }
func (m *RCEventTriggerStyle) String() string { return proto.CompactTextString(m) }
func (*RCEventTriggerStyle) ProtoMessage()    {}
func (*RCEventTriggerStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{46}
}
func (m *RCEventTriggerStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RCEventTriggerStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RCEventTriggerStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RCEventTriggerStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RCEventTriggerStyle.Merge(m, src)
}
func (m *RCEventTriggerStyle) XXX_Size() int {
	return m.Size()
}
func (m *RCEventTriggerStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_RCEventTriggerStyle.DiscardUnknown(m)
}

var xxx_messageInfo_RCEventTriggerStyle proto.InternalMessageInfo

func (m *RCEventTriggerStyle) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *RCEventTriggerStyle) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *RCEventTriggerStyle) GetFormatType() int32 {
	if m != nil {
		return m.FormatType
	}
	return 0
}

type RCReportStyle struct {
	Name          string          `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type          int32           `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	RanParameters []*RANParameter `protobuf:"bytes,3,rep,name=ran_parameters,json=ranParameters,proto3" json:"ran_parameters,omitempty"`
}

func (m *RCReportStyle) Reset()         { *m = RCReportStyle{} }
func (m *RCReportStyle) String() string { return proto.CompactTextString(m) }
func (*RCReportStyle) ProtoMessage()    {}
func (*RCReportStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{47}
}
func (m *RCReportStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RCReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RCReportStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RCReportStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RCReportStyle.Merge(m, src)
}
func (m *RCReportStyle) XXX_Size() int {
	return m.Size()
}
func (m *RCReportStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_RCReportStyle.DiscardUnknown(m)
}

var xxx_messageInfo_RCReportStyle proto.InternalMessageInfo

func (m *RCReportStyle) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *RCReportStyle) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *RCReportStyle) GetRanParameters() []*RANParameter {
	if m != nil {
		return m.RanParameters
	}
	return nil
}

type RCInsertStyle struct {
	Name              string              `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type              int32               `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	InsertIndications []*InsertIndication `protobuf:"bytes,3,rep,name=insert_indications,json=insertIndications,proto3" json:"insert_indications,omitempty"`
}

func (m *RCInsertStyle) Reset()         { *m = RCInsertStyle{} }
func (m *RCInsertStyle) String() string { return proto.CompactTextString(m) }
func (*RCInsertStyle) ProtoMessage()    {}
func (*RCInsertStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{48}
}
func (m *RCInsertStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RCInsertStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RCInsertStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RCInsertStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RCInsertStyle.Merge(m, src)
}
func (m *RCInsertStyle) XXX_Size() int {
	return m.Size()
}
func (m *RCInsertStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_RCInsertStyle.DiscardUnknown(m)
}

var xxx_messageInfo_RCInsertStyle proto.InternalMessageInfo

func (m *RCInsertStyle) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *RCInsertStyle) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *RCInsertStyle) GetInsertIndications() []*InsertIndication {
	if m != nil {
		return m.InsertIndications
	}
	return nil
}

type RCPolicyStyle struct {
	Name          string          `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type          int32           `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	PolicyActions []*PolicyAction `protobuf:"bytes,3,rep,name=policy_actions,json=policyActions,proto3" json:"policy_actions,omitempty"`
}

func (m *RCPolicyStyle) Reset()         { *m = RCPolicyStyle{} }
func (m *RCPolicyStyle) String() string { return proto.CompactTextString(m) }
func (*RCPolicyStyle) ProtoMessage()    {}
func (*RCPolicyStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{49}
}
func (m *RCPolicyStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RCPolicyStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RCPolicyStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RCPolicyStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RCPolicyStyle.Merge(m, src)
}
func (m *RCPolicyStyle) XXX_Size() int {
	return m.Size()
}
func (m *RCPolicyStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_RCPolicyStyle.DiscardUnknown(m)
}

var xxx_messageInfo_RCPolicyStyle proto.InternalMessageInfo

func (m *RCPolicyStyle) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *RCPolicyStyle) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *RCPolicyStyle) GetPolicyActions() []*PolicyAction {
	if m != nil {
		return m.PolicyActions
	}
	return nil
}

type PolicyAction struct {
	ID                           int32           `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name                         string          `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	PolicyActionRanParameters    []*RANParameter `protobuf:"bytes,3,rep,name=policy_action_ran_parameters,json=policyActionRanParameters,proto3" json:"policy_action_ran_parameters,omitempty"`
	PolicyConditionRanParameters []*RANParameter `protobuf:"bytes,4,rep,name=policy_condition_ran_parameters,json=policyConditionRanParameters,proto3" json:"policy_condition_ran_parameters,omitempty"`
}

func (m *PolicyAction) Reset()         { *m = PolicyAction{} }
func (m *PolicyAction) String() string { return proto.CompactTextString(m) }
func (*PolicyAction) ProtoMessage()    {}
func (*PolicyAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{50}
}
func (m *PolicyAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PolicyAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PolicyAction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PolicyAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PolicyAction.Merge(m, src)
}
func (m *PolicyAction) XXX_Size() int {
	return m.Size()
}
func (m *PolicyAction) XXX_DiscardUnknown() {
	xxx_messageInfo_PolicyAction.DiscardUnknown(m)
}

var xxx_messageInfo_PolicyAction proto.InternalMessageInfo

func (m *PolicyAction) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *PolicyAction) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *PolicyAction) GetPolicyActionRanParameters() []*RANParameter {
	if m != nil {
		return m.PolicyActionRanParameters
	}
	return nil
}

func (m *PolicyAction) GetPolicyConditionRanParameters() []*RANParameter {
	if m != nil {
		return m.PolicyConditionRanParameters
	}
	return nil
}

type RCControlStyle struct {
	Name                     string           `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type                     int32            `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	HeaderFormatType         int32            `protobuf:"varint,3,opt,name=header_format_type,json=headerFormatType,proto3" json:"header_format_type,omitempty"`
	MessageFormatType        int32            `protobuf:"varint,4,opt,name=message_format_type,json=messageFormatType,proto3" json:"message_format_type,omitempty"`
	ControlOutcomeFormatType int32            `protobuf:"varint,5,opt,name=control_outcome_format_type,json=controlOutcomeFormatType,proto3" json:"control_outcome_format_type,omitempty"`
	ControlActions           []*ControlAction `protobuf:"bytes,6,rep,name=control_actions,json=controlActions,proto3" json:"control_actions,omitempty"`
}

func (m *RCControlStyle) Reset()         { *m = RCControlStyle{} }
func (m *RCControlStyle) String() string { return proto.CompactTextString(m) }
func (*RCControlStyle) ProtoMessage()    {}
func (*RCControlStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{51}
}
func (m *RCControlStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RCControlStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RCControlStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RCControlStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RCControlStyle.Merge(m, src)
}
func (m *RCControlStyle) XXX_Size() int {
	return m.Size()
}
func (m *RCControlStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_RCControlStyle.DiscardUnknown(m)
}

var xxx_messageInfo_RCControlStyle proto.InternalMessageInfo

func (m *RCControlStyle) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *RCControlStyle) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *RCControlStyle) GetHeaderFormatType() int32 {
	if m != nil {
		return m.HeaderFormatType
	}
	return 0
}

func (m *RCControlStyle) GetMessageFormatType() int32 {
	if m != nil {
		return m.MessageFormatType
	}
	return 0
}

func (m *RCControlStyle) GetControlOutcomeFormatType() int32 {
	if m != nil {
		return m.ControlOutcomeFormatType
	}
	return 0
}

func (m *RCControlStyle) GetControlActions() []*ControlAction {
	if m != nil {
		return m.ControlActions
	}
	return nil
}

type ControlAction struct {
	ID            int32           `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name          string          `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	RanParameters []*RANParameter `protobuf:"bytes,3,rep,name=ran_parameters,json=ranParameters,proto3" json:"ran_parameters,omitempty"`
}

func (m *ControlAction) Reset()         { *m = ControlAction{} }
func (m *ControlAction) String() string { return proto.CompactTextString(m) }
func (*ControlAction) ProtoMessage()    {}
func (*ControlAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{52}
}
func (m *ControlAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ControlAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ControlAction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ControlAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControlAction.Merge(m, src)
}
func (m *ControlAction) XXX_Size() int {
	return m.Size()
}
func (m *ControlAction) XXX_DiscardUnknown() {
	xxx_messageInfo_ControlAction.DiscardUnknown(m)
}

var xxx_messageInfo_ControlAction proto.InternalMessageInfo

func (m *ControlAction) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *ControlAction) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ControlAction) GetRanParameters() []*RANParameter {
	if m != nil {
		return m.RanParameters
	}
	return nil
}

type InsertIndication struct {
	ID            int32           `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name          string          `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	RanParameters []*RANParameter `protobuf:"bytes,3,rep,name=ran_parameters,json=ranParameters,proto3" json:"ran_parameters,omitempty"`
}

func (m *InsertIndication) Reset()         { *m = InsertIndication{} }
func (m *InsertIndication) String() string { return proto.CompactTextString(m) }
func (*InsertIndication) ProtoMessage()    {}
func (*InsertIndication) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{53}
}
func (m *InsertIndication) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InsertIndication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InsertIndication.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InsertIndication) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InsertIndication.Merge(m, src)
}
func (m *InsertIndication) XXX_Size() int {
	return m.Size()
}
func (m *InsertIndication) XXX_DiscardUnknown() {
	xxx_messageInfo_InsertIndication.DiscardUnknown(m)
}

var xxx_messageInfo_InsertIndication proto.InternalMessageInfo

func (m *InsertIndication) GetID() int32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *InsertIndication) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *InsertIndication) GetRanParameters() []*RANParameter {
	if m != nil {
		return m.RanParameters
	}
	return nil
}

type RANParameter struct {
	ID   int64  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *RANParameter) Reset()         { *m = RANParameter{} }
func (m *RANParameter) String() string { return proto.CompactTextString(m) }
func (*RANParameter) ProtoMessage()    {}
func (*RANParameter) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{54}
}
func (m *RANParameter) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RANParameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RANParameter.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RANParameter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RANParameter.Merge(m, src)
}
func (m *RANParameter) XXX_Size() int {
	return m.Size()
}
func (m *RANParameter) XXX_DiscardUnknown() {
	xxx_messageInfo_RANParameter.DiscardUnknown(m)
}

var xxx_messageInfo_RANParameter proto.InternalMessageInfo

func (m *RANParameter) GetID() int64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *RANParameter) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type KPMReportStyle struct {
	Name         string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type         int32             `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	Measurements []*KPMMeasurement `protobuf:"bytes,3,rep,name=measurements,proto3" json:"measurements,omitempty"`
}

func (m *KPMReportStyle) Reset()         { *m = KPMReportStyle{} }
func (m *KPMReportStyle) String() string { return proto.CompactTextString(m) }
func (*KPMReportStyle) ProtoMessage()    {}
func (*KPMReportStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{55}
}
func (m *KPMReportStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KPMReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KPMReportStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KPMReportStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KPMReportStyle.Merge(m, src)
}
func (m *KPMReportStyle) XXX_Size() int {
	return m.Size()
}
func (m *KPMReportStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_KPMReportStyle.DiscardUnknown(m)
}

var xxx_messageInfo_KPMReportStyle proto.InternalMessageInfo

func (m *KPMReportStyle) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *KPMReportStyle) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *KPMReportStyle) GetMeasurements() []*KPMMeasurement {
	if m != nil {
		return m.Measurements
	}
	return nil
}

type MHOReportStyle struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type int32  `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
}

func (m *MHOReportStyle) Reset()         { *m = MHOReportStyle{} }
func (m *MHOReportStyle) String() string { return proto.CompactTextString(m) }
func (*MHOReportStyle) ProtoMessage()    {}
func (*MHOReportStyle) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{56}
}
func (m *MHOReportStyle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MHOReportStyle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MHOReportStyle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MHOReportStyle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MHOReportStyle.Merge(m, src)
}
func (m *MHOReportStyle) XXX_Size() int {
	return m.Size()
}
func (m *MHOReportStyle) XXX_DiscardUnknown() {
	xxx_messageInfo_MHOReportStyle.DiscardUnknown(m)
}

var xxx_messageInfo_MHOReportStyle proto.InternalMessageInfo

func (m *MHOReportStyle) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *MHOReportStyle) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

type KPMMeasurement struct {
	ID   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *KPMMeasurement) Reset()         { *m = KPMMeasurement{} }
func (m *KPMMeasurement) String() string { return proto.CompactTextString(m) }
func (*KPMMeasurement) ProtoMessage()    {}
func (*KPMMeasurement) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{57}
}
func (m *KPMMeasurement) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KPMMeasurement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KPMMeasurement.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KPMMeasurement) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KPMMeasurement.Merge(m, src)
}
func (m *KPMMeasurement) XXX_Size() int {
	return m.Size()
}
func (m *KPMMeasurement) XXX_DiscardUnknown() {
	xxx_messageInfo_KPMMeasurement.DiscardUnknown(m)
}

var xxx_messageInfo_KPMMeasurement proto.InternalMessageInfo

func (m *KPMMeasurement) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *KPMMeasurement) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type RSMNodeSlicingCapabilityItem struct {
	MaxNumberOfSlicesDl    int32                            `protobuf:"varint,1,opt,name=max_number_of_slices_dl,json=maxNumberOfSlicesDl,proto3" json:"max_number_of_slices_dl,omitempty"`
	MaxNumberOfSlicesUl    int32                            `protobuf:"varint,2,opt,name=max_number_of_slices_ul,json=maxNumberOfSlicesUl,proto3" json:"max_number_of_slices_ul,omitempty"`
	SlicingType            RSMSlicingType                   `protobuf:"varint,3,opt,name=slicing_type,json=slicingType,proto3,enum=onos.topo.RSMSlicingType" json:"slicing_type,omitempty"`
	MaxNumberOfUesPerSlice int32                            `protobuf:"varint,4,opt,name=max_number_of_ues_per_slice,json=maxNumberOfUesPerSlice,proto3" json:"max_number_of_ues_per_slice,omitempty"`
	SupportedConfig        []*RSMSupportedSlicingConfigItem `protobuf:"bytes,5,rep,name=supported_config,json=supportedConfig,proto3" json:"supported_config,omitempty"`
}

func (m *RSMNodeSlicingCapabilityItem) Reset()         { *m = RSMNodeSlicingCapabilityItem{} }
func (m *RSMNodeSlicingCapabilityItem) String() string { return proto.CompactTextString(m) }
func (*RSMNodeSlicingCapabilityItem) ProtoMessage()    {}
func (*RSMNodeSlicingCapabilityItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{58}
}
func (m *RSMNodeSlicingCapabilityItem) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RSMNodeSlicingCapabilityItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RSMNodeSlicingCapabilityItem.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RSMNodeSlicingCapabilityItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RSMNodeSlicingCapabilityItem.Merge(m, src)
}
func (m *RSMNodeSlicingCapabilityItem) XXX_Size() int {
	return m.Size()
}
func (m *RSMNodeSlicingCapabilityItem) XXX_DiscardUnknown() {
	xxx_messageInfo_RSMNodeSlicingCapabilityItem.DiscardUnknown(m)
}

var xxx_messageInfo_RSMNodeSlicingCapabilityItem proto.InternalMessageInfo

func (m *RSMNodeSlicingCapabilityItem) GetMaxNumberOfSlicesDl() int32 {
	if m != nil {
		return m.MaxNumberOfSlicesDl
	}
	return 0
}

func (m *RSMNodeSlicingCapabilityItem) GetMaxNumberOfSlicesUl() int32 {
	if m != nil {
		return m.MaxNumberOfSlicesUl
	}
	return 0
}

func (m *RSMNodeSlicingCapabilityItem) GetSlicingType() RSMSlicingType {
	if m != nil {
		return m.SlicingType
	}
	return RSMSlicingType_SLICING_TYPE_STATIC
}

func (m *RSMNodeSlicingCapabilityItem) GetMaxNumberOfUesPerSlice() int32 {
	if m != nil {
		return m.MaxNumberOfUesPerSlice
	}
	return 0
}

func (m *RSMNodeSlicingCapabilityItem) GetSupportedConfig() []*RSMSupportedSlicingConfigItem {
	if m != nil {
		return m.SupportedConfig
	}
	return nil
}

type RSMSupportedSlicingConfigItem struct {
	SlicingConfigType E2SmRsmCommand `protobuf:"varint,1,opt,name=slicing_config_type,json=slicingConfigType,proto3,enum=onos.topo.E2SmRsmCommand" json:"slicing_config_type,omitempty"`
}

func (m *RSMSupportedSlicingConfigItem) Reset()         { *m = RSMSupportedSlicingConfigItem{} }
func (m *RSMSupportedSlicingConfigItem) String() string { return proto.CompactTextString(m) }
func (*RSMSupportedSlicingConfigItem) ProtoMessage()    {}
func (*RSMSupportedSlicingConfigItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{59}
}
func (m *RSMSupportedSlicingConfigItem) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RSMSupportedSlicingConfigItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RSMSupportedSlicingConfigItem.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RSMSupportedSlicingConfigItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RSMSupportedSlicingConfigItem.Merge(m, src)
}
func (m *RSMSupportedSlicingConfigItem) XXX_Size() int {
	return m.Size()
}
func (m *RSMSupportedSlicingConfigItem) XXX_DiscardUnknown() {
	xxx_messageInfo_RSMSupportedSlicingConfigItem.DiscardUnknown(m)
}

var xxx_messageInfo_RSMSupportedSlicingConfigItem proto.InternalMessageInfo

func (m *RSMSupportedSlicingConfigItem) GetSlicingConfigType() E2SmRsmCommand {
	if m != nil {
		return m.SlicingConfigType
	}
	return E2SmRsmCommand_E2_SM_RSM_COMMAND_SLICE_CREATE
}

type RSMSliceItemList struct {
	RsmSliceList []*RSMSlicingItem `protobuf:"bytes,1,rep,name=rsm_slice_list,json=rsmSliceList,proto3" json:"rsm_slice_list,omitempty"`
}

func (m *RSMSliceItemList) Reset()         { *m = RSMSliceItemList{} }
func (m *RSMSliceItemList) String() string { return proto.CompactTextString(m) }
func (*RSMSliceItemList) ProtoMessage()    {}
func (*RSMSliceItemList) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{60}
}
func (m *RSMSliceItemList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RSMSliceItemList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RSMSliceItemList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RSMSliceItemList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RSMSliceItemList.Merge(m, src)
}
func (m *RSMSliceItemList) XXX_Size() int {
	return m.Size()
}
func (m *RSMSliceItemList) XXX_DiscardUnknown() {
	xxx_messageInfo_RSMSliceItemList.DiscardUnknown(m)
}

var xxx_messageInfo_RSMSliceItemList proto.InternalMessageInfo

func (m *RSMSliceItemList) GetRsmSliceList() []*RSMSlicingItem {
	if m != nil {
		return m.RsmSliceList
	}
	return nil
}

type RSMSlicingItem struct {
	ID              string              `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	SliceDesc       string              `protobuf:"bytes,2,opt,name=slice_desc,json=sliceDesc,proto3" json:"slice_desc,omitempty"`
	SliceParameters *RSMSliceParameters `protobuf:"bytes,3,opt,name=slice_parameters,json=sliceParameters,proto3" json:"slice_parameters,omitempty"`
	SliceType       RSMSliceType        `protobuf:"varint,4,opt,name=slice_type,json=sliceType,proto3,enum=onos.topo.RSMSliceType" json:"slice_type,omitempty"`
	UeIdList        []*UeIdentity       `protobuf:"bytes,5,rep,name=ue_id_list,json=ueIdList,proto3" json:"ue_id_list,omitempty"`
}

func (m *RSMSlicingItem) Reset()         { *m = RSMSlicingItem{} }
func (m *RSMSlicingItem) String() string { return proto.CompactTextString(m) }
func (*RSMSlicingItem) ProtoMessage()    {}
func (*RSMSlicingItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{61}
}
func (m *RSMSlicingItem) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RSMSlicingItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RSMSlicingItem.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RSMSlicingItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RSMSlicingItem.Merge(m, src)
}
func (m *RSMSlicingItem) XXX_Size() int {
	return m.Size()
}
func (m *RSMSlicingItem) XXX_DiscardUnknown() {
	xxx_messageInfo_RSMSlicingItem.DiscardUnknown(m)
}

var xxx_messageInfo_RSMSlicingItem proto.InternalMessageInfo

func (m *RSMSlicingItem) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *RSMSlicingItem) GetSliceDesc() string {
	if m != nil {
		return m.SliceDesc
	}
	return ""
}

func (m *RSMSlicingItem) GetSliceParameters() *RSMSliceParameters {
	if m != nil {
		return m.SliceParameters
	}
	return nil
}

func (m *RSMSlicingItem) GetSliceType() RSMSliceType {
	if m != nil {
		return m.SliceType
	}
	return RSMSliceType_SLICE_TYPE_DL_SLICE
}

func (m *RSMSlicingItem) GetUeIdList() []*UeIdentity {
	if m != nil {
		return m.UeIdList
	}
	return nil
}

type RSMSliceParameters struct {
	SchedulerType RSMSchedulerType `protobuf:"varint,1,opt,name=scheduler_type,json=schedulerType,proto3,enum=onos.topo.RSMSchedulerType" json:"scheduler_type,omitempty"`
	Weight        int32            `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"`
	QosLevel      int32            `protobuf:"varint,3,opt,name=qos_level,json=qosLevel,proto3" json:"qos_level,omitempty"`
}

func (m *RSMSliceParameters) Reset()         { *m = RSMSliceParameters{} }
func (m *RSMSliceParameters) String() string { return proto.CompactTextString(m) }
func (*RSMSliceParameters) ProtoMessage()    {}
func (*RSMSliceParameters) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{62}
}
func (m *RSMSliceParameters) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RSMSliceParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RSMSliceParameters.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RSMSliceParameters) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RSMSliceParameters.Merge(m, src)
}
func (m *RSMSliceParameters) XXX_Size() int {
	return m.Size()
}
func (m *RSMSliceParameters) XXX_DiscardUnknown() {
	xxx_messageInfo_RSMSliceParameters.DiscardUnknown(m)
}

var xxx_messageInfo_RSMSliceParameters proto.InternalMessageInfo

func (m *RSMSliceParameters) GetSchedulerType() RSMSchedulerType {
	if m != nil {
		return m.SchedulerType
	}
	return RSMSchedulerType_SCHEDULER_TYPE_ROUND_ROBIN
}

func (m *RSMSliceParameters) GetWeight() int32 {
	if m != nil {
		return m.Weight
	}
	return 0
}

func (m *RSMSliceParameters) GetQosLevel() int32 {
	if m != nil {
		return m.QosLevel
	}
	return 0
}

type DuUeF1ApID struct {
	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *DuUeF1ApID) Reset()         { *m = DuUeF1ApID{} }
func (m *DuUeF1ApID) String() string { return proto.CompactTextString(m) }
func (*DuUeF1ApID) ProtoMessage()    {}
func (*DuUeF1ApID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{63}
}
func (m *DuUeF1ApID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DuUeF1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DuUeF1ApID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DuUeF1ApID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DuUeF1ApID.Merge(m, src)
}
func (m *DuUeF1ApID) XXX_Size() int {
	return m.Size()
}
func (m *DuUeF1ApID) XXX_DiscardUnknown() {
	xxx_messageInfo_DuUeF1ApID.DiscardUnknown(m)
}

var xxx_messageInfo_DuUeF1ApID proto.InternalMessageInfo

func (m *DuUeF1ApID) GetValue() int64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type CuUeF1ApID struct {
	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *CuUeF1ApID) Reset()         { *m = CuUeF1ApID{} }
func (m *CuUeF1ApID) String() string { return proto.CompactTextString(m) }
func (*CuUeF1ApID) ProtoMessage()    {}
func (*CuUeF1ApID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{64}
}
func (m *CuUeF1ApID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CuUeF1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CuUeF1ApID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CuUeF1ApID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CuUeF1ApID.Merge(m, src)
}
func (m *CuUeF1ApID) XXX_Size() int {
	return m.Size()
}
func (m *CuUeF1ApID) XXX_DiscardUnknown() {
	xxx_messageInfo_CuUeF1ApID.DiscardUnknown(m)
}

var xxx_messageInfo_CuUeF1ApID proto.InternalMessageInfo

func (m *CuUeF1ApID) GetValue() int64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type RanUeNgapID struct {
	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *RanUeNgapID) Reset()         { *m = RanUeNgapID{} }
func (m *RanUeNgapID) String() string { return proto.CompactTextString(m) }
func (*RanUeNgapID) ProtoMessage()    {}
func (*RanUeNgapID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{65}
}
func (m *RanUeNgapID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RanUeNgapID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RanUeNgapID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RanUeNgapID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RanUeNgapID.Merge(m, src)
}
func (m *RanUeNgapID) XXX_Size() int {
	return m.Size()
}
func (m *RanUeNgapID) XXX_DiscardUnknown() {
	xxx_messageInfo_RanUeNgapID.DiscardUnknown(m)
}

var xxx_messageInfo_RanUeNgapID proto.InternalMessageInfo

func (m *RanUeNgapID) GetValue() int64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type EnbUeS1ApID struct {
	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *EnbUeS1ApID) Reset()         { *m = EnbUeS1ApID{} }
func (m *EnbUeS1ApID) String() string { return proto.CompactTextString(m) }
func (*EnbUeS1ApID) ProtoMessage()    {}
func (*EnbUeS1ApID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{66}
}
func (m *EnbUeS1ApID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EnbUeS1ApID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EnbUeS1ApID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EnbUeS1ApID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnbUeS1ApID.Merge(m, src)
}
func (m *EnbUeS1ApID) XXX_Size() int {
	return m.Size()
}
func (m *EnbUeS1ApID) XXX_DiscardUnknown() {
	xxx_messageInfo_EnbUeS1ApID.DiscardUnknown(m)
}

var xxx_messageInfo_EnbUeS1ApID proto.InternalMessageInfo

func (m *EnbUeS1ApID) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

type AmfUeNgapID struct {
	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *AmfUeNgapID) Reset()         { *m = AmfUeNgapID{} }
func (m *AmfUeNgapID) String() string { return proto.CompactTextString(m) }
func (*AmfUeNgapID) ProtoMessage()    {}
func (*AmfUeNgapID) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{67}
}
func (m *AmfUeNgapID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AmfUeNgapID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AmfUeNgapID.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AmfUeNgapID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AmfUeNgapID.Merge(m, src)
}
func (m *AmfUeNgapID) XXX_Size() int {
	return m.Size()
}
func (m *AmfUeNgapID) XXX_DiscardUnknown() {
	xxx_messageInfo_AmfUeNgapID.DiscardUnknown(m)
}

var xxx_messageInfo_AmfUeNgapID proto.InternalMessageInfo

func (m *AmfUeNgapID) GetValue() int64 {
	if m != nil {
		return m.Value
	}
	return 0
}

type UeIdentity struct {
	DuUeF1apID      *DuUeF1ApID  `protobuf:"bytes,1,opt,name=du_ue_f1ap_id,json=duUeF1apId,proto3" json:"du_ue_f1ap_id,omitempty"`
	CuUeF1apID      *CuUeF1ApID  `protobuf:"bytes,2,opt,name=cu_ue_f1ap_id,json=cuUeF1apId,proto3" json:"cu_ue_f1ap_id,omitempty"`
	RANUeNgapID     *RanUeNgapID `protobuf:"bytes,3,opt,name=ran_ue_ngap_id,json=ranUeNgapId,proto3" json:"ran_ue_ngap_id,omitempty"`
	EnbUeS1apID     *EnbUeS1ApID `protobuf:"bytes,4,opt,name=enb_ue_s1ap_id,json=enbUeS1apId,proto3" json:"enb_ue_s1ap_id,omitempty"`
	AMFUeNgapID     *AmfUeNgapID `protobuf:"bytes,5,opt,name=amf_ue_ngap_id,json=amfUeNgapId,proto3" json:"amf_ue_ngap_id,omitempty"`
	PreferredIDType UeIdType     `protobuf:"varint,6,opt,name=preferred_id_type,json=preferredIdType,proto3,enum=onos.topo.UeIdType" json:"preferred_id_type,omitempty"`
	DrbId           *DrbId       `protobuf:"bytes,7,opt,name=drb_id,json=drbId,proto3" json:"drb_id,omitempty"`
}

func (m *UeIdentity) Reset()         { *m = UeIdentity{} }
func (m *UeIdentity) String() string { return proto.CompactTextString(m) }
func (*UeIdentity) ProtoMessage()    {}
func (*UeIdentity) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{68}
}
func (m *UeIdentity) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UeIdentity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UeIdentity.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UeIdentity) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UeIdentity.Merge(m, src)
}
func (m *UeIdentity) XXX_Size() int {
	return m.Size()
}
func (m *UeIdentity) XXX_DiscardUnknown() {
	xxx_messageInfo_UeIdentity.DiscardUnknown(m)
}

var xxx_messageInfo_UeIdentity proto.InternalMessageInfo

func (m *UeIdentity) GetDuUeF1apID() *DuUeF1ApID {
	if m != nil {
		return m.DuUeF1apID
	}
	return nil
}

func (m *UeIdentity) GetCuUeF1apID() *CuUeF1ApID {
	if m != nil {
		return m.CuUeF1apID
	}
	return nil
}

func (m *UeIdentity) GetRANUeNgapID() *RanUeNgapID {
	if m != nil {
		return m.RANUeNgapID
	}
	return nil
}

func (m *UeIdentity) GetEnbUeS1apID() *EnbUeS1ApID {
	if m != nil {
		return m.EnbUeS1apID
	}
	return nil
}

func (m *UeIdentity) GetAMFUeNgapID() *AmfUeNgapID {
	if m != nil {
		return m.AMFUeNgapID
	}
	return nil
}

func (m *UeIdentity) GetPreferredIDType() UeIdType {
	if m != nil {
		return m.PreferredIDType
	}
	return UeIdType_UE_ID_TYPE_CU_UE_F1_AP_ID
}

func (m *UeIdentity) GetDrbId() *DrbId {
	if m != nil {
		return m.DrbId
	}
	return nil
}

type DrbId struct {
	// Types that are valid to be assigned to DrbId:
	//
	//	*DrbId_FourGdrbId
	//	*DrbId_FiveGdrbId
	DrbId isDrbId_DrbId `protobuf_oneof:"drb_id"`
}

func (m *DrbId) Reset()         { *m = DrbId{} }
func (m *DrbId) String() string { return proto.CompactTextString(m) }
func (*DrbId) ProtoMessage()    {}
func (*DrbId) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{69}
}
func (m *DrbId) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DrbId.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DrbId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DrbId.Merge(m, src)
}
func (m *DrbId) XXX_Size() int {
	return m.Size()
}
func (m *DrbId) XXX_DiscardUnknown() {
	xxx_messageInfo_DrbId.DiscardUnknown(m)
}

var xxx_messageInfo_DrbId proto.InternalMessageInfo

type isDrbId_DrbId interface {
	isDrbId_DrbId()
	MarshalTo([]byte) (int, error)
	Size() int
}

type DrbId_FourGdrbId struct {
	FourGdrbId *FourGDrbId `protobuf:"bytes,1,opt,name=four_gdrb_id,json=fourGDrbID,proto3,oneof" json:"four_gdrb_id,omitempty"`
}
type DrbId_FiveGdrbId struct {
	FiveGdrbId *FiveGDrbId `protobuf:"bytes,2,opt,name=five_gdrb_id,json=fiveGDrbID,proto3,oneof" json:"five_gdrb_id,omitempty"`
}

func (*DrbId_FourGdrbId) isDrbId_DrbId() {}
func (*DrbId_FiveGdrbId) isDrbId_DrbId() {}

func (m *DrbId) GetDrbId() isDrbId_DrbId {
	if m != nil {
		return m.DrbId
	}
	return nil
}

func (m *DrbId) GetFourGdrbId() *FourGDrbId {
	if x, ok := m.GetDrbId().(*DrbId_FourGdrbId); ok {
		return x.FourGdrbId
	}
	return nil
}

func (m *DrbId) GetFiveGdrbId() *FiveGDrbId {
	if x, ok := m.GetDrbId().(*DrbId_FiveGdrbId); ok {
		return x.FiveGdrbId
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*DrbId) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*DrbId_FourGdrbId)(nil),
		(*DrbId_FiveGdrbId)(nil),
	}
}

type FiveGDrbId struct {
	Value         int32                     `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	Qfi           *Qfi                      `protobuf:"bytes,2,opt,name=qfi,proto3" json:"qfi,omitempty"`
	FlowsMapToDrb []*QoSflowLevelParameters `protobuf:"bytes,3,rep,name=flows_map_to_drb,json=flowsMapToDrb,proto3" json:"flows_map_to_drb,omitempty"`
}

func (m *FiveGDrbId) Reset()         { *m = FiveGDrbId{} }
func (m *FiveGDrbId) String() string { return proto.CompactTextString(m) }
func (*FiveGDrbId) ProtoMessage()    {}
func (*FiveGDrbId) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{70}
}
func (m *FiveGDrbId) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FiveGDrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FiveGDrbId.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FiveGDrbId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FiveGDrbId.Merge(m, src)
}
func (m *FiveGDrbId) XXX_Size() int {
	return m.Size()
}
func (m *FiveGDrbId) XXX_DiscardUnknown() {
	xxx_messageInfo_FiveGDrbId.DiscardUnknown(m)
}

var xxx_messageInfo_FiveGDrbId proto.InternalMessageInfo

func (m *FiveGDrbId) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *FiveGDrbId) GetQfi() *Qfi {
	if m != nil {
		return m.Qfi
	}
	return nil
}

func (m *FiveGDrbId) GetFlowsMapToDrb() []*QoSflowLevelParameters {
	if m != nil {
		return m.FlowsMapToDrb
	}
	return nil
}

type Qfi struct {
	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *Qfi) Reset()         { *m = Qfi{} }
func (m *Qfi) String() string { return proto.CompactTextString(m) }
func (*Qfi) ProtoMessage()    {}
func (*Qfi) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{71}
}
func (m *Qfi) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Qfi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Qfi.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Qfi) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Qfi.Merge(m, src)
}
func (m *Qfi) XXX_Size() int {
	return m.Size()
}
func (m *Qfi) XXX_DiscardUnknown() {
	xxx_messageInfo_Qfi.DiscardUnknown(m)
}

var xxx_messageInfo_Qfi proto.InternalMessageInfo

func (m *Qfi) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

type QoSflowLevelParameters struct {
	// Types that are valid to be assigned to QosFlowLevelParameters:
	//
	//	*QoSflowLevelParameters_DynamicFiveQi
	//	*QoSflowLevelParameters_NonDynamicFiveQi
	QosFlowLevelParameters isQoSflowLevelParameters_QosFlowLevelParameters `protobuf_oneof:"qos_flow_level_parameters"`
}

func (m *QoSflowLevelParameters) Reset()         { *m = QoSflowLevelParameters{} }
func (m *QoSflowLevelParameters) String() string { return proto.CompactTextString(m) }
func (*QoSflowLevelParameters) ProtoMessage()    {}
func (*QoSflowLevelParameters) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{72}
}
func (m *QoSflowLevelParameters) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QoSflowLevelParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QoSflowLevelParameters.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QoSflowLevelParameters) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QoSflowLevelParameters.Merge(m, src)
}
func (m *QoSflowLevelParameters) XXX_Size() int {
	return m.Size()
}
func (m *QoSflowLevelParameters) XXX_DiscardUnknown() {
	xxx_messageInfo_QoSflowLevelParameters.DiscardUnknown(m)
}

var xxx_messageInfo_QoSflowLevelParameters proto.InternalMessageInfo

type isQoSflowLevelParameters_QosFlowLevelParameters interface {
	isQoSflowLevelParameters_QosFlowLevelParameters()
	MarshalTo([]byte) (int, error)
	Size() int
}

type QoSflowLevelParameters_DynamicFiveQi struct {
	DynamicFiveQi *DynamicFiveQi `protobuf:"bytes,1,opt,name=dynamic_five_qi,json=dynamicFiveQi,proto3,oneof" json:"dynamic_five_qi,omitempty"`
}
type QoSflowLevelParameters_NonDynamicFiveQi struct {
	NonDynamicFiveQi *NonDynamicFiveQi `protobuf:"bytes,2,opt,name=non_dynamic_five_qi,json=nonDynamicFiveQi,proto3,oneof" json:"non_dynamic_five_qi,omitempty"`
}

func (*QoSflowLevelParameters_DynamicFiveQi) isQoSflowLevelParameters_QosFlowLevelParameters()    {}
func (*QoSflowLevelParameters_NonDynamicFiveQi) isQoSflowLevelParameters_QosFlowLevelParameters() {}

func (m *QoSflowLevelParameters) GetQosFlowLevelParameters() isQoSflowLevelParameters_QosFlowLevelParameters {
	if m != nil {
		return m.QosFlowLevelParameters
	}
	return nil
}

func (m *QoSflowLevelParameters) GetDynamicFiveQi() *DynamicFiveQi {
	if x, ok := m.GetQosFlowLevelParameters().(*QoSflowLevelParameters_DynamicFiveQi); ok {
		return x.DynamicFiveQi
	}
	return nil
}

func (m *QoSflowLevelParameters) GetNonDynamicFiveQi() *NonDynamicFiveQi {
	if x, ok := m.GetQosFlowLevelParameters().(*QoSflowLevelParameters_NonDynamicFiveQi); ok {
		return x.NonDynamicFiveQi
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*QoSflowLevelParameters) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*QoSflowLevelParameters_DynamicFiveQi)(nil),
		(*QoSflowLevelParameters_NonDynamicFiveQi)(nil),
	}
}

type DynamicFiveQi struct {
	PriorityLevel    int32 `protobuf:"varint,1,opt,name=priority_level,json=priorityLevel,proto3" json:"priority_level,omitempty"`
	PacketDelayBudge int32 `protobuf:"varint,2,opt,name=packet_delay_budge,json=packetDelayBudge,proto3" json:"packet_delay_budge,omitempty"`
	PacketErrorRate  int32 `protobuf:"varint,3,opt,name=packet_error_rate,json=packetErrorRate,proto3" json:"packet_error_rate,omitempty"`
}

func (m *DynamicFiveQi) Reset()         { *m = DynamicFiveQi{} }
func (m *DynamicFiveQi) String() string { return proto.CompactTextString(m) }
func (*DynamicFiveQi) ProtoMessage()    {}
func (*DynamicFiveQi) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{73}
}
func (m *DynamicFiveQi) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DynamicFiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DynamicFiveQi.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DynamicFiveQi) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DynamicFiveQi.Merge(m, src)
}
func (m *DynamicFiveQi) XXX_Size() int {
	return m.Size()
}
func (m *DynamicFiveQi) XXX_DiscardUnknown() {
	xxx_messageInfo_DynamicFiveQi.DiscardUnknown(m)
}

var xxx_messageInfo_DynamicFiveQi proto.InternalMessageInfo

func (m *DynamicFiveQi) GetPriorityLevel() int32 {
	if m != nil {
		return m.PriorityLevel
	}
	return 0
}

func (m *DynamicFiveQi) GetPacketDelayBudge() int32 {
	if m != nil {
		return m.PacketDelayBudge
	}
	return 0
}

func (m *DynamicFiveQi) GetPacketErrorRate() int32 {
	if m != nil {
		return m.PacketErrorRate
	}
	return 0
}

type NonDynamicFiveQi struct {
	FiveQi *FiveQi `protobuf:"bytes,1,opt,name=five_qi,json=fiveQi,proto3" json:"five_qi,omitempty"`
}

func (m *NonDynamicFiveQi) Reset()         { *m = NonDynamicFiveQi{} }
func (m *NonDynamicFiveQi) String() string { return proto.CompactTextString(m) }
func (*NonDynamicFiveQi) ProtoMessage()    {}
func (*NonDynamicFiveQi) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{74}
}
func (m *NonDynamicFiveQi) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NonDynamicFiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NonDynamicFiveQi.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NonDynamicFiveQi) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NonDynamicFiveQi.Merge(m, src)
}
func (m *NonDynamicFiveQi) XXX_Size() int {
	return m.Size()
}
func (m *NonDynamicFiveQi) XXX_DiscardUnknown() {
	xxx_messageInfo_NonDynamicFiveQi.DiscardUnknown(m)
}

var xxx_messageInfo_NonDynamicFiveQi proto.InternalMessageInfo

func (m *NonDynamicFiveQi) GetFiveQi() *FiveQi {
	if m != nil {
		return m.FiveQi
	}
	return nil
}

type FiveQi struct {
	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *FiveQi) Reset()         { *m = FiveQi{} }
func (m *FiveQi) String() string { return proto.CompactTextString(m) }
func (*FiveQi) ProtoMessage()    {}
func (*FiveQi) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{75}
}
func (m *FiveQi) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FiveQi) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FiveQi.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FiveQi) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FiveQi.Merge(m, src)
}
func (m *FiveQi) XXX_Size() int {
	return m.Size()
}
func (m *FiveQi) XXX_DiscardUnknown() {
	xxx_messageInfo_FiveQi.DiscardUnknown(m)
}

var xxx_messageInfo_FiveQi proto.InternalMessageInfo

func (m *FiveQi) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

type FourGDrbId struct {
	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	Qci   *Qci  `protobuf:"bytes,2,opt,name=qci,proto3" json:"qci,omitempty"`
}

func (m *FourGDrbId) Reset()         { *m = FourGDrbId{} }
func (m *FourGDrbId) String() string { return proto.CompactTextString(m) }
func (*FourGDrbId) ProtoMessage()    {}
func (*FourGDrbId) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{76}
}
func (m *FourGDrbId) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FourGDrbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FourGDrbId.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FourGDrbId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FourGDrbId.Merge(m, src)
}
func (m *FourGDrbId) XXX_Size() int {
	return m.Size()
}
func (m *FourGDrbId) XXX_DiscardUnknown() {
	xxx_messageInfo_FourGDrbId.DiscardUnknown(m)
}

var xxx_messageInfo_FourGDrbId proto.InternalMessageInfo

func (m *FourGDrbId) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *FourGDrbId) GetQci() *Qci {
	if m != nil {
		return m.Qci
	}
	return nil
}

type Qci struct {
	Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *Qci) Reset()         { *m = Qci{} }
func (m *Qci) String() string { return proto.CompactTextString(m) }
func (*Qci) ProtoMessage()    {}
func (*Qci) Descriptor() ([]byte, []int) {
	return fileDescriptor_23cc5f935e05bbb6, []int{77}
}
func (m *Qci) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Qci) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Qci.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Qci) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Qci.Merge(m, src)
}
func (m *Qci) XXX_Size() int {
	return m.Size()
}
func (m *Qci) XXX_DiscardUnknown() {
	xxx_messageInfo_Qci.DiscardUnknown(m)
}

var xxx_messageInfo_Qci proto.InternalMessageInfo

func (m *Qci) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

func init() {
	proto.RegisterEnum("onos.topo.RANEntityKinds", RANEntityKinds_name, RANEntityKinds_value)
	proto.RegisterEnum("onos.topo.RANRelationKinds", RANRelationKinds_name, RANRelationKinds_value)
	proto.RegisterEnum("onos.topo.CellGlobalIDType", CellGlobalIDType_name, CellGlobalIDType_value)
	proto.RegisterEnum("onos.topo.NodeType", NodeType_name, NodeType_value)
	proto.RegisterEnum("onos.topo.ComponentType", ComponentType_name, ComponentType_value)
	proto.RegisterEnum("onos.topo.E2SmRsmCommand", E2SmRsmCommand_name, E2SmRsmCommand_value)
	proto.RegisterEnum("onos.topo.RSMSlicingType", RSMSlicingType_name, RSMSlicingType_value)
	proto.RegisterEnum("onos.topo.RSMSchedulerType", RSMSchedulerType_name, RSMSchedulerType_value)
	proto.RegisterEnum("onos.topo.RSMSliceType", RSMSliceType_name, RSMSliceType_value)
	proto.RegisterEnum("onos.topo.UeIdType", UeIdType_name, UeIdType_value)
	proto.RegisterEnum("onos.topo.NrScs", NrScs_name, NrScs_value)
	proto.RegisterEnum("onos.topo.Nrb", Nrb_name, Nrb_value)
	proto.RegisterEnum("onos.topo.EnDcSupport", EnDcSupport_name, EnDcSupport_value)
	proto.RegisterEnum("onos.topo.Interface_Type", Interface_Type_name, Interface_Type_value)
	proto.RegisterType((*Location)(nil), "onos.topo.Location")
	proto.RegisterType((*Wgs84Location)(nil), "onos.topo.Wgs84Location")
	proto.RegisterType((*CartesianLocation)(nil), "onos.topo.CartesianLocation")
	proto.RegisterType((*AzElOrientation)(nil), "onos.topo.AzElOrientation")
	proto.RegisterType((*YprOrientation)(nil), "onos.topo.YprOrientation")
	proto.RegisterType((*Orientation)(nil), "onos.topo.Orientation")
	proto.RegisterType((*Waypoint)(nil), "onos.topo.Waypoint")
	proto.RegisterType((*Waypoints)(nil), "onos.topo.Waypoints")
	proto.RegisterType((*OrbitData)(nil), "onos.topo.OrbitData")
	proto.RegisterType((*Motion)(nil), "onos.topo.Motion")
	proto.RegisterType((*Coverage)(nil), "onos.topo.Coverage")
	proto.RegisterType((*E2Node)(nil), "onos.topo.E2Node")
	proto.RegisterMapType((map[string]*ServiceModelInfo)(nil), "onos.topo.E2Node.ServiceModelsEntry")
	proto.RegisterType((*E2NodeConfig)(nil), "onos.topo.E2NodeConfig")
	proto.RegisterType((*Lease)(nil), "onos.topo.Lease")
	proto.RegisterType((*Interface)(nil), "onos.topo.Interface")
	proto.RegisterType((*E2TInfo)(nil), "onos.topo.E2TInfo")
	proto.RegisterType((*XAppInfo)(nil), "onos.topo.XAppInfo")
	proto.RegisterType((*A1PolicyType)(nil), "onos.topo.A1PolicyType")
	proto.RegisterType((*A1TInfo)(nil), "onos.topo.A1TInfo")
	proto.RegisterType((*CellGlobalID)(nil), "onos.topo.CellGlobalID")
	proto.RegisterType((*NeighborCellID)(nil), "onos.topo.NeighborCellID")
	proto.RegisterType((*E2Cell)(nil), "onos.topo.E2Cell")
	proto.RegisterMapType((map[string]uint32)(nil), "onos.topo.E2Cell.KpiReportsEntry")
	proto.RegisterType((*ConnectivitySupport)(nil), "onos.topo.ConnectivitySupport")
	proto.RegisterType((*FDDInfo)(nil), "onos.topo.FDDInfo")
	proto.RegisterType((*TDDInfo)(nil), "onos.topo.TDDInfo")
	proto.RegisterType((*FrequencyInfo)(nil), "onos.topo.FrequencyInfo")
	proto.RegisterType((*TransmissionBandwidth)(nil), "onos.topo.TransmissionBandwidth")
	proto.RegisterType((*FrequencyBandList)(nil), "onos.topo.FrequencyBandList")
	proto.RegisterType((*FrequencyBandItem)(nil), "onos.topo.FrequencyBandItem")
	proto.RegisterType((*GlobalNgRanNodeID)(nil), "onos.topo.GlobalNgRanNodeID")
	proto.RegisterType((*GlobalGnbID)(nil), "onos.topo.GlobalGnbID")
	proto.RegisterType((*GlobalNgEnbID)(nil), "onos.topo.GlobalNgEnbID")
	proto.RegisterType((*TaiSupportList)(nil), "onos.topo.TaiSupportList")
	proto.RegisterType((*TaiSupportItem)(nil), "onos.topo.TaiSupportItem")
	proto.RegisterType((*XnBroadcastPlmn)(nil), "onos.topo.XnBroadcastPlmn")
	proto.RegisterType((*TaiSliceSupportList)(nil), "onos.topo.TaiSliceSupportList")
	proto.RegisterType((*SliceSupportItem)(nil), "onos.topo.SliceSupportItem")
	proto.RegisterType((*SNssai)(nil), "onos.topo.SNssai")
	proto.RegisterType((*AmfRegionInformation)(nil), "onos.topo.AmfRegionInformation")
	proto.RegisterType((*GlobalAmfRegionInformationItem)(nil), "onos.topo.GlobalAmfRegionInformationItem")
	proto.RegisterType((*NeighborInformationNr)(nil), "onos.topo.NeighborInformationNr")
	proto.RegisterType((*ServiceModelInfo)(nil), "onos.topo.ServiceModelInfo")
	proto.RegisterType((*RCRanFunction)(nil), "onos.topo.RCRanFunction")
	proto.RegisterType((*MHORanFunction)(nil), "onos.topo.MHORanFunction")
	proto.RegisterType((*KPMRanFunction)(nil), "onos.topo.KPMRanFunction")
	proto.RegisterType((*RSMRanFunction)(nil), "onos.topo.RSMRanFunction")
	proto.RegisterType((*RCEventTriggerStyle)(nil), "onos.topo.RCEventTriggerStyle")
	proto.RegisterType((*RCReportStyle)(nil), "onos.topo.RCReportStyle")
	proto.RegisterType((*RCInsertStyle)(nil), "onos.topo.RCInsertStyle")
	proto.RegisterType((*RCPolicyStyle)(nil), "onos.topo.RCPolicyStyle")
	proto.RegisterType((*PolicyAction)(nil), "onos.topo.PolicyAction")
	proto.RegisterType((*RCControlStyle)(nil), "onos.topo.RCControlStyle")
	proto.RegisterType((*ControlAction)(nil), "onos.topo.ControlAction")
	proto.RegisterType((*InsertIndication)(nil), "onos.topo.InsertIndication")
	proto.RegisterType((*RANParameter)(nil), "onos.topo.RANParameter")
	proto.RegisterType((*KPMReportStyle)(nil), "onos.topo.KPMReportStyle")
	proto.RegisterType((*MHOReportStyle)(nil), "onos.topo.MHOReportStyle")
	proto.RegisterType((*KPMMeasurement)(nil), "onos.topo.KPMMeasurement")
	proto.RegisterType((*RSMNodeSlicingCapabilityItem)(nil), "onos.topo.RSMNodeSlicingCapabilityItem")
	proto.RegisterType((*RSMSupportedSlicingConfigItem)(nil), "onos.topo.RSMSupportedSlicingConfigItem")
	proto.RegisterType((*RSMSliceItemList)(nil), "onos.topo.RSMSliceItemList")
	proto.RegisterType((*RSMSlicingItem)(nil), "onos.topo.RSMSlicingItem")
	proto.RegisterType((*RSMSliceParameters)(nil), "onos.topo.RSMSliceParameters")
	proto.RegisterType((*DuUeF1ApID)(nil), "onos.topo.DuUeF1apID")
	proto.RegisterType((*CuUeF1ApID)(nil), "onos.topo.CuUeF1apID")
	proto.RegisterType((*RanUeNgapID)(nil), "onos.topo.RanUeNgapID")
	proto.RegisterType((*EnbUeS1ApID)(nil), "onos.topo.EnbUeS1apID")
	proto.RegisterType((*AmfUeNgapID)(nil), "onos.topo.AmfUeNgapID")
	proto.RegisterType((*UeIdentity)(nil), "onos.topo.UeIdentity")
	proto.RegisterType((*DrbId)(nil), "onos.topo.DrbId")
	proto.RegisterType((*FiveGDrbId)(nil), "onos.topo.FiveGDrbId")
	proto.RegisterType((*Qfi)(nil), "onos.topo.Qfi")
	proto.RegisterType((*QoSflowLevelParameters)(nil), "onos.topo.QoSflowLevelParameters")
	proto.RegisterType((*DynamicFiveQi)(nil), "onos.topo.DynamicFiveQi")
	proto.RegisterType((*NonDynamicFiveQi)(nil), "onos.topo.NonDynamicFiveQi")
	proto.RegisterType((*FiveQi)(nil), "onos.topo.FiveQi")
	proto.RegisterType((*FourGDrbId)(nil), "onos.topo.FourGDrbId")
	proto.RegisterType((*Qci)(nil), "onos.topo.Qci")
}

func init() { proto.RegisterFile("onos/topo/ran.proto", fileDescriptor_23cc5f935e05bbb6) }

var fileDescriptor_23cc5f935e05bbb6 = []byte{
	// 4812 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5a, 0x4d, 0x6c, 0x1b, 0x49,
	0x76, 0x56, 0xf3, 0x47, 0x3f, 0x8f, 0x3f, 0x6a, 0x95, 0x64, 0x59, 0xb6, 0x6c, 0xd1, 0xd3, 0xb3,
	0x19, 0x4f, 0x84, 0x59, 0x5b, 0x92, 0x7f, 0xc6, 0x33, 0xf1, 0xfc, 0xf0, 0x4f, 0x16, 0xc7, 0x12,
	0x25, 0x17, 0xa9, 0xf5, 0xcc, 0x26, 0xbb, 0x8d, 0x66, 0x77, 0x91, 0xee, 0x1d, 0xb2, 0x9b, 0xee,
	0x6e, 0xda, 0x96, 0x83, 0x24, 0x58, 0x04, 0x48, 0xb0, 0x87, 0x20, 0x73, 0x4c, 0x2e, 0x39, 0x05,
	0xb9, 0x05, 0xb9, 0xe4, 0x9a, 0x5b, 0x90, 0xec, 0x71, 0x8f, 0x41, 0x02, 0x28, 0x81, 0xe6, 0x9e,
	0x43, 0xb0, 0x87, 0x60, 0x10, 0x04, 0x41, 0xfd, 0x74, 0x77, 0x35, 0x49, 0x79, 0xec, 0x99, 0x60,
	0x4f, 0xac, 0x7a, 0xef, 0x7b, 0xaf, 0x5e, 0xbd, 0x7a, 0xaf, 0xea, 0x55, 0x35, 0x61, 0xd9, 0x75,
	0x5c, 0xff, 0x66, 0xe0, 0x0e, 0xdd, 0x9b, 0x9e, 0xe1, 0xdc, 0x18, 0x7a, 0x6e, 0xe0, 0xa2, 0x05,
	0x4a, 0xbc, 0x41, 0x89, 0x97, 0x2f, 0xf5, 0x5c, 0xb7, 0xd7, 0x27, 0x37, 0x19, 0xa3, 0x33, 0xea,
	0xde, 0x34, 0x9c, 0x13, 0x8e, 0xba, 0xbc, 0xd2, 0x73, 0x7b, 0x2e, 0x6b, 0xde, 0xa4, 0x2d, 0x41,
	0x2d, 0x8d, 0x0b, 0x04, 0xf6, 0x80, 0xf8, 0x81, 0x31, 0x18, 0x72, 0x80, 0xf6, 0xb7, 0x0a, 0xcc,
	0xef, 0xbb, 0xa6, 0x11, 0xd8, 0xae, 0x83, 0x56, 0x20, 0xdd, 0x37, 0x82, 0x35, 0xe5, 0x9a, 0xf2,
	0xae, 0x52, 0x49, 0xad, 0x29, 0x98, 0x76, 0x19, 0xd5, 0xe9, 0xad, 0xa5, 0x24, 0xaa, 0xd3, 0x43,
	0x5b, 0x90, 0x7d, 0xde, 0xf3, 0xef, 0xdd, 0x5e, 0x4b, 0x5f, 0x53, 0xde, 0xcd, 0xed, 0xac, 0xdd,
	0x88, 0xac, 0xbc, 0xf1, 0x98, 0xd2, 0x43, 0xa5, 0x7b, 0x33, 0x98, 0x03, 0xd1, 0x7d, 0x58, 0x30,
	0x0d, 0x2f, 0x20, 0xbe, 0x6d, 0x38, 0x6b, 0x19, 0x26, 0x75, 0x45, 0x92, 0xaa, 0x86, 0x3c, 0x49,
	0x32, 0x16, 0xa8, 0x64, 0x21, 0x4d, 0x5e, 0x04, 0xda, 0x33, 0x28, 0x24, 0xd4, 0xa3, 0xb7, 0x20,
	0xdf, 0x37, 0x02, 0x3b, 0x18, 0x59, 0x44, 0xb7, 0x48, 0x8f, 0x1b, 0x8f, 0x73, 0x21, 0xad, 0x46,
	0x7a, 0xe8, 0x6d, 0x28, 0xf4, 0x5d, 0xa7, 0x17, 0x63, 0xd8, 0x54, 0x70, 0x3e, 0x22, 0x52, 0xd0,
	0x55, 0x00, 0xa3, 0x2f, 0xf4, 0x0c, 0xd8, 0xa4, 0x14, 0xbc, 0x10, 0x52, 0x0e, 0xb4, 0x5d, 0x58,
	0x9a, 0x30, 0x10, 0x2d, 0x42, 0xfa, 0x85, 0x3e, 0x10, 0x43, 0xa6, 0x5e, 0x1c, 0x50, 0xc2, 0x89,
	0x3e, 0x10, 0xfa, 0x53, 0x27, 0x8c, 0xf0, 0x32, 0x52, 0x97, 0x7a, 0x79, 0xa0, 0xbd, 0x84, 0xc5,
	0xf2, 0xcb, 0x7a, 0xff, 0xd0, 0xb3, 0x89, 0x13, 0x70, 0x2d, 0x25, 0xc8, 0x19, 0x2f, 0xed, 0xc1,
	0x28, 0x78, 0x22, 0x4d, 0x00, 0x04, 0x49, 0xd8, 0x4f, 0xfa, 0xe4, 0x19, 0x43, 0xcb, 0xf6, 0x47,
	0x44, 0x0a, 0x7a, 0x0b, 0xf2, 0x9e, 0x1b, 0xc4, 0x18, 0x3e, 0x64, 0x2e, 0xa4, 0xd5, 0x48, 0x4f,
	0x33, 0xa0, 0xf8, 0xc5, 0xd0, 0x93, 0x87, 0xbe, 0x08, 0x73, 0x27, 0xc6, 0x73, 0x69, 0xd8, 0xd9,
	0x13, 0xe3, 0x39, 0xd5, 0xb6, 0x0e, 0x0b, 0x43, 0x3b, 0x30, 0x9f, 0x48, 0xc3, 0xcd, 0x33, 0x02,
	0x65, 0x5e, 0x82, 0x79, 0xcf, 0xed, 0xf7, 0xa5, 0x61, 0xe6, 0x68, 0x9f, 0x0e, 0xf1, 0x07, 0x90,
	0x93, 0xf5, 0x6f, 0x41, 0xc6, 0x78, 0x49, 0xfa, 0x4c, 0x79, 0x6e, 0xe7, 0xb2, 0xb4, 0xda, 0x63,
	0x4e, 0xd8, 0x9b, 0xc1, 0x0c, 0x89, 0x7e, 0x08, 0xe9, 0x93, 0xa1, 0xc7, 0x86, 0xcc, 0xed, 0x5c,
	0x92, 0x04, 0x92, 0x96, 0xef, 0xcd, 0x60, 0x8a, 0xab, 0x14, 0x20, 0xe7, 0xc6, 0x54, 0xed, 0x4b,
	0x98, 0x7f, 0x6c, 0x9c, 0x0c, 0x5d, 0xdb, 0x09, 0xd0, 0x0d, 0xc8, 0xd0, 0x60, 0x8f, 0xc6, 0xe6,
	0x99, 0x70, 0x23, 0xcc, 0x84, 0x1b, 0xed, 0x30, 0x13, 0x30, 0xc3, 0xa1, 0x9b, 0x30, 0xdf, 0x17,
	0x0b, 0x2b, 0x86, 0x5f, 0x96, 0x86, 0x0f, 0xd7, 0x1c, 0x47, 0x20, 0xed, 0x3e, 0x2c, 0x84, 0x83,
	0xf9, 0x54, 0xfa, 0xb9, 0xe8, 0xac, 0x29, 0xd7, 0xd2, 0x63, 0xd2, 0x21, 0x0e, 0x47, 0x20, 0xed,
	0xd7, 0x0a, 0x2c, 0x1c, 0x7a, 0x1d, 0x3b, 0xa8, 0x19, 0x81, 0x41, 0xb3, 0x89, 0x0c, 0x5d, 0xf3,
	0xc9, 0x6b, 0x58, 0xcb, 0x81, 0xe8, 0x3a, 0x2c, 0xda, 0x8e, 0xd9, 0xb7, 0x9d, 0xf1, 0xb0, 0x28,
	0x4a, 0xe4, 0x70, 0xb5, 0x0c, 0xc3, 0x49, 0xac, 0x96, 0x61, 0x30, 0x56, 0x1e, 0x14, 0xc2, 0x32,
	0x51, 0xc1, 0x0a, 0xa1, 0x11, 0x64, 0x78, 0xbd, 0xd1, 0x80, 0x38, 0x01, 0x03, 0x67, 0x79, 0x04,
	0x85, 0x34, 0x2a, 0x40, 0x43, 0xd5, 0x71, 0x07, 0x46, 0xff, 0x84, 0x21, 0x66, 0x45, 0xa8, 0x72,
	0x92, 0x00, 0x0c, 0x88, 0xe1, 0xe8, 0x03, 0x97, 0xf9, 0x71, 0x8e, 0x03, 0x28, 0xe9, 0x80, 0x51,
	0xb4, 0xbf, 0x57, 0x60, 0x96, 0x37, 0xd1, 0x7d, 0x28, 0x76, 0xed, 0x17, 0xc4, 0xd2, 0x23, 0xb7,
	0x2b, 0xe7, 0xba, 0x7d, 0x6f, 0x06, 0x17, 0x18, 0x38, 0xca, 0xbd, 0xdb, 0xb0, 0x10, 0xfa, 0xd2,
	0x17, 0xeb, 0xb5, 0x32, 0xc5, 0xe3, 0x3e, 0xdd, 0x45, 0x22, 0x20, 0x7a, 0x0f, 0xb2, 0x2e, 0x75,
	0xba, 0xd8, 0xb5, 0x64, 0x89, 0x68, 0x31, 0xe8, 0x8e, 0xc5, 0x40, 0x95, 0x79, 0x98, 0xe5, 0x13,
	0xd1, 0x06, 0x30, 0x5f, 0x75, 0x9f, 0x11, 0xcf, 0xe8, 0x11, 0xb4, 0x0a, 0xb3, 0x4f, 0x88, 0xdd,
	0x7b, 0xc2, 0x37, 0xca, 0x2c, 0x16, 0x3d, 0x9a, 0x33, 0x86, 0x67, 0xea, 0xcf, 0x6d, 0x2b, 0x78,
	0xc2, 0x2c, 0xca, 0xe2, 0x79, 0xc3, 0x33, 0x1f, 0xd3, 0x3e, 0x5a, 0x83, 0x39, 0x91, 0xd1, 0x6c,
	0xe8, 0x2c, 0x0e, 0xbb, 0x08, 0xd1, 0x38, 0xed, 0x07, 0x6c, 0x1d, 0xb2, 0x98, 0xb5, 0x99, 0x97,
	0xea, 0x3b, 0x4d, 0xd7, 0x22, 0xe8, 0x21, 0x14, 0x7d, 0xe2, 0x3d, 0xb3, 0x4d, 0xa2, 0x0f, 0x5c,
	0x8b, 0xf4, 0x7d, 0x11, 0x5e, 0x3f, 0x90, 0x4c, 0xe7, 0xd0, 0x1b, 0x2d, 0x8e, 0x3b, 0x60, 0xb0,
	0xba, 0x13, 0x78, 0x27, 0xb8, 0xe0, 0xcb, 0xb4, 0xcb, 0x3f, 0x01, 0x34, 0x09, 0x42, 0x2a, 0xa4,
	0xbf, 0x24, 0x27, 0x6c, 0x36, 0x0b, 0x98, 0x36, 0xd1, 0x36, 0x64, 0x9f, 0x19, 0xfd, 0x11, 0x11,
	0x8e, 0x5d, 0x97, 0xc6, 0x92, 0xe5, 0x1b, 0x4e, 0xd7, 0xc5, 0x1c, 0xf9, 0x61, 0xea, 0x9e, 0xa2,
	0x75, 0x21, 0xcf, 0x4d, 0xa9, 0xba, 0x4e, 0xd7, 0xee, 0xa1, 0xfb, 0x90, 0x33, 0x5d, 0xc7, 0x21,
	0x26, 0xf5, 0x61, 0x68, 0xb8, 0xec, 0xf3, 0x86, 0x13, 0x10, 0xaf, 0x6b, 0x98, 0xa4, 0x92, 0xf9,
	0xe5, 0x69, 0x69, 0x06, 0xcb, 0x70, 0xea, 0xb2, 0x67, 0xc4, 0xf3, 0xc3, 0x7c, 0xcc, 0xe0, 0xb0,
	0xab, 0x35, 0x20, 0xbb, 0x4f, 0x0c, 0x9f, 0xa0, 0x4f, 0x01, 0xc8, 0x8b, 0xa1, 0xed, 0xc9, 0xe1,
	0xf3, 0x8a, 0xdc, 0xa9, 0x64, 0xbe, 0xfa, 0xf7, 0x92, 0x82, 0x25, 0x19, 0xed, 0xbf, 0x14, 0x58,
	0x88, 0xac, 0x40, 0x3f, 0x84, 0x4c, 0x70, 0x32, 0xe4, 0x7b, 0x46, 0x31, 0xb1, 0xfd, 0x44, 0x98,
	0x1b, 0xed, 0x93, 0x21, 0xc1, 0x0c, 0x86, 0x56, 0x21, 0x65, 0x0f, 0x99, 0x71, 0x0b, 0x95, 0xd9,
	0xb3, 0xd3, 0x52, 0xaa, 0x71, 0x84, 0x53, 0xf6, 0x90, 0x2e, 0xe9, 0xd0, 0xf5, 0x78, 0x90, 0x15,
	0x30, 0x6b, 0x6b, 0xbf, 0x50, 0x20, 0x43, 0x45, 0xd1, 0x05, 0x58, 0x6a, 0x34, 0xdb, 0x75, 0xbc,
	0x5b, 0xae, 0xd6, 0xf5, 0xe3, 0xe6, 0xc3, 0xe6, 0xe1, 0xe3, 0xa6, 0x3a, 0x83, 0x96, 0xa0, 0x10,
	0x93, 0xeb, 0x3b, 0x6d, 0x55, 0x49, 0x22, 0xeb, 0x3b, 0xe5, 0xa3, 0xed, 0xad, 0x6d, 0x35, 0x35,
	0x49, 0xde, 0xd9, 0xda, 0x52, 0xd3, 0x49, 0x72, 0x79, 0x5b, 0xff, 0xbc, 0x7c, 0x74, 0xa4, 0x66,
	0x10, 0x82, 0xa2, 0x4c, 0x2e, 0x1f, 0xa9, 0x59, 0xed, 0x13, 0x98, 0xab, 0xef, 0xb4, 0xe9, 0xea,
	0xa1, 0xdb, 0x00, 0x76, 0x38, 0xb5, 0x57, 0xae, 0x10, 0x96, 0x70, 0xda, 0xcf, 0x15, 0x98, 0xff,
	0xbc, 0x3c, 0x1c, 0x7e, 0x77, 0x15, 0xe8, 0x13, 0x58, 0x34, 0xb6, 0xf5, 0xa1, 0xdb, 0xb7, 0xcd,
	0x13, 0x9d, 0x7a, 0x93, 0x66, 0x31, 0x15, 0xbd, 0x28, 0x9f, 0x12, 0xdb, 0x47, 0x0c, 0xc0, 0x7c,
	0x5e, 0x30, 0xa4, 0x9e, 0xaf, 0xfd, 0xa7, 0x02, 0x79, 0x99, 0x8f, 0xde, 0x81, 0x94, 0x6d, 0xf1,
	0x28, 0xae, 0xac, 0xb2, 0xd5, 0xa8, 0x7d, 0x73, 0x5a, 0xca, 0xc7, 0x88, 0x46, 0x0d, 0xa7, 0x6c,
	0x8b, 0x1e, 0x0c, 0x8e, 0x31, 0x20, 0x62, 0xdd, 0x2e, 0x9f, 0x9d, 0x96, 0x32, 0x4d, 0x63, 0x40,
	0xbe, 0x39, 0x2d, 0x15, 0x63, 0x2c, 0xa5, 0x60, 0x86, 0x43, 0x1f, 0xc6, 0x71, 0x98, 0x66, 0x22,
	0xd7, 0xce, 0x4e, 0x4b, 0x73, 0x3f, 0xe2, 0xa4, 0x6f, 0x4e, 0x4b, 0x4b, 0xb1, 0x94, 0x20, 0x46,
	0x91, 0x8a, 0x3e, 0x83, 0x9c, 0x45, 0x7c, 0xd3, 0xb3, 0x87, 0x2c, 0x42, 0x33, 0x4c, 0xfe, 0xdd,
	0xb3, 0xd3, 0x52, 0xae, 0x16, 0x93, 0xbf, 0x39, 0x2d, 0x5d, 0x88, 0x75, 0x48, 0x0c, 0x2c, 0x0b,
	0xd3, 0x55, 0x2b, 0x6f, 0x7f, 0x9f, 0x55, 0x3b, 0x86, 0x7c, 0x95, 0xf4, 0xfb, 0x0f, 0xfa, 0x6e,
	0xc7, 0xe8, 0x37, 0x6a, 0x68, 0x25, 0xcc, 0x72, 0x9e, 0xf9, 0xbc, 0x83, 0x6e, 0x8a, 0x1c, 0x48,
	0xb1, 0x1c, 0x90, 0x53, 0x5f, 0x16, 0x8e, 0xb3, 0x40, 0xfb, 0x13, 0x05, 0x8a, 0x4d, 0xba, 0x05,
	0x76, 0x5c, 0x8f, 0x42, 0x1a, 0x35, 0x74, 0x08, 0x45, 0x93, 0xf4, 0xfb, 0x7a, 0x8f, 0xa1, 0x75,
	0xb1, 0x2c, 0xc9, 0xb5, 0x95, 0xb5, 0x55, 0xd4, 0xb3, 0xd3, 0x52, 0xc2, 0x38, 0x9c, 0x37, 0xe3,
	0x9e, 0x85, 0xde, 0x86, 0xb9, 0x61, 0x7f, 0xe0, 0x50, 0x4d, 0x7c, 0xd9, 0xe0, 0xec, 0xb4, 0x34,
	0x7b, 0xd4, 0x1f, 0x38, 0x8d, 0x1a, 0x9e, 0xa5, 0xac, 0x86, 0xa5, 0xfd, 0xdb, 0x02, 0xdd, 0x35,
	0xa9, 0x16, 0x74, 0x57, 0x18, 0xe0, 0x76, 0x7e, 0x46, 0xcc, 0x40, 0x8f, 0xe2, 0x22, 0x1a, 0xe7,
	0x90, 0x31, 0xc2, 0x71, 0x44, 0xcf, 0x9a, 0x62, 0x78, 0xea, 0xfb, 0x1a, 0x5e, 0x30, 0x9c, 0x80,
	0x38, 0x8e, 0xa1, 0x9b, 0xee, 0xc8, 0x09, 0xf7, 0x84, 0xbc, 0x20, 0x56, 0x29, 0x0d, 0x95, 0x20,
	0x6b, 0x78, 0x5d, 0x93, 0xc7, 0x47, 0xa1, 0xb2, 0x70, 0x76, 0x5a, 0xca, 0x96, 0xf1, 0x6e, 0xb5,
	0x89, 0x39, 0x9d, 0x1e, 0x2d, 0xcc, 0x2c, 0xb6, 0x30, 0x59, 0xb6, 0x5a, 0xf3, 0x94, 0xc0, 0xe2,
	0xfe, 0x12, 0xa4, 0x87, 0xa6, 0xcd, 0x0e, 0xe3, 0x42, 0x65, 0xee, 0xec, 0xb4, 0x94, 0x3e, 0xaa,
	0x36, 0x30, 0xa5, 0x21, 0x0c, 0xb9, 0x2f, 0x87, 0xb6, 0xee, 0x11, 0xba, 0x05, 0xf9, 0x6b, 0x73,
	0x2c, 0x50, 0xde, 0x4a, 0x9c, 0x1c, 0xd4, 0xf6, 0x1b, 0x0f, 0x87, 0x36, 0xe6, 0x18, 0x76, 0x22,
	0x54, 0x8a, 0x67, 0xa7, 0x25, 0x88, 0x89, 0x18, 0xbe, 0x8c, 0xda, 0xe8, 0xc7, 0xb0, 0xe4, 0x88,
	0xd5, 0xd6, 0x99, 0x51, 0xb6, 0xe5, 0xaf, 0xcd, 0x33, 0xcd, 0xf2, 0x86, 0x99, 0x8c, 0x88, 0xca,
	0xf2, 0xd9, 0x69, 0x69, 0x31, 0x49, 0xf3, 0xf1, 0xa2, 0x23, 0x13, 0x2c, 0x1f, 0x5d, 0x86, 0x85,
	0x9e, 0xd3, 0xd1, 0xad, 0x11, 0xf5, 0xfc, 0x02, 0xf3, 0xd4, 0x5c, 0xcf, 0xe9, 0xd4, 0x46, 0x0d,
	0x0b, 0xbd, 0x07, 0xa8, 0x6f, 0x04, 0xc4, 0x0f, 0x74, 0xcf, 0x33, 0xf5, 0x30, 0x23, 0x81, 0x81,
	0x54, 0xce, 0xc1, 0x9e, 0x29, 0x32, 0x90, 0x56, 0xb6, 0x61, 0xc0, 0xe4, 0x18, 0x44, 0x04, 0x09,
	0xad, 0x72, 0xe8, 0x99, 0x48, 0x2c, 0x9d, 0x12, 0xfc, 0xb5, 0xfc, 0xb5, 0xf4, 0xbb, 0x05, 0x9c,
	0xe3, 0x34, 0x1a, 0x50, 0xac, 0x96, 0xeb, 0x5a, 0x96, 0x6e, 0x3b, 0x5d, 0x77, 0xad, 0xc0, 0x96,
	0x1f, 0x49, 0x13, 0xdb, 0xad, 0xd5, 0x68, 0x0e, 0xee, 0xcd, 0xe0, 0xb9, 0xae, 0x65, 0xb1, 0x74,
	0xbc, 0x09, 0xf3, 0x41, 0x28, 0x50, 0x9c, 0x10, 0x68, 0xc7, 0x02, 0x81, 0x10, 0xd8, 0x83, 0x6b,
	0x03, 0x62, 0xf8, 0x23, 0x8f, 0xb0, 0x6a, 0x2b, 0xb0, 0x07, 0xb6, 0xd3, 0xd3, 0x4d, 0x76, 0x6a,
	0x8e, 0xc4, 0x69, 0xb6, 0xc8, 0xcc, 0xde, 0x90, 0x70, 0x6d, 0x06, 0xab, 0xca, 0x28, 0xd4, 0x84,
	0x0b, 0x22, 0x56, 0x9d, 0x9e, 0xee, 0x19, 0x8e, 0xee, 0xb8, 0x16, 0xa1, 0xb3, 0x56, 0x27, 0x2e,
	0x58, 0x3c, 0x26, 0x9b, 0x3d, 0x6c, 0x38, 0xf4, 0x8c, 0x6e, 0xd4, 0xf0, 0x52, 0x6f, 0x8c, 0x64,
	0xa1, 0x2a, 0xa8, 0x81, 0x61, 0xeb, 0xfe, 0x68, 0x48, 0x57, 0x5b, 0xef, 0xdb, 0x7e, 0xb0, 0xb6,
	0x34, 0x51, 0x8c, 0xb7, 0x0d, 0xbb, 0xc5, 0x11, 0xfb, 0xb6, 0x1f, 0xe0, 0x62, 0x90, 0xe8, 0xa3,
	0x63, 0x58, 0x35, 0x06, 0x5d, 0xdd, 0x23, 0x3d, 0x5a, 0x9a, 0x52, 0xb7, 0x78, 0x03, 0x3e, 0x29,
	0xc4, 0x54, 0x95, 0xe4, 0x2d, 0x7e, 0xd0, 0xc5, 0x0c, 0xd7, 0x88, 0x61, 0x78, 0xc5, 0x98, 0x42,
	0x45, 0x8f, 0x60, 0x25, 0xac, 0x0f, 0x9e, 0xd9, 0xc1, 0x49, 0x68, 0xe4, 0xda, 0x32, 0x53, 0xba,
	0x21, 0xa7, 0xa8, 0x04, 0x13, 0x86, 0xe1, 0x65, 0x73, 0x92, 0x88, 0x7e, 0x0c, 0x6b, 0x51, 0x30,
	0x4b, 0x76, 0xea, 0x8e, 0xe7, 0xaf, 0xad, 0xb0, 0x98, 0xbe, 0x36, 0x25, 0xa6, 0x25, 0xa3, 0x9a,
	0x1e, 0x5e, 0x75, 0xa6, 0x91, 0xfd, 0xcb, 0x1f, 0xc1, 0xe2, 0x58, 0x5e, 0x4d, 0xa9, 0xb4, 0x56,
	0xe4, 0x4a, 0xab, 0x20, 0x15, 0x53, 0x95, 0x22, 0xe4, 0x1d, 0x8f, 0xd5, 0x7c, 0xcc, 0x32, 0xed,
	0x11, 0x2c, 0x4f, 0x99, 0x16, 0xfa, 0x10, 0x0a, 0xc4, 0xd1, 0x2d, 0x33, 0xf2, 0x06, 0xaf, 0x5d,
	0x56, 0xe5, 0x24, 0x77, 0x6a, 0x66, 0xe8, 0x85, 0x1c, 0x89, 0x3b, 0xda, 0x3f, 0xa4, 0x60, 0x4e,
	0x84, 0x33, 0xfa, 0x10, 0xf2, 0xa3, 0xbe, 0xde, 0xf5, 0xc8, 0x53, 0x1e, 0xc7, 0xca, 0xc4, 0xb5,
	0x7e, 0xd7, 0x23, 0x4f, 0x47, 0xc4, 0x31, 0x4f, 0x58, 0xd9, 0x07, 0xa3, 0x3e, 0x25, 0x84, 0xb2,
	0x96, 0x2c, 0x9b, 0xfa, 0x36, 0x59, 0x2b, 0x96, 0xfd, 0x3d, 0xb8, 0x34, 0xea, 0xeb, 0x81, 0x67,
	0x38, 0xfe, 0xc0, 0xf6, 0x69, 0xee, 0xea, 0x1d, 0xc3, 0xb1, 0x78, 0x15, 0xcd, 0xab, 0x74, 0x79,
	0x09, 0xda, 0x12, 0xb0, 0x12, 0xe2, 0xf0, 0xc5, 0x51, 0x7f, 0x2a, 0x83, 0x6a, 0xb7, 0xce, 0xd5,
	0x9e, 0x79, 0x5d, 0xed, 0xd6, 0x74, 0xed, 0xda, 0x5f, 0x29, 0x30, 0xd7, 0x8e, 0xfd, 0xe7, 0x78,
	0x6f, 0xe2, 0x3f, 0xc7, 0x8b, 0x7c, 0xf0, 0x18, 0x56, 0xcf, 0x31, 0x31, 0xf5, 0x9a, 0x26, 0x5e,
	0x08, 0xa6, 0x1a, 0xf8, 0x02, 0x0a, 0x89, 0x51, 0xe9, 0x65, 0xd0, 0xf1, 0x74, 0x7e, 0xd8, 0x28,
	0x7c, 0x7f, 0x75, 0xbc, 0x32, 0x3b, 0x63, 0xf6, 0x61, 0xb9, 0x1b, 0x62, 0x99, 0x05, 0x3c, 0xf9,
	0x53, 0x13, 0xfb, 0x48, 0xa4, 0x91, 0x8e, 0xc3, 0xf2, 0x7f, 0xa9, 0x3b, 0x4e, 0xd2, 0x3a, 0x70,
	0x61, 0xfa, 0x8a, 0x5c, 0x87, 0x59, 0xc7, 0xd3, 0x7d, 0xd3, 0x17, 0x81, 0xaa, 0xca, 0xf9, 0xe5,
	0xb5, 0x4c, 0x1f, 0x67, 0x1d, 0xfa, 0x83, 0xae, 0x41, 0xda, 0xf1, 0x3a, 0xa2, 0x0c, 0x29, 0x26,
	0x50, 0x1d, 0x4c, 0x59, 0x9a, 0x09, 0x4b, 0x13, 0xb6, 0xa0, 0x26, 0xac, 0x8c, 0x4d, 0xc3, 0x0e,
	0xc8, 0x20, 0x2c, 0x92, 0xce, 0x9d, 0x47, 0x23, 0x20, 0x03, 0x8c, 0xba, 0xe3, 0x24, 0x5f, 0xfb,
	0x64, 0x6c, 0x10, 0x4a, 0x45, 0x9b, 0xb0, 0x24, 0x16, 0x3b, 0x1e, 0x47, 0xf8, 0x73, 0x91, 0xaf,
	0x6b, 0x84, 0xd7, 0xfe, 0x4e, 0x81, 0xa5, 0x89, 0xad, 0x17, 0xdd, 0x87, 0x82, 0xd8, 0xb7, 0xe9,
	0x81, 0x17, 0x15, 0x48, 0xab, 0x13, 0xfb, 0xf5, 0x03, 0xa7, 0xd3, 0xa8, 0xed, 0xcd, 0xe0, 0x5c,
	0x2f, 0xea, 0xb2, 0x5d, 0x3a, 0xde, 0xf5, 0x09, 0x57, 0x30, 0x99, 0x74, 0xe1, 0xa8, 0x75, 0xa1,
	0xa2, 0xd0, 0x93, 0x08, 0x56, 0xe5, 0xe2, 0x39, 0x47, 0x87, 0xf6, 0xbb, 0x90, 0x93, 0xc6, 0x96,
	0x8f, 0x52, 0x25, 0x71, 0x94, 0x5e, 0x80, 0xd9, 0x5e, 0x3c, 0x76, 0x01, 0x67, 0x7b, 0xcc, 0xb8,
	0x2b, 0x00, 0x9c, 0xac, 0xf7, 0x89, 0x23, 0xea, 0x9d, 0x79, 0xc6, 0xda, 0x27, 0x8e, 0xf6, 0x8f,
	0x0a, 0x14, 0x12, 0x86, 0x9d, 0xaf, 0xff, 0x3a, 0x2c, 0x0e, 0x0c, 0xd3, 0x73, 0xc7, 0x26, 0x59,
	0xd8, 0x9b, 0xc1, 0x79, 0xc6, 0x10, 0x33, 0x41, 0x3b, 0x70, 0xc1, 0x7f, 0x42, 0x8f, 0xab, 0x71,
	0x78, 0x5a, 0xc0, 0x97, 0x18, 0xfb, 0x40, 0x96, 0xd9, 0x82, 0x95, 0xbe, 0xeb, 0xf4, 0x26, 0x44,
	0x32, 0x42, 0x44, 0xa5, 0x5c, 0x59, 0xa2, 0x92, 0x83, 0x85, 0x08, 0xa6, 0x3d, 0x86, 0x62, 0xf2,
	0x10, 0x44, 0x75, 0x58, 0x92, 0x4f, 0x4e, 0x39, 0xea, 0xa6, 0x1f, 0x9d, 0x2c, 0xe4, 0x16, 0x83,
	0x44, 0xdf, 0xd7, 0x7a, 0xb2, 0x62, 0x16, 0x6c, 0x2a, 0xa4, 0x03, 0xc3, 0x14, 0xbe, 0xa1, 0x4d,
	0x54, 0x85, 0xc5, 0x8e, 0xe7, 0x1a, 0x96, 0x69, 0xf8, 0x81, 0x28, 0x63, 0xf8, 0xdd, 0x49, 0x7e,
	0x61, 0xfb, 0xdc, 0xa9, 0x84, 0x18, 0x5a, 0xd6, 0xe0, 0x62, 0x47, 0xee, 0xfa, 0xda, 0x1f, 0xc1,
	0xe2, 0x18, 0xe4, 0xfc, 0x95, 0x68, 0xc1, 0x2a, 0x9b, 0x5b, 0xdf, 0x36, 0x49, 0xb2, 0x36, 0x48,
	0x4d, 0x9c, 0xbd, 0xd4, 0x7a, 0x8a, 0x93, 0x0b, 0x84, 0xe5, 0x60, 0x92, 0xa8, 0x75, 0x60, 0x79,
	0x0a, 0x16, 0x3d, 0x84, 0xe5, 0xe4, 0x38, 0xb2, 0x27, 0x13, 0x2f, 0x11, 0x92, 0x24, 0xf3, 0xe5,
	0x92, 0x3f, 0x46, 0xf1, 0xb5, 0x8f, 0x41, 0x1d, 0x87, 0xa1, 0x4d, 0x98, 0xf3, 0x75, 0xc7, 0xf7,
	0x0d, 0x5b, 0x24, 0xdd, 0x92, 0xac, 0xb4, 0x49, 0x19, 0x78, 0xd6, 0x67, 0xbf, 0xda, 0x26, 0xcc,
	0x72, 0x0a, 0x5d, 0x05, 0xdf, 0x0f, 0xc2, 0x55, 0xf0, 0xfd, 0x00, 0x15, 0x21, 0xe5, 0x87, 0xa1,
	0x9f, 0xf2, 0x2d, 0xed, 0xcf, 0x15, 0x58, 0x99, 0x56, 0xcd, 0xa0, 0xe7, 0xf0, 0xb6, 0x48, 0xb4,
	0xe9, 0x55, 0x51, 0x62, 0x86, 0xbf, 0x3d, 0x91, 0xc0, 0xd3, 0x74, 0xb2, 0xf9, 0x96, 0x7a, 0xaf,
	0xe4, 0xfb, 0xda, 0x4f, 0x60, 0xe3, 0xd5, 0x2a, 0xce, 0x5f, 0x71, 0x0d, 0x0a, 0xb2, 0xb1, 0xe1,
	0x3c, 0x73, 0x71, 0x61, 0x66, 0x69, 0xff, 0x93, 0x82, 0x0b, 0x53, 0x4b, 0x22, 0xea, 0x2c, 0x7a,
	0x25, 0x11, 0xce, 0xa2, 0x37, 0x91, 0x2d, 0xb6, 0xed, 0x9b, 0x3d, 0x7b, 0xca, 0xd3, 0x6e, 0xf2,
	0x5a, 0x40, 0xf7, 0xff, 0x6a, 0xcf, 0x0e, 0xc3, 0x3e, 0x1d, 0x87, 0xbd, 0x5c, 0x97, 0x67, 0xde,
	0xb4, 0x2e, 0xcf, 0xbe, 0x4e, 0x5d, 0x7e, 0x5e, 0x85, 0x39, 0xfb, 0xdd, 0x2b, 0xcc, 0xd7, 0x29,
	0xf5, 0xe7, 0x5e, 0xa7, 0xd4, 0x9f, 0x28, 0x08, 0xff, 0x5a, 0x01, 0x75, 0xfc, 0x35, 0x8e, 0x5e,
	0x06, 0xdd, 0xe8, 0xb6, 0xcb, 0x2e, 0x83, 0x87, 0x8d, 0x1a, 0xa6, 0x34, 0x84, 0xe4, 0x77, 0x0f,
	0xf1, 0xb6, 0xf1, 0x01, 0x14, 0xe8, 0xce, 0xdf, 0x1d, 0x39, 0xe2, 0x8d, 0x2e, 0x2d, 0xde, 0x12,
	0xc6, 0xdf, 0xd0, 0xca, 0xce, 0x09, 0xce, 0x7b, 0x86, 0xb3, 0x1b, 0x22, 0xd1, 0x3b, 0x50, 0x94,
	0xfa, 0x8d, 0x9a, 0xbf, 0x96, 0x61, 0x57, 0xa9, 0x31, 0xaa, 0xf6, 0xdf, 0x29, 0x28, 0xe0, 0x2a,
	0x8e, 0x89, 0xec, 0xd9, 0x2c, 0x34, 0x91, 0x3f, 0x9b, 0xf1, 0x87, 0x99, 0x8f, 0xa0, 0xc0, 0x6f,
	0xaa, 0xba, 0x1f, 0x9c, 0xf4, 0xa3, 0x07, 0x21, 0xf9, 0x48, 0xc3, 0x55, 0x5e, 0x4f, 0xb7, 0x28,
	0x00, 0xe7, 0xbd, 0xb8, 0xe3, 0x53, 0x71, 0xdb, 0xf1, 0x49, 0x2c, 0x9e, 0x9e, 0x22, 0xde, 0x60,
	0x08, 0x21, 0x6e, 0xc7, 0x1d, 0x1f, 0x1d, 0xc1, 0x0a, 0x79, 0xc6, 0x96, 0xc8, 0xb3, 0x7b, 0x3d,
	0xe2, 0x85, 0x5a, 0x32, 0x4c, 0xcb, 0x46, 0x42, 0x4b, 0x9d, 0x02, 0xdb, 0x1c, 0xc7, 0x75, 0x21,
	0x32, 0x4e, 0x62, 0x06, 0x89, 0xf7, 0x2d, 0xa1, 0x2a, 0x3b, 0xc5, 0x20, 0xfe, 0xf0, 0x23, 0x0c,
	0x1a, 0xc6, 0x1d, 0x1f, 0x7d, 0x0a, 0x45, 0xd3, 0x75, 0x02, 0xcf, 0xed, 0x87, 0xf2, 0xb3, 0x13,
	0xa7, 0x09, 0xae, 0x56, 0x39, 0x84, 0x2b, 0x28, 0x98, 0x52, 0xcf, 0xd7, 0x9e, 0x40, 0xf1, 0x60,
	0xef, 0xf0, 0x75, 0x5c, 0xff, 0xf1, 0x74, 0xd7, 0xcb, 0x43, 0x51, 0x4d, 0xe7, 0xf9, 0x9e, 0x8e,
	0xf4, 0xf0, 0xe8, 0xe0, 0xff, 0x69, 0x24, 0xaa, 0xe9, 0xdc, 0x91, 0xfe, 0x52, 0x81, 0x22, 0x6e,
	0xbd, 0xd6, 0x50, 0x2e, 0x5c, 0xf3, 0x6c, 0x93, 0x9d, 0x5a, 0x34, 0xe7, 0x58, 0x79, 0x63, 0x1a,
	0x43, 0xa3, 0x63, 0xf7, 0x69, 0x72, 0x8b, 0xf3, 0x8b, 0x8e, 0x7e, 0x5d, 0x76, 0x69, 0xeb, 0x80,
	0xd6, 0x68, 0x2d, 0x2e, 0x55, 0x8d, 0xf0, 0x6c, 0xcb, 0xbd, 0xe2, 0xd9, 0xa6, 0xe0, 0xb0, 0x77,
	0xee, 0x88, 0xcb, 0x4e, 0xb4, 0x9f, 0xc2, 0xf2, 0x94, 0xd8, 0x88, 0x12, 0x4f, 0x91, 0x12, 0x0f,
	0x49, 0xaf, 0x6c, 0x59, 0xf1, 0x9c, 0x5c, 0x82, 0x1c, 0xdf, 0x44, 0xf9, 0x3b, 0x0f, 0xff, 0x4e,
	0x00, 0x9c, 0xd4, 0x3e, 0x19, 0x12, 0xed, 0x39, 0xcb, 0xa4, 0xd8, 0x1b, 0xaf, 0xad, 0xf9, 0x63,
	0x96, 0xab, 0xfa, 0xd0, 0xf0, 0x8c, 0x01, 0x09, 0x88, 0x17, 0xe6, 0x86, 0xfc, 0xac, 0x85, 0xcb,
	0xcd, 0xa3, 0x90, 0x8f, 0xe9, 0xae, 0x10, 0xf5, 0x7c, 0xed, 0x8f, 0x15, 0x3a, 0xb2, 0x94, 0x3b,
	0xaf, 0x3d, 0xf2, 0x67, 0x80, 0x44, 0x52, 0xda, 0x8e, 0x65, 0xf3, 0x6f, 0x37, 0xe1, 0xe8, 0xeb,
	0x89, 0x17, 0x4b, 0x0a, 0x6a, 0x44, 0x18, 0xbc, 0x64, 0x8f, 0x51, 0x7c, 0x3e, 0x7d, 0x29, 0x5f,
	0xde, 0x64, 0xfa, 0x22, 0x11, 0x8d, 0xc4, 0x36, 0x27, 0x4f, 0x9f, 0xeb, 0x2d, 0x33, 0x3e, 0x16,
	0x79, 0xcb, 0x7b, 0xbe, 0xf6, 0x6b, 0x05, 0xf2, 0x32, 0x5f, 0x8a, 0xb8, 0x6c, 0x22, 0xe2, 0xa6,
	0x6d, 0xb1, 0x9f, 0xc3, 0x95, 0xc4, 0xe0, 0xfa, 0x9b, 0xad, 0xc4, 0x25, 0xd9, 0x14, 0x2c, 0xaf,
	0x0a, 0xfa, 0x29, 0x94, 0x84, 0x66, 0xd3, 0x75, 0x2c, 0x7b, 0x9a, 0xf2, 0xcc, 0xab, 0x95, 0x0b,
	0xcb, 0xaa, 0xa1, 0x78, 0x42, 0xbf, 0xf6, 0x17, 0x29, 0x28, 0x26, 0x37, 0x98, 0xd7, 0xf6, 0xf8,
	0x7b, 0x80, 0x9e, 0x10, 0xc3, 0x22, 0x9e, 0x3e, 0x19, 0xd1, 0x2a, 0xe7, 0xec, 0x46, 0x71, 0x8d,
	0x6e, 0xc0, 0xf2, 0x80, 0xf8, 0xbe, 0xd1, 0x23, 0x09, 0x38, 0xff, 0x22, 0xb6, 0x24, 0x58, 0x12,
	0xfe, 0x23, 0x58, 0x0f, 0x77, 0x46, 0x77, 0x14, 0x98, 0xee, 0x20, 0x29, 0x97, 0x65, 0x72, 0x6b,
	0x02, 0x72, 0xc8, 0x11, 0x92, 0x78, 0x19, 0x16, 0x43, 0xf1, 0x30, 0x1e, 0x66, 0x27, 0x76, 0x66,
	0x31, 0x6d, 0xe1, 0xf7, 0x70, 0x27, 0x0e, 0x23, 0xe2, 0xf7, 0xa1, 0x90, 0x00, 0xbc, 0x51, 0x44,
	0x7c, 0xdf, 0x6c, 0xfc, 0x43, 0x50, 0xc7, 0xd3, 0xe5, 0x37, 0x3a, 0xfe, 0x87, 0x90, 0x97, 0xd9,
	0xd2, 0xd8, 0xe9, 0x6f, 0x1b, 0x5b, 0x7b, 0xce, 0x0f, 0x8a, 0xef, 0xb0, 0x87, 0x7d, 0x04, 0x79,
	0xa9, 0x40, 0x0a, 0x6d, 0x1e, 0x3b, 0x37, 0x0e, 0x62, 0x04, 0x4e, 0xc0, 0xb5, 0x7b, 0xfc, 0x2c,
	0x7c, 0xf3, 0x81, 0xb5, 0xfb, 0xcc, 0x64, 0x49, 0xf3, 0xb9, 0x07, 0xce, 0xb4, 0x09, 0xff, 0x6b,
	0x0a, 0xae, 0xbc, 0xea, 0x48, 0x41, 0xb7, 0xe1, 0xe2, 0xc0, 0x78, 0xa1, 0x3b, 0xa3, 0x41, 0x87,
	0x78, 0xba, 0xdb, 0xe5, 0xb7, 0x2c, 0x5f, 0xb7, 0xfa, 0xe2, 0xfb, 0xf2, 0xf2, 0xc0, 0x78, 0xd1,
	0x64, 0xdc, 0xc3, 0x2e, 0xbb, 0xcc, 0xf8, 0xb5, 0xfe, 0xb9, 0x52, 0xa3, 0xbe, 0xb0, 0x7d, 0x52,
	0xea, 0xb8, 0x8f, 0xee, 0x43, 0x3e, 0x3c, 0x0d, 0xa3, 0x84, 0x4c, 0x7e, 0xe7, 0xc4, 0xad, 0x03,
	0x61, 0x26, 0xfb, 0xc2, 0x93, 0xf3, 0xe3, 0x0e, 0xfa, 0x1d, 0x58, 0x4f, 0x8e, 0x39, 0x22, 0xbe,
	0x3e, 0xa4, 0x95, 0x12, 0xd5, 0x2f, 0xd2, 0x75, 0x55, 0x1a, 0xf7, 0x98, 0xf8, 0x47, 0xc4, 0x63,
	0xa3, 0xa3, 0x16, 0xa8, 0xa2, 0x9a, 0x26, 0x96, 0x28, 0x7f, 0x45, 0x3d, 0xf4, 0xee, 0xd8, 0xf0,
	0x21, 0x2a, 0x74, 0x17, 0xc3, 0xf2, 0xcb, 0x72, 0xa4, 0x81, 0x13, 0xb5, 0x9f, 0xc1, 0xd5, 0x57,
	0x4a, 0xa0, 0x06, 0xbf, 0x4c, 0xc6, 0x25, 0xb7, 0x7e, 0xce, 0xf7, 0xdd, 0xfa, 0x4e, 0x6b, 0x80,
	0xfd, 0x41, 0xd5, 0x1d, 0x0c, 0x0c, 0xc7, 0xe2, 0x57, 0xc9, 0x48, 0x15, 0x3b, 0x7c, 0x5b, 0xa0,
	0x0a, 0xe7, 0x10, 0xaa, 0x9a, 0xdd, 0x55, 0x3f, 0x81, 0xa2, 0xe7, 0x0f, 0xc4, 0xbd, 0x98, 0xd5,
	0x13, 0x93, 0x17, 0xfe, 0xd8, 0xa3, 0x6c, 0x0e, 0x79, 0xcf, 0x1f, 0x30, 0x25, 0xac, 0x62, 0xf8,
	0x5f, 0x5e, 0xcd, 0x48, 0x80, 0x73, 0x83, 0xeb, 0x2a, 0x00, 0x1f, 0xc7, 0x22, 0xbe, 0x29, 0x42,
	0x6c, 0x81, 0x51, 0x6a, 0xc4, 0x37, 0xd1, 0x1e, 0xa8, 0x9c, 0x9d, 0x48, 0x6b, 0x7a, 0x6d, 0xb9,
	0x3a, 0x69, 0x0c, 0x89, 0xb3, 0x19, 0x2f, 0xfa, 0x49, 0x02, 0xba, 0x1b, 0x0e, 0x14, 0x6d, 0xc2,
	0xc5, 0xe4, 0xd6, 0x20, 0x74, 0xb0, 0x00, 0xe1, 0x16, 0xb0, 0xf0, 0xb8, 0x05, 0x30, 0x22, 0xec,
	0xd9, 0x87, 0x3a, 0x82, 0xaf, 0xed, 0x05, 0x49, 0xee, 0x98, 0x34, 0x2c, 0xe2, 0x04, 0x76, 0x70,
	0x82, 0xe7, 0x47, 0xa4, 0xc1, 0xdf, 0x09, 0xff, 0x4c, 0x01, 0x34, 0x69, 0x14, 0xaa, 0x40, 0xd1,
	0x37, 0x9f, 0x10, 0x6b, 0xd4, 0x27, 0x9e, 0xbc, 0x64, 0xeb, 0x63, 0x76, 0x84, 0x18, 0xfe, 0x81,
	0xd8, 0x97, 0xbb, 0x68, 0x15, 0x66, 0x9f, 0xf3, 0xff, 0x69, 0xf0, 0x8c, 0x10, 0x3d, 0xb4, 0x0e,
	0x0b, 0x4f, 0x5d, 0x5f, 0xef, 0x93, 0x67, 0xa4, 0x2f, 0x8e, 0xa4, 0xf9, 0xa7, 0xae, 0xbf, 0x4f,
	0xfb, 0x9a, 0x06, 0x50, 0x1b, 0x1d, 0x93, 0xdd, 0x6d, 0x63, 0x38, 0xfe, 0x85, 0x34, 0x2d, 0x5e,
	0xe7, 0x29, 0xa6, 0xfa, 0x6d, 0x98, 0xb7, 0x21, 0x87, 0x0d, 0xe7, 0x98, 0x34, 0x7b, 0xaf, 0x06,
	0xd5, 0x9d, 0xce, 0x31, 0x69, 0x4d, 0xd1, 0x94, 0x95, 0x40, 0xe5, 0x41, 0xf7, 0x5b, 0x34, 0xfd,
	0x22, 0x03, 0x10, 0xfb, 0x17, 0xed, 0x41, 0xc1, 0x1a, 0xe9, 0x23, 0xa2, 0x77, 0xb7, 0x8d, 0x61,
	0xfc, 0xba, 0x28, 0xaf, 0x46, 0x3c, 0x4b, 0xfe, 0xb5, 0x2f, 0xee, 0x63, 0xb0, 0xc2, 0xb6, 0x45,
	0x35, 0x99, 0x09, 0x4d, 0xa9, 0x09, 0x4d, 0xd5, 0x31, 0x4d, 0x55, 0x49, 0x93, 0x19, 0x6b, 0xda,
	0xe7, 0xa7, 0xce, 0x88, 0xe8, 0x4e, 0x8f, 0xab, 0x4a, 0x4f, 0x3c, 0x79, 0x4a, 0x2e, 0xab, 0x2c,
	0x9e, 0x9d, 0x96, 0x72, 0xb8, 0xdc, 0x0c, 0x09, 0x38, 0xe7, 0x45, 0x5c, 0xa6, 0x8d, 0x38, 0x1d,
	0xaa, 0xcd, 0x17, 0x86, 0x65, 0x26, 0xb4, 0x49, 0xbe, 0xe5, 0xda, 0x24, 0x02, 0xce, 0x91, 0xa8,
	0xc3, 0xb4, 0x19, 0x83, 0xae, 0x6c, 0x5b, 0x76, 0x42, 0x9b, 0xb4, 0x08, 0x5c, 0x5b, 0xf9, 0x60,
	0x37, 0xb6, 0xcd, 0x88, 0xb8, 0x16, 0x6a, 0xc3, 0xd2, 0xd0, 0x23, 0x5d, 0xe2, 0x79, 0xc4, 0xa2,
	0xf9, 0xc0, 0xe2, 0x77, 0x96, 0xc5, 0xef, 0xf2, 0x58, 0x3e, 0xd0, 0x40, 0xe5, 0xdf, 0x46, 0x8f,
	0x42, 0x09, 0xf1, 0x6d, 0x7d, 0x31, 0x52, 0xc1, 0x51, 0xe8, 0x3a, 0xcc, 0x5a, 0x1e, 0x7b, 0xa2,
	0x9c, 0x63, 0xb6, 0xc9, 0x0f, 0xe7, 0x35, 0xaf, 0xd3, 0xb0, 0x70, 0xd6, 0xa2, 0x3f, 0xda, 0x9f,
	0x2a, 0x90, 0x65, 0x04, 0xf4, 0x01, 0xe4, 0xbb, 0xee, 0xc8, 0xd3, 0x7b, 0x42, 0x70, 0x32, 0x0a,
	0x76, 0xdd, 0x91, 0xf7, 0x80, 0x81, 0xf7, 0x66, 0xe8, 0x55, 0x43, 0xf4, 0x6a, 0x4c, 0xd4, 0x7e,
	0x46, 0x22, 0xd1, 0xc9, 0x65, 0xdf, 0xb5, 0x9f, 0x11, 0x49, 0x34, 0xec, 0xd5, 0x2a, 0xf3, 0xa1,
	0xa1, 0xda, 0x57, 0x0a, 0x40, 0x0c, 0x9b, 0x1e, 0xdf, 0xe8, 0x1a, 0xa4, 0x9f, 0x76, 0xc3, 0x67,
	0x21, 0xf9, 0x9d, 0xff, 0x51, 0xd7, 0xc6, 0x94, 0x85, 0x3e, 0x03, 0xb5, 0xdb, 0x77, 0x9f, 0xfb,
	0xfa, 0xc0, 0x18, 0xea, 0x81, 0xab, 0x5b, 0x5e, 0x47, 0x9c, 0xfe, 0xf2, 0xa7, 0xec, 0x47, 0x6e,
	0x8b, 0xa2, 0x58, 0x1a, 0x4b, 0xdb, 0x5b, 0x81, 0x89, 0x1e, 0x18, 0xc3, 0xb6, 0x5b, 0xf3, 0x3a,
	0xda, 0x3a, 0xa4, 0x1f, 0x75, 0xed, 0x73, 0x52, 0xed, 0x9f, 0x15, 0x58, 0x9d, 0xae, 0x06, 0x55,
	0x60, 0xd1, 0x3a, 0x71, 0x8c, 0x81, 0x6d, 0xea, 0xcc, 0x2f, 0x4f, 0xed, 0x29, 0x5f, 0x78, 0x6a,
	0x1c, 0x41, 0xa7, 0xfc, 0xc8, 0xde, 0x9b, 0xc1, 0x05, 0x4b, 0x26, 0xa0, 0x7d, 0x58, 0x76, 0x5c,
	0x47, 0x1f, 0xd7, 0x33, 0xf9, 0x1f, 0xab, 0xa6, 0xeb, 0x8c, 0xab, 0x52, 0x9d, 0x31, 0x5a, 0x65,
	0x1d, 0x2e, 0xd1, 0x6d, 0x8c, 0x1a, 0xcb, 0xf7, 0x32, 0x69, 0xe7, 0xa7, 0x9e, 0x2f, 0x24, 0xe0,
	0xe8, 0xb7, 0xa0, 0x38, 0xf4, 0x6c, 0xd7, 0x63, 0x37, 0x5f, 0xb6, 0xf5, 0xf1, 0xa9, 0x17, 0x42,
	0x2a, 0x9b, 0x31, 0x2d, 0xdc, 0x87, 0x86, 0xf9, 0x25, 0x09, 0x74, 0x8b, 0xf4, 0x8d, 0x13, 0xbd,
	0x33, 0xb2, 0x7a, 0x61, 0x39, 0xa4, 0x72, 0x4e, 0x8d, 0x32, 0x2a, 0x94, 0x8e, 0x36, 0x61, 0x49,
	0xa0, 0x89, 0xe7, 0xb9, 0x9e, 0xee, 0x19, 0x41, 0x58, 0xe5, 0x2f, 0x72, 0x46, 0x9d, 0xd2, 0xb1,
	0x11, 0x10, 0xed, 0x63, 0x50, 0xc7, 0xe7, 0x85, 0x36, 0x61, 0x2e, 0xe9, 0xcd, 0xa5, 0xb1, 0x00,
	0x7b, 0x64, 0xe3, 0xd9, 0x2e, 0xfb, 0xd5, 0x36, 0x60, 0x56, 0x48, 0x4d, 0x5f, 0xbc, 0x1a, 0x40,
	0x1c, 0xcd, 0xaf, 0x88, 0x35, 0x73, 0x6a, 0xac, 0x99, 0x34, 0xd6, 0x4c, 0x9b, 0xc5, 0x87, 0x79,
	0xce, 0x10, 0x9b, 0x35, 0x28, 0xe2, 0x72, 0xb3, 0xce, 0xf6, 0xd8, 0x87, 0xb6, 0x63, 0xf9, 0x08,
	0xd8, 0xff, 0xf4, 0x0e, 0x6b, 0x75, 0x75, 0x86, 0xb7, 0xab, 0xf5, 0xfd, 0x7d, 0x55, 0x41, 0x73,
	0x90, 0xae, 0xef, 0xb4, 0xd5, 0x34, 0x9a, 0x87, 0x8c, 0xf8, 0x23, 0xd6, 0x1c, 0xa4, 0xcb, 0xdb,
	0x6d, 0x35, 0xbb, 0xf9, 0x11, 0xa8, 0xb8, 0xdc, 0xc4, 0xa4, 0xcf, 0x2a, 0x77, 0xae, 0x27, 0x0f,
	0xf3, 0xd5, 0xc3, 0x66, 0x1b, 0x1f, 0xee, 0xb7, 0xd4, 0x99, 0xb0, 0x57, 0x6e, 0x34, 0x5b, 0xaa,
	0x82, 0x0a, 0xb0, 0xd0, 0xac, 0x37, 0x1e, 0xec, 0x55, 0x0e, 0x71, 0x4b, 0x4d, 0x6d, 0x5e, 0x07,
	0x75, 0xfc, 0x8f, 0x38, 0x68, 0x01, 0xb2, 0x4d, 0x5c, 0x7d, 0xd0, 0x50, 0x67, 0xe8, 0x80, 0x75,
	0xda, 0x52, 0x36, 0x0f, 0x60, 0x9e, 0x56, 0x9d, 0x0c, 0x90, 0x83, 0xb9, 0x66, 0x5b, 0x6f, 0x1e,
	0x36, 0x85, 0xa1, 0xcd, 0xb6, 0xfe, 0xa0, 0x59, 0x11, 0xca, 0xdb, 0x7a, 0xbd, 0xc9, 0xba, 0x29,
	0xd1, 0x6d, 0x3e, 0xd0, 0xeb, 0xcd, 0x8a, 0x9a, 0x16, 0x48, 0xda, 0xce, 0x6c, 0xee, 0xd3, 0x2b,
	0xcf, 0x60, 0xe8, 0x3a, 0xc4, 0x09, 0x42, 0x9d, 0xd5, 0x48, 0xe7, 0x02, 0x64, 0xab, 0x6d, 0xbd,
	0x7a, 0xac, 0x2a, 0xcc, 0x7a, 0xda, 0xd4, 0x8f, 0x8f, 0xd4, 0x94, 0x60, 0xd4, 0x8e, 0xb9, 0xb6,
	0x6a, 0xa8, 0xed, 0x9f, 0x14, 0x28, 0x26, 0x6b, 0x2e, 0xa4, 0xc1, 0x46, 0x7d, 0x47, 0x6f, 0x1d,
	0xe8, 0xb8, 0x75, 0xa0, 0x57, 0x0f, 0x0f, 0x0e, 0xca, 0xcd, 0x9a, 0xde, 0xda, 0x6f, 0x54, 0xeb,
	0x7a, 0x15, 0xd7, 0xcb, 0x6d, 0x3a, 0xcc, 0x2b, 0x30, 0xc7, 0x47, 0x35, 0x8a, 0x51, 0x5e, 0x85,
	0xa9, 0xd5, 0xf7, 0xeb, 0xed, 0xba, 0x9a, 0x9a, 0x8e, 0x39, 0xae, 0xeb, 0xe5, 0x56, 0xeb, 0xb0,
	0xda, 0xa0, 0x7a, 0xd2, 0xe8, 0x07, 0x70, 0x6d, 0x12, 0x53, 0xff, 0x51, 0xbd, 0xd9, 0xd6, 0xdb,
	0xb8, 0xf1, 0xe0, 0x41, 0x1d, 0xb7, 0xd4, 0xcc, 0x66, 0x55, 0x2e, 0xe0, 0x98, 0x5f, 0x2e, 0xc2,
	0x32, 0x1d, 0xad, 0xd1, 0x7c, 0xa0, 0xb7, 0xbf, 0x38, 0xaa, 0xeb, 0xad, 0x76, 0xb9, 0xdd, 0xa8,
	0xaa, 0x33, 0x68, 0x0d, 0x56, 0x12, 0x8c, 0xda, 0x17, 0xcd, 0xf2, 0x41, 0xa3, 0xaa, 0x2a, 0x9b,
	0x2f, 0x78, 0x6d, 0x99, 0x28, 0x5f, 0x36, 0xe0, 0x72, 0xab, 0xba, 0x57, 0xaf, 0x1d, 0xef, 0xd7,
	0x31, 0xc7, 0xe3, 0xc3, 0xe3, 0x66, 0x4d, 0xc7, 0x87, 0x95, 0x46, 0x53, 0x9d, 0x41, 0xef, 0x80,
	0x36, 0xc6, 0x3f, 0xc2, 0x87, 0x47, 0x87, 0xb8, 0xdd, 0x38, 0x6c, 0x96, 0xf7, 0xf7, 0xbf, 0xd0,
	0x77, 0xcb, 0x0d, 0xac, 0x2a, 0xe8, 0x0a, 0xac, 0x8d, 0xe1, 0x1e, 0x1d, 0xb6, 0xf4, 0x4a, 0xb9,
	0x55, 0xaf, 0xa9, 0xa9, 0xcd, 0x4f, 0x21, 0x2f, 0xd7, 0x73, 0xa1, 0xf1, 0x75, 0x61, 0xe1, 0x3e,
	0x77, 0x9c, 0x3a, 0x33, 0xc6, 0x38, 0x0e, 0x19, 0xca, 0xe6, 0xdf, 0x28, 0x30, 0x1f, 0x1e, 0x65,
	0xe8, 0x2a, 0x5c, 0x3a, 0xae, 0xeb, 0x8d, 0x1a, 0x47, 0xd1, 0x18, 0xa8, 0xeb, 0xbb, 0xdb, 0x7a,
	0xf9, 0x48, 0x6f, 0xd4, 0xd4, 0x99, 0x31, 0x76, 0x2d, 0xc9, 0x56, 0xc6, 0xd8, 0xb8, 0xdc, 0xa4,
	0xfc, 0xe6, 0x03, 0xce, 0x4e, 0x8d, 0xb1, 0xcb, 0x07, 0xbb, 0x32, 0x3b, 0x4d, 0x1d, 0x26, 0xb1,
	0xeb, 0xcd, 0x0a, 0x65, 0xb7, 0x42, 0xed, 0x99, 0xcd, 0x06, 0x64, 0xd9, 0x07, 0x66, 0xb4, 0x08,
	0xb9, 0x56, 0xb5, 0x25, 0xfd, 0xf7, 0x12, 0x60, 0x96, 0x12, 0xb6, 0xef, 0xa8, 0x4a, 0xd8, 0xbe,
	0xb5, 0xa5, 0xa6, 0xc2, 0xf6, 0x9d, 0x2d, 0x35, 0x4d, 0xa3, 0x9d, 0x61, 0x76, 0xb6, 0xd4, 0xcc,
	0xe6, 0xcf, 0xd3, 0x90, 0x6e, 0x7a, 0x1d, 0xaa, 0xa9, 0x89, 0x2b, 0x49, 0x4d, 0x94, 0xb0, 0xbd,
	0xcd, 0x35, 0xb1, 0xf6, 0x3d, 0xae, 0x89, 0xb6, 0x77, 0x6e, 0x8b, 0xa4, 0xa2, 0xed, 0x3b, 0x6a,
	0x26, 0x6c, 0xdf, 0xda, 0x56, 0xb3, 0x51, 0x7b, 0x47, 0x9d, 0x8d, 0xda, 0xf7, 0xd4, 0xb9, 0xb0,
	0x7d, 0x67, 0x5b, 0x9d, 0x8f, 0xda, 0x3b, 0xea, 0x42, 0xd8, 0xbe, 0x7b, 0x47, 0x85, 0xa8, 0x7d,
	0x57, 0xcd, 0x85, 0xed, 0xf7, 0xef, 0xa9, 0xf9, 0xa8, 0xfd, 0x81, 0x5a, 0x08, 0xdb, 0x1f, 0xdc,
	0x52, 0x8b, 0x6c, 0x3f, 0xa0, 0xb6, 0x6d, 0xdd, 0x55, 0x17, 0xe3, 0xce, 0xfb, 0xaa, 0x1a, 0x75,
	0x76, 0xb6, 0xd5, 0xa5, 0xa8, 0x73, 0x6b, 0x47, 0x45, 0x71, 0xe7, 0x96, 0xba, 0x1c, 0x77, 0xee,
	0xa8, 0x2b, 0x51, 0xe7, 0xee, 0x96, 0x7a, 0x21, 0xee, 0xec, 0xa8, 0xab, 0x51, 0xe7, 0xde, 0x07,
	0xea, 0xc5, 0xb0, 0xb3, 0xb3, 0x7d, 0x57, 0x5d, 0x8b, 0x3b, 0xef, 0xab, 0x97, 0xa2, 0xce, 0xed,
	0x3b, 0xea, 0xe5, 0xa8, 0x73, 0xf7, 0xb6, 0xba, 0x1e, 0x75, 0xde, 0xdf, 0x52, 0xaf, 0xc4, 0x9d,
	0x5b, 0xea, 0xd5, 0xcd, 0x2e, 0x2d, 0x9e, 0xa3, 0xff, 0xb2, 0xa0, 0x4b, 0x70, 0xa1, 0xde, 0xd4,
	0x6b, 0x55, 0xbd, 0x75, 0x7c, 0x44, 0xb3, 0x40, 0x5a, 0x94, 0x75, 0xb8, 0x98, 0x64, 0x89, 0xdf,
	0x3a, 0x8d, 0xb9, 0x12, 0xac, 0x27, 0x99, 0xcd, 0x43, 0x19, 0x90, 0xaa, 0xac, 0xfd, 0xf2, 0x6c,
	0x43, 0xf9, 0xd5, 0xd9, 0x86, 0xf2, 0x1f, 0x67, 0x1b, 0xca, 0x57, 0x5f, 0x6f, 0xcc, 0xfc, 0xea,
	0xeb, 0x8d, 0x99, 0x7f, 0xf9, 0x7a, 0x63, 0xa6, 0x33, 0xcb, 0xbe, 0x8e, 0xdc, 0xfa, 0xbf, 0x00,
	0x00, 0x00, 0xff, 0xff, 0xc5, 0x8f, 0x73, 0x09, 0xb6, 0x33, 0x00, 0x00,
}

func (m *Location) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Location) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Location) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Ext != nil {
		{
			size := m.Ext.Size()
			i -= size
			if _, err := m.Ext.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Lng != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Lng))))
		i--
		dAtA[i] = 0x11
	}
	if m.Lat != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Lat))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *Location_Wgs84) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Location_Wgs84) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Wgs84 != nil {
		{
			size, err := m.Wgs84.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *Location_Cartesian) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Location_Cartesian) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Cartesian != nil {
		{
			size, err := m.Cartesian.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *Wgs84Location) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Wgs84Location) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Wgs84Location) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AltitudeM != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AltitudeM))))
		i--
		dAtA[i] = 0x19
	}
	if m.LongitudeDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.LongitudeDeg))))
		i--
		dAtA[i] = 0x11
	}
	if m.LatitudeDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.LatitudeDeg))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *CartesianLocation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CartesianLocation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CartesianLocation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ZM != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ZM))))
		i--
		dAtA[i] = 0x19
	}
	if m.YM != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.YM))))
		i--
		dAtA[i] = 0x11
	}
	if m.XM != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.XM))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *AzElOrientation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AzElOrientation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AzElOrientation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RotationDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RotationDeg))))
		i--
		dAtA[i] = 0x19
	}
	if m.ElevationDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ElevationDeg))))
		i--
		dAtA[i] = 0x11
	}
	if m.AzimuthDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AzimuthDeg))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *YprOrientation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *YprOrientation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *YprOrientation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RollDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RollDeg))))
		i--
		dAtA[i] = 0x19
	}
	if m.PitchDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.PitchDeg))))
		i--
		dAtA[i] = 0x11
	}
	if m.YawDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.YawDeg))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *Orientation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Orientation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Orientation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Orientation != nil {
		{
			size := m.Orientation.Size()
			i -= size
			if _, err := m.Orientation.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *Orientation_Azel) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Orientation_Azel) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Azel != nil {
		{
			size, err := m.Azel.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Orientation_Ypr) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Orientation_Ypr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Ypr != nil {
		{
			size, err := m.Ypr.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *Waypoint) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Waypoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Waypoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Location != nil {
		{
			size, err := m.Location.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Time != nil {
		{
			size, err := m.Time.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Waypoints) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Waypoints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Waypoints) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Waypoint) > 0 {
		for iNdEx := len(m.Waypoint) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Waypoint[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *OrbitData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OrbitData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OrbitData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MeanMotion != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.MeanMotion))))
		i--
		dAtA[i] = 0x39
	}
	if m.AnomalyDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AnomalyDeg))))
		i--
		dAtA[i] = 0x31
	}
	if m.ArgumentDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ArgumentDeg))))
		i--
		dAtA[i] = 0x29
	}
	if m.E != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.E))))
		i--
		dAtA[i] = 0x21
	}
	if m.RaanDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RaanDeg))))
		i--
		dAtA[i] = 0x19
	}
	if m.InclinationDeg != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.InclinationDeg))))
		i--
		dAtA[i] = 0x11
	}
	if m.Epoch != nil {
		{
			size, err := m.Epoch.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Motion) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Motion) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Motion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Motion != nil {
		{
			size := m.Motion.Size()
			i -= size
			if _, err := m.Motion.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *Motion_FixedLocation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Motion_FixedLocation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FixedLocation != nil {
		{
			size, err := m.FixedLocation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Motion_Waypoints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Motion_Waypoints) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Waypoints != nil {
		{
			size, err := m.Waypoints.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *Motion_Orbit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Motion_Orbit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Orbit != nil {
		{
			size, err := m.Orbit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *Coverage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Coverage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Coverage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Tilt != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Tilt))
		i--
		dAtA[i] = 0x20
	}
	if m.Azimuth != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Azimuth))
		i--
		dAtA[i] = 0x18
	}
	if m.ArcWidth != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.ArcWidth))
		i--
		dAtA[i] = 0x10
	}
	if m.Height != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *E2Node) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *E2Node) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *E2Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ServiceModels) > 0 {
		for k := range m.ServiceModels {
			v := m.ServiceModels[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintRan(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintRan(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintRan(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *E2NodeConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *E2NodeConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *E2NodeConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Version != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Connections) > 0 {
		for iNdEx := len(m.Connections) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Connections[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Lease) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Lease) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Lease) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Expiration != nil {
		n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Expiration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration):])
		if err12 != nil {
			return 0, err12
		}
		i -= n12
		i = encodeVarintRan(dAtA, i, uint64(n12))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Interface) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Interface) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Interface) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Port != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x18
	}
	if len(m.IP) > 0 {
		i -= len(m.IP)
		copy(dAtA[i:], m.IP)
		i = encodeVarintRan(dAtA, i, uint64(len(m.IP)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *E2TInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *E2TInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *E2TInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Interfaces) > 0 {
		for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *XAppInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *XAppInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *XAppInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.A1PolicyTypes) > 0 {
		for iNdEx := len(m.A1PolicyTypes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.A1PolicyTypes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Interfaces) > 0 {
		for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *A1PolicyType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *A1PolicyType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *A1PolicyType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *A1TInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *A1TInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *A1TInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Interfaces) > 0 {
		for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *CellGlobalID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CellGlobalID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CellGlobalID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NeighborCellID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NeighborCellID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NeighborCellID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PlmnID) > 0 {
		i -= len(m.PlmnID)
		copy(dAtA[i:], m.PlmnID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.PlmnID)))
		i--
		dAtA[i] = 0x12
	}
	if m.CellGlobalID != nil {
		{
			size, err := m.CellGlobalID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *E2Cell) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *E2Cell) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *E2Cell) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NeighborInformationNrs) > 0 {
		for iNdEx := len(m.NeighborInformationNrs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NeighborInformationNrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if m.ConnectivitySupport != nil {
		{
			size, err := m.ConnectivitySupport.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if m.AmfRegionInformation != nil {
		{
			size, err := m.AmfRegionInformation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if m.TaiSupportList != nil {
		{
			size, err := m.TaiSupportList.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if m.GlobalNgRanNodeId != nil {
		{
			size, err := m.GlobalNgRanNodeId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if m.MeasurementTimingConfiguration != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.MeasurementTimingConfiguration))
		i--
		dAtA[i] = 0x78
	}
	if m.NrModeInfo != nil {
		{
			size := m.NrModeInfo.Size()
			i -= size
			if _, err := m.NrModeInfo.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.ServedPlmns) > 0 {
		dAtA19 := make([]byte, len(m.ServedPlmns)*10)
		var j18 int
		for _, num := range m.ServedPlmns {
			for num >= 1<<7 {
				dAtA19[j18] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j18++
			}
			dAtA19[j18] = uint8(num)
			j18++
		}
		i -= j18
		copy(dAtA[i:], dAtA19[:j18])
		i = encodeVarintRan(dAtA, i, uint64(j18))
		i--
		dAtA[i] = 0x62
	}
	if m.PlmnId != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PlmnId))
		i--
		dAtA[i] = 0x58
	}
	if m.LatestRrcVersion != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.LatestRrcVersion))
		i--
		dAtA[i] = 0x50
	}
	if m.GnbDuId != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.GnbDuId))
		i--
		dAtA[i] = 0x48
	}
	if len(m.NeighborCellIDs) > 0 {
		for iNdEx := len(m.NeighborCellIDs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NeighborCellIDs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.KpiReports) > 0 {
		for k := range m.KpiReports {
			v := m.KpiReports[k]
			baseI := i
			i = encodeVarintRan(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintRan(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintRan(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.PCI != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PCI))
		i--
		dAtA[i] = 0x30
	}
	if len(m.CellType) > 0 {
		i -= len(m.CellType)
		copy(dAtA[i:], m.CellType)
		i = encodeVarintRan(dAtA, i, uint64(len(m.CellType)))
		i--
		dAtA[i] = 0x2a
	}
	if m.ARFCN != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.ARFCN))
		i--
		dAtA[i] = 0x20
	}
	if m.AntennaCount != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.AntennaCount))
		i--
		dAtA[i] = 0x18
	}
	if m.CellGlobalID != nil {
		{
			size, err := m.CellGlobalID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.CellObjectID) > 0 {
		i -= len(m.CellObjectID)
		copy(dAtA[i:], m.CellObjectID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.CellObjectID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *E2Cell_FddInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *E2Cell_FddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FddInfo != nil {
		{
			size, err := m.FddInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	return len(dAtA) - i, nil
}
func (m *E2Cell_TddInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *E2Cell_TddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.TddInfo != nil {
		{
			size, err := m.TddInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	return len(dAtA) - i, nil
}
func (m *ConnectivitySupport) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConnectivitySupport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConnectivitySupport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EnDcSupport != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.EnDcSupport))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FDDInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FDDInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FDDInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DlTransmissionBandwidth != nil {
		{
			size, err := m.DlTransmissionBandwidth.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.UlTransmissionBandwidth != nil {
		{
			size, err := m.UlTransmissionBandwidth.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.DlFreqInfo != nil {
		{
			size, err := m.DlFreqInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.UlFreqInfo != nil {
		{
			size, err := m.UlFreqInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TDDInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TDDInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TDDInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TransmissionBandwidth != nil {
		{
			size, err := m.TransmissionBandwidth.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.NrFreqInfo != nil {
		{
			size, err := m.NrFreqInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FrequencyInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FrequencyInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FrequencyInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FrequencyBandList != nil {
		{
			size, err := m.FrequencyBandList.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.NrArfcn != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.NrArfcn))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TransmissionBandwidth) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TransmissionBandwidth) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransmissionBandwidth) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Nrb != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Nrb))
		i--
		dAtA[i] = 0x10
	}
	if m.NrScs != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.NrScs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FrequencyBandList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FrequencyBandList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FrequencyBandList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FrequencyBandItems) > 0 {
		for iNdEx := len(m.FrequencyBandItems) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FrequencyBandItems[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *FrequencyBandItem) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FrequencyBandItem) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FrequencyBandItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NrFrequencyBand != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.NrFrequencyBand))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GlobalNgRanNodeID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GlobalNgRanNodeID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalNgRanNodeID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GlobalNgRanNodeId != nil {
		{
			size := m.GlobalNgRanNodeId.Size()
			i -= size
			if _, err := m.GlobalNgRanNodeId.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *GlobalNgRanNodeID_GlobalGnbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalNgRanNodeID_GlobalGnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.GlobalGnbId != nil {
		{
			size, err := m.GlobalGnbId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *GlobalNgRanNodeID_GlobalNgEnbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalNgRanNodeID_GlobalNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.GlobalNgEnbId != nil {
		{
			size, err := m.GlobalNgEnbId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *GlobalGnbID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GlobalGnbID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalGnbID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GnbIdLen != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.GnbIdLen))
		i--
		dAtA[i] = 0x18
	}
	if m.GnbId != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.GnbId))
		i--
		dAtA[i] = 0x10
	}
	if m.PlmnId != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PlmnId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GlobalNgEnbID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GlobalNgEnbID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalNgEnbID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NgEnbId != nil {
		{
			size := m.NgEnbId.Size()
			i -= size
			if _, err := m.NgEnbId.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.PlmnId != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PlmnId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GlobalNgEnbID_MacroNgEnbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalNgEnbID_MacroNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintRan(dAtA, i, uint64(m.MacroNgEnbId))
	i--
	dAtA[i] = 0x10
	return len(dAtA) - i, nil
}
func (m *GlobalNgEnbID_ShortMacroNgEnbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalNgEnbID_ShortMacroNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintRan(dAtA, i, uint64(m.ShortMacroNgEnbId))
	i--
	dAtA[i] = 0x18
	return len(dAtA) - i, nil
}
func (m *GlobalNgEnbID_LongMacroNgEnbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalNgEnbID_LongMacroNgEnbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintRan(dAtA, i, uint64(m.LongMacroNgEnbId))
	i--
	dAtA[i] = 0x20
	return len(dAtA) - i, nil
}
func (m *TaiSupportList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TaiSupportList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TaiSupportList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TaiSupportItems) > 0 {
		for iNdEx := len(m.TaiSupportItems) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TaiSupportItems[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *TaiSupportItem) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TaiSupportItem) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TaiSupportItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BroadcastPlmns) > 0 {
		for iNdEx := len(m.BroadcastPlmns) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BroadcastPlmns[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Tac != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Tac))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *XnBroadcastPlmn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *XnBroadcastPlmn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *XnBroadcastPlmn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TaiSliceSupportList != nil {
		{
			size, err := m.TaiSliceSupportList.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.PlmnId != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PlmnId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TaiSliceSupportList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TaiSliceSupportList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TaiSliceSupportList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SliceSupportItems) > 0 {
		for iNdEx := len(m.SliceSupportItems) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SliceSupportItems[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *SliceSupportItem) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SliceSupportItem) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SliceSupportItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SNssai != nil {
		{
			size, err := m.SNssai.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SNssai) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SNssai) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SNssai) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sd != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Sd))
		i--
		dAtA[i] = 0x10
	}
	if m.Sst != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Sst))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AmfRegionInformation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AmfRegionInformation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AmfRegionInformation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.GlobalAmfRegionInformationItems) > 0 {
		for iNdEx := len(m.GlobalAmfRegionInformationItems) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.GlobalAmfRegionInformationItems[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GlobalAmfRegionInformationItem) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GlobalAmfRegionInformationItem) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobalAmfRegionInformationItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AmfRegionId != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.AmfRegionId))
		i--
		dAtA[i] = 0x10
	}
	if m.PlmnId != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PlmnId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *NeighborInformationNr) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NeighborInformationNr) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NeighborInformationNr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MeasurementTimingConfiguration != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.MeasurementTimingConfiguration))
		i--
		dAtA[i] = 0x38
	}
	if m.ConnectivitySupport != nil {
		{
			size, err := m.ConnectivitySupport.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.NrModeInfo != nil {
		{
			size := m.NrModeInfo.Size()
			i -= size
			if _, err := m.NrModeInfo.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Tac != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Tac))
		i--
		dAtA[i] = 0x18
	}
	if m.NrCgi != nil {
		{
			size, err := m.NrCgi.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Pci != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Pci))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *NeighborInformationNr_FddInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NeighborInformationNr_FddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FddInfo != nil {
		{
			size, err := m.FddInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *NeighborInformationNr_TddInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NeighborInformationNr_TddInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.TddInfo != nil {
		{
			size, err := m.TddInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *ServiceModelInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceModelInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceModelInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RanFunctionIDs) > 0 {
		dAtA39 := make([]byte, len(m.RanFunctionIDs)*10)
		var j38 int
		for _, num := range m.RanFunctionIDs {
			for num >= 1<<7 {
				dAtA39[j38] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j38++
			}
			dAtA39[j38] = uint8(num)
			j38++
		}
		i -= j38
		copy(dAtA[i:], dAtA39[:j38])
		i = encodeVarintRan(dAtA, i, uint64(j38))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RanFunctions) > 0 {
		for iNdEx := len(m.RanFunctions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RanFunctions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.OID) > 0 {
		i -= len(m.OID)
		copy(dAtA[i:], m.OID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.OID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RCRanFunction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RCRanFunction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RCRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ControlStyles) > 0 {
		for iNdEx := len(m.ControlStyles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ControlStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.PolicyStyles) > 0 {
		for iNdEx := len(m.PolicyStyles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PolicyStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.EventTriggerStyles) > 0 {
		for iNdEx := len(m.EventTriggerStyles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EventTriggerStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.InsertStyles) > 0 {
		for iNdEx := len(m.InsertStyles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InsertStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.ReportStyles) > 0 {
		for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MHORanFunction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MHORanFunction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MHORanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ReportStyles) > 0 {
		for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *KPMRanFunction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KPMRanFunction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KPMRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ReportStyles) > 0 {
		for iNdEx := len(m.ReportStyles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ReportStyles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RSMRanFunction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RSMRanFunction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RSMRanFunction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RicSlicingNodeCapabilityList) > 0 {
		for iNdEx := len(m.RicSlicingNodeCapabilityList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RicSlicingNodeCapabilityList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RCEventTriggerStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RCEventTriggerStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RCEventTriggerStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FormatType != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.FormatType))
		i--
		dAtA[i] = 0x18
	}
	if m.Type != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RCReportStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RCReportStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RCReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RanParameters) > 0 {
		for iNdEx := len(m.RanParameters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Type != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RCInsertStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RCInsertStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RCInsertStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.InsertIndications) > 0 {
		for iNdEx := len(m.InsertIndications) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InsertIndications[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Type != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RCPolicyStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RCPolicyStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RCPolicyStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PolicyActions) > 0 {
		for iNdEx := len(m.PolicyActions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PolicyActions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Type != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PolicyAction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PolicyAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PolicyAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PolicyConditionRanParameters) > 0 {
		for iNdEx := len(m.PolicyConditionRanParameters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PolicyConditionRanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.PolicyActionRanParameters) > 0 {
		for iNdEx := len(m.PolicyActionRanParameters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PolicyActionRanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.ID != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RCControlStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RCControlStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RCControlStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ControlActions) > 0 {
		for iNdEx := len(m.ControlActions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ControlActions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.ControlOutcomeFormatType != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.ControlOutcomeFormatType))
		i--
		dAtA[i] = 0x28
	}
	if m.MessageFormatType != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.MessageFormatType))
		i--
		dAtA[i] = 0x20
	}
	if m.HeaderFormatType != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.HeaderFormatType))
		i--
		dAtA[i] = 0x18
	}
	if m.Type != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ControlAction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ControlAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ControlAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RanParameters) > 0 {
		for iNdEx := len(m.RanParameters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.ID != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *InsertIndication) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InsertIndication) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InsertIndication) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RanParameters) > 0 {
		for iNdEx := len(m.RanParameters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RanParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.ID != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RANParameter) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RANParameter) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RANParameter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.ID != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *KPMReportStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KPMReportStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KPMReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Measurements) > 0 {
		for iNdEx := len(m.Measurements) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Measurements[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Type != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MHOReportStyle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MHOReportStyle) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MHOReportStyle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *KPMMeasurement) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KPMMeasurement) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KPMMeasurement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RSMNodeSlicingCapabilityItem) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RSMNodeSlicingCapabilityItem) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RSMNodeSlicingCapabilityItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SupportedConfig) > 0 {
		for iNdEx := len(m.SupportedConfig) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SupportedConfig[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.MaxNumberOfUesPerSlice != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.MaxNumberOfUesPerSlice))
		i--
		dAtA[i] = 0x20
	}
	if m.SlicingType != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.SlicingType))
		i--
		dAtA[i] = 0x18
	}
	if m.MaxNumberOfSlicesUl != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.MaxNumberOfSlicesUl))
		i--
		dAtA[i] = 0x10
	}
	if m.MaxNumberOfSlicesDl != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.MaxNumberOfSlicesDl))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RSMSupportedSlicingConfigItem) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RSMSupportedSlicingConfigItem) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RSMSupportedSlicingConfigItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SlicingConfigType != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.SlicingConfigType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RSMSliceItemList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RSMSliceItemList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RSMSliceItemList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RsmSliceList) > 0 {
		for iNdEx := len(m.RsmSliceList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RsmSliceList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RSMSlicingItem) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RSMSlicingItem) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RSMSlicingItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UeIdList) > 0 {
		for iNdEx := len(m.UeIdList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UeIdList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.SliceType != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.SliceType))
		i--
		dAtA[i] = 0x20
	}
	if m.SliceParameters != nil {
		{
			size, err := m.SliceParameters.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SliceDesc) > 0 {
		i -= len(m.SliceDesc)
		copy(dAtA[i:], m.SliceDesc)
		i = encodeVarintRan(dAtA, i, uint64(len(m.SliceDesc)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintRan(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RSMSliceParameters) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RSMSliceParameters) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RSMSliceParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.QosLevel != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.QosLevel))
		i--
		dAtA[i] = 0x18
	}
	if m.Weight != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Weight))
		i--
		dAtA[i] = 0x10
	}
	if m.SchedulerType != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.SchedulerType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DuUeF1ApID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DuUeF1ApID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DuUeF1ApID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CuUeF1ApID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CuUeF1ApID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CuUeF1ApID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RanUeNgapID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RanUeNgapID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RanUeNgapID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EnbUeS1ApID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EnbUeS1ApID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EnbUeS1ApID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AmfUeNgapID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AmfUeNgapID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AmfUeNgapID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *UeIdentity) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UeIdentity) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UeIdentity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DrbId != nil {
		{
			size, err := m.DrbId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.PreferredIDType != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PreferredIDType))
		i--
		dAtA[i] = 0x30
	}
	if m.AMFUeNgapID != nil {
		{
			size, err := m.AMFUeNgapID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.EnbUeS1apID != nil {
		{
			size, err := m.EnbUeS1apID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.RANUeNgapID != nil {
		{
			size, err := m.RANUeNgapID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.CuUeF1apID != nil {
		{
			size, err := m.CuUeF1apID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.DuUeF1apID != nil {
		{
			size, err := m.DuUeF1apID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DrbId) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DrbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DrbId != nil {
		{
			size := m.DrbId.Size()
			i -= size
			if _, err := m.DrbId.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *DrbId_FourGdrbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DrbId_FourGdrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FourGdrbId != nil {
		{
			size, err := m.FourGdrbId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *DrbId_FiveGdrbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DrbId_FiveGdrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FiveGdrbId != nil {
		{
			size, err := m.FiveGdrbId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *FiveGDrbId) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FiveGDrbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FiveGDrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FlowsMapToDrb) > 0 {
		for iNdEx := len(m.FlowsMapToDrb) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FlowsMapToDrb[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Qfi != nil {
		{
			size, err := m.Qfi.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Qfi) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Qfi) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Qfi) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QoSflowLevelParameters) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QoSflowLevelParameters) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QoSflowLevelParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.QosFlowLevelParameters != nil {
		{
			size := m.QosFlowLevelParameters.Size()
			i -= size
			if _, err := m.QosFlowLevelParameters.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *QoSflowLevelParameters_DynamicFiveQi) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QoSflowLevelParameters_DynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DynamicFiveQi != nil {
		{
			size, err := m.DynamicFiveQi.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *QoSflowLevelParameters_NonDynamicFiveQi) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QoSflowLevelParameters_NonDynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NonDynamicFiveQi != nil {
		{
			size, err := m.NonDynamicFiveQi.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *DynamicFiveQi) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DynamicFiveQi) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PacketErrorRate != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PacketErrorRate))
		i--
		dAtA[i] = 0x18
	}
	if m.PacketDelayBudge != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PacketDelayBudge))
		i--
		dAtA[i] = 0x10
	}
	if m.PriorityLevel != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.PriorityLevel))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *NonDynamicFiveQi) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NonDynamicFiveQi) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NonDynamicFiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FiveQi != nil {
		{
			size, err := m.FiveQi.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FiveQi) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FiveQi) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FiveQi) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FourGDrbId) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FourGDrbId) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FourGDrbId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Qci != nil {
		{
			size, err := m.Qci.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Qci) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Qci) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Qci) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != 0 {
		i = encodeVarintRan(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintRan(dAtA []byte, offset int, v uint64) int {
	offset -= sovRan(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Location) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Lat != 0 {
		n += 9
	}
	if m.Lng != 0 {
		n += 9
	}
	if m.Ext != nil {
		n += m.Ext.Size()
	}
	return n
}

func (m *Location_Wgs84) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Wgs84 != nil {
		l = m.Wgs84.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *Location_Cartesian) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cartesian != nil {
		l = m.Cartesian.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *Wgs84Location) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LatitudeDeg != 0 {
		n += 9
	}
	if m.LongitudeDeg != 0 {
		n += 9
	}
	if m.AltitudeM != 0 {
		n += 9
	}
	return n
}

func (m *CartesianLocation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XM != 0 {
		n += 9
	}
	if m.YM != 0 {
		n += 9
	}
	if m.ZM != 0 {
		n += 9
	}
	return n
}

func (m *AzElOrientation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AzimuthDeg != 0 {
		n += 9
	}
	if m.ElevationDeg != 0 {
		n += 9
	}
	if m.RotationDeg != 0 {
		n += 9
	}
	return n
}

func (m *YprOrientation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.YawDeg != 0 {
		n += 9
	}
	if m.PitchDeg != 0 {
		n += 9
	}
	if m.RollDeg != 0 {
		n += 9
	}
	return n
}

func (m *Orientation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Orientation != nil {
		n += m.Orientation.Size()
	}
	return n
}

func (m *Orientation_Azel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Azel != nil {
		l = m.Azel.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *Orientation_Ypr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ypr != nil {
		l = m.Ypr.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *Waypoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Time != nil {
		l = m.Time.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Location != nil {
		l = m.Location.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *Waypoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Waypoint) > 0 {
		for _, e := range m.Waypoint {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *OrbitData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Epoch != nil {
		l = m.Epoch.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.InclinationDeg != 0 {
		n += 9
	}
	if m.RaanDeg != 0 {
		n += 9
	}
	if m.E != 0 {
		n += 9
	}
	if m.ArgumentDeg != 0 {
		n += 9
	}
	if m.AnomalyDeg != 0 {
		n += 9
	}
	if m.MeanMotion != 0 {
		n += 9
	}
	return n
}

func (m *Motion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Motion != nil {
		n += m.Motion.Size()
	}
	return n
}

func (m *Motion_FixedLocation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FixedLocation != nil {
		l = m.FixedLocation.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *Motion_Waypoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Waypoints != nil {
		l = m.Waypoints.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *Motion_Orbit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Orbit != nil {
		l = m.Orbit.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *Coverage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovRan(uint64(m.Height))
	}
	if m.ArcWidth != 0 {
		n += 1 + sovRan(uint64(m.ArcWidth))
	}
	if m.Azimuth != 0 {
		n += 1 + sovRan(uint64(m.Azimuth))
	}
	if m.Tilt != 0 {
		n += 1 + sovRan(uint64(m.Tilt))
	}
	return n
}

func (m *E2Node) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ServiceModels) > 0 {
		for k, v := range m.ServiceModels {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovRan(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovRan(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovRan(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *E2NodeConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Connections) > 0 {
		for _, e := range m.Connections {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	if m.Version != 0 {
		n += 1 + sovRan(uint64(m.Version))
	}
	return n
}

func (m *Lease) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Expiration != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration)
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *Interface) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovRan(uint64(m.Type))
	}
	l = len(m.IP)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Port != 0 {
		n += 1 + sovRan(uint64(m.Port))
	}
	return n
}

func (m *E2TInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Interfaces) > 0 {
		for _, e := range m.Interfaces {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *XAppInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Interfaces) > 0 {
		for _, e := range m.Interfaces {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	if len(m.A1PolicyTypes) > 0 {
		for _, e := range m.A1PolicyTypes {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *A1PolicyType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *A1TInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Interfaces) > 0 {
		for _, e := range m.Interfaces {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *CellGlobalID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovRan(uint64(m.Type))
	}
	return n
}

func (m *NeighborCellID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CellGlobalID != nil {
		l = m.CellGlobalID.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	l = len(m.PlmnID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *E2Cell) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.CellObjectID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.CellGlobalID != nil {
		l = m.CellGlobalID.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.AntennaCount != 0 {
		n += 1 + sovRan(uint64(m.AntennaCount))
	}
	if m.ARFCN != 0 {
		n += 1 + sovRan(uint64(m.ARFCN))
	}
	l = len(m.CellType)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.PCI != 0 {
		n += 1 + sovRan(uint64(m.PCI))
	}
	if len(m.KpiReports) > 0 {
		for k, v := range m.KpiReports {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovRan(uint64(len(k))) + 1 + sovRan(uint64(v))
			n += mapEntrySize + 1 + sovRan(uint64(mapEntrySize))
		}
	}
	if len(m.NeighborCellIDs) > 0 {
		for _, e := range m.NeighborCellIDs {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	if m.GnbDuId != 0 {
		n += 1 + sovRan(uint64(m.GnbDuId))
	}
	if m.LatestRrcVersion != 0 {
		n += 1 + sovRan(uint64(m.LatestRrcVersion))
	}
	if m.PlmnId != 0 {
		n += 1 + sovRan(uint64(m.PlmnId))
	}
	if len(m.ServedPlmns) > 0 {
		l = 0
		for _, e := range m.ServedPlmns {
			l += sovRan(uint64(e))
		}
		n += 1 + sovRan(uint64(l)) + l
	}
	if m.NrModeInfo != nil {
		n += m.NrModeInfo.Size()
	}
	if m.MeasurementTimingConfiguration != 0 {
		n += 1 + sovRan(uint64(m.MeasurementTimingConfiguration))
	}
	if m.GlobalNgRanNodeId != nil {
		l = m.GlobalNgRanNodeId.Size()
		n += 2 + l + sovRan(uint64(l))
	}
	if m.TaiSupportList != nil {
		l = m.TaiSupportList.Size()
		n += 2 + l + sovRan(uint64(l))
	}
	if m.AmfRegionInformation != nil {
		l = m.AmfRegionInformation.Size()
		n += 2 + l + sovRan(uint64(l))
	}
	if m.ConnectivitySupport != nil {
		l = m.ConnectivitySupport.Size()
		n += 2 + l + sovRan(uint64(l))
	}
	if len(m.NeighborInformationNrs) > 0 {
		for _, e := range m.NeighborInformationNrs {
			l = e.Size()
			n += 2 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *E2Cell_FddInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FddInfo != nil {
		l = m.FddInfo.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *E2Cell_TddInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TddInfo != nil {
		l = m.TddInfo.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *ConnectivitySupport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EnDcSupport != 0 {
		n += 1 + sovRan(uint64(m.EnDcSupport))
	}
	return n
}

func (m *FDDInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UlFreqInfo != nil {
		l = m.UlFreqInfo.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.DlFreqInfo != nil {
		l = m.DlFreqInfo.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.UlTransmissionBandwidth != nil {
		l = m.UlTransmissionBandwidth.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.DlTransmissionBandwidth != nil {
		l = m.DlTransmissionBandwidth.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *TDDInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NrFreqInfo != nil {
		l = m.NrFreqInfo.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.TransmissionBandwidth != nil {
		l = m.TransmissionBandwidth.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *FrequencyInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NrArfcn != 0 {
		n += 1 + sovRan(uint64(m.NrArfcn))
	}
	if m.FrequencyBandList != nil {
		l = m.FrequencyBandList.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *TransmissionBandwidth) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NrScs != 0 {
		n += 1 + sovRan(uint64(m.NrScs))
	}
	if m.Nrb != 0 {
		n += 1 + sovRan(uint64(m.Nrb))
	}
	return n
}

func (m *FrequencyBandList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.FrequencyBandItems) > 0 {
		for _, e := range m.FrequencyBandItems {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *FrequencyBandItem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NrFrequencyBand != 0 {
		n += 1 + sovRan(uint64(m.NrFrequencyBand))
	}
	return n
}

func (m *GlobalNgRanNodeID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GlobalNgRanNodeId != nil {
		n += m.GlobalNgRanNodeId.Size()
	}
	return n
}

func (m *GlobalNgRanNodeID_GlobalGnbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GlobalGnbId != nil {
		l = m.GlobalGnbId.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *GlobalNgRanNodeID_GlobalNgEnbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GlobalNgEnbId != nil {
		l = m.GlobalNgEnbId.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *GlobalGnbID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PlmnId != 0 {
		n += 1 + sovRan(uint64(m.PlmnId))
	}
	if m.GnbId != 0 {
		n += 1 + sovRan(uint64(m.GnbId))
	}
	if m.GnbIdLen != 0 {
		n += 1 + sovRan(uint64(m.GnbIdLen))
	}
	return n
}

func (m *GlobalNgEnbID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PlmnId != 0 {
		n += 1 + sovRan(uint64(m.PlmnId))
	}
	if m.NgEnbId != nil {
		n += m.NgEnbId.Size()
	}
	return n
}

func (m *GlobalNgEnbID_MacroNgEnbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRan(uint64(m.MacroNgEnbId))
	return n
}
func (m *GlobalNgEnbID_ShortMacroNgEnbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRan(uint64(m.ShortMacroNgEnbId))
	return n
}
func (m *GlobalNgEnbID_LongMacroNgEnbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRan(uint64(m.LongMacroNgEnbId))
	return n
}
func (m *TaiSupportList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.TaiSupportItems) > 0 {
		for _, e := range m.TaiSupportItems {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *TaiSupportItem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tac != 0 {
		n += 1 + sovRan(uint64(m.Tac))
	}
	if len(m.BroadcastPlmns) > 0 {
		for _, e := range m.BroadcastPlmns {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *XnBroadcastPlmn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PlmnId != 0 {
		n += 1 + sovRan(uint64(m.PlmnId))
	}
	if m.TaiSliceSupportList != nil {
		l = m.TaiSliceSupportList.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *TaiSliceSupportList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SliceSupportItems) > 0 {
		for _, e := range m.SliceSupportItems {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *SliceSupportItem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SNssai != nil {
		l = m.SNssai.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *SNssai) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sst != 0 {
		n += 1 + sovRan(uint64(m.Sst))
	}
	if m.Sd != 0 {
		n += 1 + sovRan(uint64(m.Sd))
	}
	return n
}

func (m *AmfRegionInformation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.GlobalAmfRegionInformationItems) > 0 {
		for _, e := range m.GlobalAmfRegionInformationItems {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *GlobalAmfRegionInformationItem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PlmnId != 0 {
		n += 1 + sovRan(uint64(m.PlmnId))
	}
	if m.AmfRegionId != 0 {
		n += 1 + sovRan(uint64(m.AmfRegionId))
	}
	return n
}

func (m *NeighborInformationNr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pci != 0 {
		n += 1 + sovRan(uint64(m.Pci))
	}
	if m.NrCgi != nil {
		l = m.NrCgi.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Tac != 0 {
		n += 1 + sovRan(uint64(m.Tac))
	}
	if m.NrModeInfo != nil {
		n += m.NrModeInfo.Size()
	}
	if m.ConnectivitySupport != nil {
		l = m.ConnectivitySupport.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.MeasurementTimingConfiguration != 0 {
		n += 1 + sovRan(uint64(m.MeasurementTimingConfiguration))
	}
	return n
}

func (m *NeighborInformationNr_FddInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FddInfo != nil {
		l = m.FddInfo.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *NeighborInformationNr_TddInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TddInfo != nil {
		l = m.TddInfo.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *ServiceModelInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if len(m.RanFunctions) > 0 {
		for _, e := range m.RanFunctions {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	if len(m.RanFunctionIDs) > 0 {
		l = 0
		for _, e := range m.RanFunctionIDs {
			l += sovRan(uint64(e))
		}
		n += 1 + sovRan(uint64(l)) + l
	}
	return n
}

func (m *RCRanFunction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if len(m.ReportStyles) > 0 {
		for _, e := range m.ReportStyles {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	if len(m.InsertStyles) > 0 {
		for _, e := range m.InsertStyles {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	if len(m.EventTriggerStyles) > 0 {
		for _, e := range m.EventTriggerStyles {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	if len(m.PolicyStyles) > 0 {
		for _, e := range m.PolicyStyles {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	if len(m.ControlStyles) > 0 {
		for _, e := range m.ControlStyles {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *MHORanFunction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if len(m.ReportStyles) > 0 {
		for _, e := range m.ReportStyles {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *KPMRanFunction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if len(m.ReportStyles) > 0 {
		for _, e := range m.ReportStyles {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *RSMRanFunction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if len(m.RicSlicingNodeCapabilityList) > 0 {
		for _, e := range m.RicSlicingNodeCapabilityList {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *RCEventTriggerStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovRan(uint64(m.Type))
	}
	if m.FormatType != 0 {
		n += 1 + sovRan(uint64(m.FormatType))
	}
	return n
}

func (m *RCReportStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovRan(uint64(m.Type))
	}
	if len(m.RanParameters) > 0 {
		for _, e := range m.RanParameters {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *RCInsertStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovRan(uint64(m.Type))
	}
	if len(m.InsertIndications) > 0 {
		for _, e := range m.InsertIndications {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *RCPolicyStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovRan(uint64(m.Type))
	}
	if len(m.PolicyActions) > 0 {
		for _, e := range m.PolicyActions {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *PolicyAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovRan(uint64(m.ID))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if len(m.PolicyActionRanParameters) > 0 {
		for _, e := range m.PolicyActionRanParameters {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	if len(m.PolicyConditionRanParameters) > 0 {
		for _, e := range m.PolicyConditionRanParameters {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *RCControlStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovRan(uint64(m.Type))
	}
	if m.HeaderFormatType != 0 {
		n += 1 + sovRan(uint64(m.HeaderFormatType))
	}
	if m.MessageFormatType != 0 {
		n += 1 + sovRan(uint64(m.MessageFormatType))
	}
	if m.ControlOutcomeFormatType != 0 {
		n += 1 + sovRan(uint64(m.ControlOutcomeFormatType))
	}
	if len(m.ControlActions) > 0 {
		for _, e := range m.ControlActions {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *ControlAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovRan(uint64(m.ID))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if len(m.RanParameters) > 0 {
		for _, e := range m.RanParameters {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *InsertIndication) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovRan(uint64(m.ID))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if len(m.RanParameters) > 0 {
		for _, e := range m.RanParameters {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *RANParameter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovRan(uint64(m.ID))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *KPMReportStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovRan(uint64(m.Type))
	}
	if len(m.Measurements) > 0 {
		for _, e := range m.Measurements {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *MHOReportStyle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovRan(uint64(m.Type))
	}
	return n
}

func (m *KPMMeasurement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *RSMNodeSlicingCapabilityItem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MaxNumberOfSlicesDl != 0 {
		n += 1 + sovRan(uint64(m.MaxNumberOfSlicesDl))
	}
	if m.MaxNumberOfSlicesUl != 0 {
		n += 1 + sovRan(uint64(m.MaxNumberOfSlicesUl))
	}
	if m.SlicingType != 0 {
		n += 1 + sovRan(uint64(m.SlicingType))
	}
	if m.MaxNumberOfUesPerSlice != 0 {
		n += 1 + sovRan(uint64(m.MaxNumberOfUesPerSlice))
	}
	if len(m.SupportedConfig) > 0 {
		for _, e := range m.SupportedConfig {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *RSMSupportedSlicingConfigItem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlicingConfigType != 0 {
		n += 1 + sovRan(uint64(m.SlicingConfigType))
	}
	return n
}

func (m *RSMSliceItemList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.RsmSliceList) > 0 {
		for _, e := range m.RsmSliceList {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *RSMSlicingItem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	l = len(m.SliceDesc)
	if l > 0 {
		n += 1 + l + sovRan(uint64(l))
	}
	if m.SliceParameters != nil {
		l = m.SliceParameters.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.SliceType != 0 {
		n += 1 + sovRan(uint64(m.SliceType))
	}
	if len(m.UeIdList) > 0 {
		for _, e := range m.UeIdList {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *RSMSliceParameters) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SchedulerType != 0 {
		n += 1 + sovRan(uint64(m.SchedulerType))
	}
	if m.Weight != 0 {
		n += 1 + sovRan(uint64(m.Weight))
	}
	if m.QosLevel != 0 {
		n += 1 + sovRan(uint64(m.QosLevel))
	}
	return n
}

func (m *DuUeF1ApID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	return n
}

func (m *CuUeF1ApID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	return n
}

func (m *RanUeNgapID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	return n
}

func (m *EnbUeS1ApID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	return n
}

func (m *AmfUeNgapID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	return n
}

func (m *UeIdentity) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DuUeF1apID != nil {
		l = m.DuUeF1apID.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.CuUeF1apID != nil {
		l = m.CuUeF1apID.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.RANUeNgapID != nil {
		l = m.RANUeNgapID.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.EnbUeS1apID != nil {
		l = m.EnbUeS1apID.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.AMFUeNgapID != nil {
		l = m.AMFUeNgapID.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if m.PreferredIDType != 0 {
		n += 1 + sovRan(uint64(m.PreferredIDType))
	}
	if m.DrbId != nil {
		l = m.DrbId.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *DrbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DrbId != nil {
		n += m.DrbId.Size()
	}
	return n
}

func (m *DrbId_FourGdrbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FourGdrbId != nil {
		l = m.FourGdrbId.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *DrbId_FiveGdrbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FiveGdrbId != nil {
		l = m.FiveGdrbId.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *FiveGDrbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	if m.Qfi != nil {
		l = m.Qfi.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	if len(m.FlowsMapToDrb) > 0 {
		for _, e := range m.FlowsMapToDrb {
			l = e.Size()
			n += 1 + l + sovRan(uint64(l))
		}
	}
	return n
}

func (m *Qfi) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	return n
}

func (m *QoSflowLevelParameters) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.QosFlowLevelParameters != nil {
		n += m.QosFlowLevelParameters.Size()
	}
	return n
}

func (m *QoSflowLevelParameters_DynamicFiveQi) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DynamicFiveQi != nil {
		l = m.DynamicFiveQi.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *QoSflowLevelParameters_NonDynamicFiveQi) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NonDynamicFiveQi != nil {
		l = m.NonDynamicFiveQi.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}
func (m *DynamicFiveQi) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PriorityLevel != 0 {
		n += 1 + sovRan(uint64(m.PriorityLevel))
	}
	if m.PacketDelayBudge != 0 {
		n += 1 + sovRan(uint64(m.PacketDelayBudge))
	}
	if m.PacketErrorRate != 0 {
		n += 1 + sovRan(uint64(m.PacketErrorRate))
	}
	return n
}

func (m *NonDynamicFiveQi) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FiveQi != nil {
		l = m.FiveQi.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *FiveQi) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	return n
}

func (m *FourGDrbId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	if m.Qci != nil {
		l = m.Qci.Size()
		n += 1 + l + sovRan(uint64(l))
	}
	return n
}

func (m *Qci) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovRan(uint64(m.Value))
	}
	return n
}

func sovRan(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRan(x uint64) (n int) {
	return sovRan(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Location) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Location: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Location: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lat", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Lat = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lng", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Lng = float64(math.Float64frombits(v))
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Wgs84", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Wgs84Location{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Ext = &Location_Wgs84{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cartesian", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CartesianLocation{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Ext = &Location_Cartesian{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Wgs84Location) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Wgs84Location: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Wgs84Location: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatitudeDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.LatitudeDeg = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field LongitudeDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.LongitudeDeg = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field AltitudeM", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.AltitudeM = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CartesianLocation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CartesianLocation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CartesianLocation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field XM", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.XM = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field YM", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.YM = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ZM", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.ZM = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AzElOrientation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AzElOrientation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AzElOrientation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field AzimuthDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.AzimuthDeg = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ElevationDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.ElevationDeg = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RotationDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.RotationDeg = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *YprOrientation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: YprOrientation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: YprOrientation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field YawDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.YawDeg = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field PitchDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.PitchDeg = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.RollDeg = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Orientation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Orientation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Orientation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Azel", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AzElOrientation{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Orientation = &Orientation_Azel{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ypr", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &YprOrientation{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Orientation = &Orientation_Ypr{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Waypoint) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Waypoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Waypoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Time == nil {
				m.Time = &types.Timestamp{}
			}
			if err := m.Time.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Location == nil {
				m.Location = &Location{}
			}
			if err := m.Location.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Waypoints) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Waypoints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Waypoints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Waypoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Waypoint = append(m.Waypoint, &Waypoint{})
			if err := m.Waypoint[len(m.Waypoint)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OrbitData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OrbitData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OrbitData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Epoch == nil {
				m.Epoch = &types.Timestamp{}
			}
			if err := m.Epoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field InclinationDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.InclinationDeg = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RaanDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.RaanDeg = float64(math.Float64frombits(v))
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field E", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.E = float64(math.Float64frombits(v))
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArgumentDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.ArgumentDeg = float64(math.Float64frombits(v))
		case 6:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnomalyDeg", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.AnomalyDeg = float64(math.Float64frombits(v))
		case 7:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field MeanMotion", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.MeanMotion = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Motion) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Motion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Motion: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FixedLocation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Location{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Motion = &Motion_FixedLocation{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Waypoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Waypoints{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Motion = &Motion_Waypoints{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Orbit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OrbitData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Motion = &Motion_Orbit{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Coverage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Coverage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Coverage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArcWidth", wireType)
			}
			m.ArcWidth = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ArcWidth |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Azimuth", wireType)
			}
			m.Azimuth = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Azimuth |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tilt", wireType)
			}
			m.Tilt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tilt |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *E2Node) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: E2Node: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: E2Node: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceModels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ServiceModels == nil {
				m.ServiceModels = make(map[string]*ServiceModelInfo)
			}
			var mapkey string
			var mapvalue *ServiceModelInfo
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthRan
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthRan
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthRan
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthRan
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ServiceModelInfo{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipRan(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthRan
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ServiceModels[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *E2NodeConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: E2NodeConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: E2NodeConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Connections", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Connections = append(m.Connections, Interface{})
			if err := m.Connections[len(m.Connections)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Lease) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Lease: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Lease: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Expiration == nil {
				m.Expiration = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Expiration, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Interface) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Interface: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Interface: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Interface_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IP = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *E2TInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: E2TInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: E2TInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Interfaces = append(m.Interfaces, &Interface{})
			if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *XAppInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: XAppInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: XAppInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Interfaces = append(m.Interfaces, &Interface{})
			if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field A1PolicyTypes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.A1PolicyTypes = append(m.A1PolicyTypes, &A1PolicyType{})
			if err := m.A1PolicyTypes[len(m.A1PolicyTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *A1PolicyType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: A1PolicyType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: A1PolicyType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = PolicyTypeID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = PolicyTypeName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = PolicyTypeVersion(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = PolicyTypeDescription(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *A1TInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: A1TInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: A1TInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Interfaces = append(m.Interfaces, &Interface{})
			if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CellGlobalID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CellGlobalID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CellGlobalID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= CellGlobalIDType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NeighborCellID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NeighborCellID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NeighborCellID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellGlobalID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CellGlobalID == nil {
				m.CellGlobalID = &CellGlobalID{}
			}
			if err := m.CellGlobalID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlmnID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PlmnID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *E2Cell) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: E2Cell: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: E2Cell: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellObjectID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CellObjectID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellGlobalID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CellGlobalID == nil {
				m.CellGlobalID = &CellGlobalID{}
			}
			if err := m.CellGlobalID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AntennaCount", wireType)
			}
			m.AntennaCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AntennaCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ARFCN", wireType)
			}
			m.ARFCN = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ARFCN |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CellType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PCI", wireType)
			}
			m.PCI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PCI |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KpiReports", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KpiReports == nil {
				m.KpiReports = make(map[string]uint32)
			}
			var mapkey string
			var mapvalue uint32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthRan
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthRan
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipRan(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthRan
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.KpiReports[mapkey] = mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NeighborCellIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NeighborCellIDs = append(m.NeighborCellIDs, &NeighborCellID{})
			if err := m.NeighborCellIDs[len(m.NeighborCellIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GnbDuId", wireType)
			}
			m.GnbDuId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GnbDuId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestRrcVersion", wireType)
			}
			m.LatestRrcVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LatestRrcVersion |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType)
			}
			m.PlmnId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PlmnId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ServedPlmns = append(m.ServedPlmns, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthRan
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthRan
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ServedPlmns) == 0 {
					m.ServedPlmns = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ServedPlmns = append(m.ServedPlmns, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ServedPlmns", wireType)
			}
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FddInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FDDInfo{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.NrModeInfo = &E2Cell_FddInfo{v}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TddInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TDDInfo{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.NrModeInfo = &E2Cell_TddInfo{v}
			iNdEx = postIndex
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MeasurementTimingConfiguration", wireType)
			}
			m.MeasurementTimingConfiguration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MeasurementTimingConfiguration |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalNgRanNodeId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GlobalNgRanNodeId == nil {
				m.GlobalNgRanNodeId = &GlobalNgRanNodeID{}
			}
			if err := m.GlobalNgRanNodeId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaiSupportList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TaiSupportList == nil {
				m.TaiSupportList = &TaiSupportList{}
			}
			if err := m.TaiSupportList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmfRegionInformation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AmfRegionInformation == nil {
				m.AmfRegionInformation = &AmfRegionInformation{}
			}
			if err := m.AmfRegionInformation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectivitySupport", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConnectivitySupport == nil {
				m.ConnectivitySupport = &ConnectivitySupport{}
			}
			if err := m.ConnectivitySupport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NeighborInformationNrs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NeighborInformationNrs = append(m.NeighborInformationNrs, &NeighborInformationNr{})
			if err := m.NeighborInformationNrs[len(m.NeighborInformationNrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnectivitySupport) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConnectivitySupport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnectivitySupport: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnDcSupport", wireType)
			}
			m.EnDcSupport = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EnDcSupport |= EnDcSupport(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FDDInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FDDInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FDDInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UlFreqInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UlFreqInfo == nil {
				m.UlFreqInfo = &FrequencyInfo{}
			}
			if err := m.UlFreqInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DlFreqInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DlFreqInfo == nil {
				m.DlFreqInfo = &FrequencyInfo{}
			}
			if err := m.DlFreqInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UlTransmissionBandwidth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UlTransmissionBandwidth == nil {
				m.UlTransmissionBandwidth = &TransmissionBandwidth{}
			}
			if err := m.UlTransmissionBandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DlTransmissionBandwidth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DlTransmissionBandwidth == nil {
				m.DlTransmissionBandwidth = &TransmissionBandwidth{}
			}
			if err := m.DlTransmissionBandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TDDInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TDDInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TDDInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NrFreqInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NrFreqInfo == nil {
				m.NrFreqInfo = &FrequencyInfo{}
			}
			if err := m.NrFreqInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransmissionBandwidth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TransmissionBandwidth == nil {
				m.TransmissionBandwidth = &TransmissionBandwidth{}
			}
			if err := m.TransmissionBandwidth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FrequencyInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FrequencyInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FrequencyInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NrArfcn", wireType)
			}
			m.NrArfcn = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NrArfcn |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrequencyBandList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FrequencyBandList == nil {
				m.FrequencyBandList = &FrequencyBandList{}
			}
			if err := m.FrequencyBandList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TransmissionBandwidth) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TransmissionBandwidth: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransmissionBandwidth: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NrScs", wireType)
			}
			m.NrScs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NrScs |= NrScs(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nrb", wireType)
			}
			m.Nrb = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nrb |= Nrb(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FrequencyBandList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FrequencyBandList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FrequencyBandList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrequencyBandItems", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FrequencyBandItems = append(m.FrequencyBandItems, &FrequencyBandItem{})
			if err := m.FrequencyBandItems[len(m.FrequencyBandItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FrequencyBandItem) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FrequencyBandItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FrequencyBandItem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NrFrequencyBand", wireType)
			}
			m.NrFrequencyBand = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NrFrequencyBand |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalNgRanNodeID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GlobalNgRanNodeID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalNgRanNodeID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalGnbId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &GlobalGnbID{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.GlobalNgRanNodeId = &GlobalNgRanNodeID_GlobalGnbId{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalNgEnbId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &GlobalNgEnbID{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.GlobalNgRanNodeId = &GlobalNgRanNodeID_GlobalNgEnbId{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalGnbID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GlobalGnbID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalGnbID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType)
			}
			m.PlmnId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PlmnId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GnbId", wireType)
			}
			m.GnbId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GnbId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GnbIdLen", wireType)
			}
			m.GnbIdLen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GnbIdLen |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalNgEnbID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GlobalNgEnbID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalNgEnbID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType)
			}
			m.PlmnId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PlmnId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MacroNgEnbId", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NgEnbId = &GlobalNgEnbID_MacroNgEnbId{v}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShortMacroNgEnbId", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NgEnbId = &GlobalNgEnbID_ShortMacroNgEnbId{v}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LongMacroNgEnbId", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NgEnbId = &GlobalNgEnbID_LongMacroNgEnbId{v}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TaiSupportList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TaiSupportList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaiSupportList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaiSupportItems", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TaiSupportItems = append(m.TaiSupportItems, &TaiSupportItem{})
			if err := m.TaiSupportItems[len(m.TaiSupportItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TaiSupportItem) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TaiSupportItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaiSupportItem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tac", wireType)
			}
			m.Tac = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tac |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BroadcastPlmns", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BroadcastPlmns = append(m.BroadcastPlmns, &XnBroadcastPlmn{})
			if err := m.BroadcastPlmns[len(m.BroadcastPlmns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *XnBroadcastPlmn) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: XnBroadcastPlmn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: XnBroadcastPlmn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType)
			}
			m.PlmnId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PlmnId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaiSliceSupportList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TaiSliceSupportList == nil {
				m.TaiSliceSupportList = &TaiSliceSupportList{}
			}
			if err := m.TaiSliceSupportList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TaiSliceSupportList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TaiSliceSupportList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaiSliceSupportList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SliceSupportItems", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SliceSupportItems = append(m.SliceSupportItems, &SliceSupportItem{})
			if err := m.SliceSupportItems[len(m.SliceSupportItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SliceSupportItem) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SliceSupportItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SliceSupportItem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SNssai", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SNssai == nil {
				m.SNssai = &SNssai{}
			}
			if err := m.SNssai.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SNssai) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SNssai: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SNssai: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sst", wireType)
			}
			m.Sst = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sst |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sd", wireType)
			}
			m.Sd = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sd |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AmfRegionInformation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AmfRegionInformation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AmfRegionInformation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalAmfRegionInformationItems", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GlobalAmfRegionInformationItems = append(m.GlobalAmfRegionInformationItems, &GlobalAmfRegionInformationItem{})
			if err := m.GlobalAmfRegionInformationItems[len(m.GlobalAmfRegionInformationItems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalAmfRegionInformationItem) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GlobalAmfRegionInformationItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalAmfRegionInformationItem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlmnId", wireType)
			}
			m.PlmnId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PlmnId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmfRegionId", wireType)
			}
			m.AmfRegionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AmfRegionId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NeighborInformationNr) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NeighborInformationNr: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NeighborInformationNr: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pci", wireType)
			}
			m.Pci = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pci |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NrCgi", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NrCgi == nil {
				m.NrCgi = &NeighborCellID{}
			}
			if err := m.NrCgi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tac", wireType)
			}
			m.Tac = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tac |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FddInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FDDInfo{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.NrModeInfo = &NeighborInformationNr_FddInfo{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TddInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TDDInfo{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.NrModeInfo = &NeighborInformationNr_TddInfo{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectivitySupport", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConnectivitySupport == nil {
				m.ConnectivitySupport = &ConnectivitySupport{}
			}
			if err := m.ConnectivitySupport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MeasurementTimingConfiguration", wireType)
			}
			m.MeasurementTimingConfiguration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MeasurementTimingConfiguration |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceModelInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceModelInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceModelInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RanFunctions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RanFunctions = append(m.RanFunctions, &types.Any{})
			if err := m.RanFunctions[len(m.RanFunctions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RanFunctionIDs = append(m.RanFunctionIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthRan
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthRan
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RanFunctionIDs) == 0 {
					m.RanFunctionIDs = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RanFunctionIDs = append(m.RanFunctionIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RanFunctionIDs", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RCRanFunction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RCRanFunction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RCRanFunction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReportStyles = append(m.ReportStyles, &RCReportStyle{})
			if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InsertStyles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InsertStyles = append(m.InsertStyles, &RCInsertStyle{})
			if err := m.InsertStyles[len(m.InsertStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventTriggerStyles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventTriggerStyles = append(m.EventTriggerStyles, &RCEventTriggerStyle{})
			if err := m.EventTriggerStyles[len(m.EventTriggerStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PolicyStyles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PolicyStyles = append(m.PolicyStyles, &RCPolicyStyle{})
			if err := m.PolicyStyles[len(m.PolicyStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlStyles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControlStyles = append(m.ControlStyles, &RCControlStyle{})
			if err := m.ControlStyles[len(m.ControlStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MHORanFunction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MHORanFunction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MHORanFunction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReportStyles = append(m.ReportStyles, &MHOReportStyle{})
			if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KPMRanFunction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KPMRanFunction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KPMRanFunction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportStyles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReportStyles = append(m.ReportStyles, &KPMReportStyle{})
			if err := m.ReportStyles[len(m.ReportStyles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RSMRanFunction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RSMRanFunction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RSMRanFunction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RicSlicingNodeCapabilityList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RicSlicingNodeCapabilityList = append(m.RicSlicingNodeCapabilityList, &RSMNodeSlicingCapabilityItem{})
			if err := m.RicSlicingNodeCapabilityList[len(m.RicSlicingNodeCapabilityList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RCEventTriggerStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RCEventTriggerStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RCEventTriggerStyle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FormatType", wireType)
			}
			m.FormatType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FormatType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RCReportStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RCReportStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RCReportStyle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RanParameters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RanParameters = append(m.RanParameters, &RANParameter{})
			if err := m.RanParameters[len(m.RanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RCInsertStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RCInsertStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RCInsertStyle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InsertIndications", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InsertIndications = append(m.InsertIndications, &InsertIndication{})
			if err := m.InsertIndications[len(m.InsertIndications)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RCPolicyStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RCPolicyStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RCPolicyStyle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PolicyActions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PolicyActions = append(m.PolicyActions, &PolicyAction{})
			if err := m.PolicyActions[len(m.PolicyActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PolicyAction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PolicyAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PolicyAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PolicyActionRanParameters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PolicyActionRanParameters = append(m.PolicyActionRanParameters, &RANParameter{})
			if err := m.PolicyActionRanParameters[len(m.PolicyActionRanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PolicyConditionRanParameters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PolicyConditionRanParameters = append(m.PolicyConditionRanParameters, &RANParameter{})
			if err := m.PolicyConditionRanParameters[len(m.PolicyConditionRanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RCControlStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RCControlStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RCControlStyle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderFormatType", wireType)
			}
			m.HeaderFormatType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HeaderFormatType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageFormatType", wireType)
			}
			m.MessageFormatType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MessageFormatType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlOutcomeFormatType", wireType)
			}
			m.ControlOutcomeFormatType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ControlOutcomeFormatType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlActions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControlActions = append(m.ControlActions, &ControlAction{})
			if err := m.ControlActions[len(m.ControlActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ControlAction) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ControlAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControlAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RanParameters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RanParameters = append(m.RanParameters, &RANParameter{})
			if err := m.RanParameters[len(m.RanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InsertIndication) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InsertIndication: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InsertIndication: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RanParameters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RanParameters = append(m.RanParameters, &RANParameter{})
			if err := m.RanParameters[len(m.RanParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RANParameter) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RANParameter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RANParameter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KPMReportStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KPMReportStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KPMReportStyle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Measurements", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Measurements = append(m.Measurements, &KPMMeasurement{})
			if err := m.Measurements[len(m.Measurements)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MHOReportStyle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MHOReportStyle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MHOReportStyle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KPMMeasurement) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KPMMeasurement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KPMMeasurement: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RSMNodeSlicingCapabilityItem) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RSMNodeSlicingCapabilityItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RSMNodeSlicingCapabilityItem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfSlicesDl", wireType)
			}
			m.MaxNumberOfSlicesDl = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxNumberOfSlicesDl |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfSlicesUl", wireType)
			}
			m.MaxNumberOfSlicesUl = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxNumberOfSlicesUl |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlicingType", wireType)
			}
			m.SlicingType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SlicingType |= RSMSlicingType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxNumberOfUesPerSlice", wireType)
			}
			m.MaxNumberOfUesPerSlice = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxNumberOfUesPerSlice |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SupportedConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SupportedConfig = append(m.SupportedConfig, &RSMSupportedSlicingConfigItem{})
			if err := m.SupportedConfig[len(m.SupportedConfig)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RSMSupportedSlicingConfigItem) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RSMSupportedSlicingConfigItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RSMSupportedSlicingConfigItem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlicingConfigType", wireType)
			}
			m.SlicingConfigType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SlicingConfigType |= E2SmRsmCommand(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RSMSliceItemList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RSMSliceItemList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RSMSliceItemList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RsmSliceList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RsmSliceList = append(m.RsmSliceList, &RSMSlicingItem{})
			if err := m.RsmSliceList[len(m.RsmSliceList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RSMSlicingItem) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RSMSlicingItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RSMSlicingItem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SliceDesc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SliceDesc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SliceParameters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SliceParameters == nil {
				m.SliceParameters = &RSMSliceParameters{}
			}
			if err := m.SliceParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SliceType", wireType)
			}
			m.SliceType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SliceType |= RSMSliceType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UeIdList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UeIdList = append(m.UeIdList, &UeIdentity{})
			if err := m.UeIdList[len(m.UeIdList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RSMSliceParameters) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RSMSliceParameters: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RSMSliceParameters: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchedulerType", wireType)
			}
			m.SchedulerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SchedulerType |= RSMSchedulerType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			m.Weight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QosLevel", wireType)
			}
			m.QosLevel = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QosLevel |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DuUeF1ApID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DuUeF1apID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DuUeF1apID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CuUeF1ApID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CuUeF1apID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CuUeF1apID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RanUeNgapID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RanUeNgapID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RanUeNgapID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnbUeS1ApID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EnbUeS1apID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnbUeS1apID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AmfUeNgapID) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AmfUeNgapID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AmfUeNgapID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UeIdentity) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UeIdentity: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UeIdentity: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DuUeF1apID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DuUeF1apID == nil {
				m.DuUeF1apID = &DuUeF1ApID{}
			}
			if err := m.DuUeF1apID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CuUeF1apID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CuUeF1apID == nil {
				m.CuUeF1apID = &CuUeF1ApID{}
			}
			if err := m.CuUeF1apID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RANUeNgapID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RANUeNgapID == nil {
				m.RANUeNgapID = &RanUeNgapID{}
			}
			if err := m.RANUeNgapID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnbUeS1apID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EnbUeS1apID == nil {
				m.EnbUeS1apID = &EnbUeS1ApID{}
			}
			if err := m.EnbUeS1apID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AMFUeNgapID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AMFUeNgapID == nil {
				m.AMFUeNgapID = &AmfUeNgapID{}
			}
			if err := m.AMFUeNgapID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreferredIDType", wireType)
			}
			m.PreferredIDType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PreferredIDType |= UeIdType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DrbId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DrbId == nil {
				m.DrbId = &DrbId{}
			}
			if err := m.DrbId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DrbId) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DrbId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DrbId: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FourGdrbId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FourGDrbId{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.DrbId = &DrbId_FourGdrbId{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FiveGdrbId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FiveGDrbId{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.DrbId = &DrbId_FiveGdrbId{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FiveGDrbId) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FiveGDrbId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FiveGDrbId: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Qfi", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Qfi == nil {
				m.Qfi = &Qfi{}
			}
			if err := m.Qfi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FlowsMapToDrb", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FlowsMapToDrb = append(m.FlowsMapToDrb, &QoSflowLevelParameters{})
			if err := m.FlowsMapToDrb[len(m.FlowsMapToDrb)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Qfi) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Qfi: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Qfi: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QoSflowLevelParameters) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QoSflowLevelParameters: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QoSflowLevelParameters: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DynamicFiveQi", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DynamicFiveQi{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.QosFlowLevelParameters = &QoSflowLevelParameters_DynamicFiveQi{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonDynamicFiveQi", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NonDynamicFiveQi{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.QosFlowLevelParameters = &QoSflowLevelParameters_NonDynamicFiveQi{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DynamicFiveQi) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DynamicFiveQi: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DynamicFiveQi: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriorityLevel", wireType)
			}
			m.PriorityLevel = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PriorityLevel |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PacketDelayBudge", wireType)
			}
			m.PacketDelayBudge = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PacketDelayBudge |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PacketErrorRate", wireType)
			}
			m.PacketErrorRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PacketErrorRate |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NonDynamicFiveQi) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NonDynamicFiveQi: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NonDynamicFiveQi: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FiveQi", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FiveQi == nil {
				m.FiveQi = &FiveQi{}
			}
			if err := m.FiveQi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FiveQi) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FiveQi: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FiveQi: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FourGDrbId) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FourGDrbId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FourGDrbId: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Qci", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Qci == nil {
				m.Qci = &Qci{}
			}
			if err := m.Qci.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Qci) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Qci: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Qci: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRan(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowRan
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowRan
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowRan
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthRan
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupRan
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthRan
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthRan        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRan          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRan = fmt.Errorf("proto: unexpected end of group")
)