github.com/onosproject/onos-api/go@v0.10.32/onos/ransim/types/types.pb.go

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

package types

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

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

// 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

type CellType int32

const (
	CellType_FEMTO         CellType = 0
	CellType_ENTERPRISE    CellType = 1
	CellType_OUTDOOR_SMALL CellType = 2
	CellType_MACRO         CellType = 3
)

var CellType_name = map[int32]string{
	0: "FEMTO",
	1: "ENTERPRISE",
	2: "OUTDOOR_SMALL",
	3: "MACRO",
}

var CellType_value = map[string]int32{
	"FEMTO":         0,
	"ENTERPRISE":    1,
	"OUTDOOR_SMALL": 2,
	"MACRO":         3,
}

func (x CellType) String() string {
	return proto.EnumName(CellType_name, int32(x))
}

func (CellType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{0}
}

type Point struct {
	Lat float64 `protobuf:"fixed64,1,opt,name=lat,proto3" json:"lat,omitempty"`
	Lng float64 `protobuf:"fixed64,2,opt,name=lng,proto3" json:"lng,omitempty"`
}

func (m *Point) Reset()         { *m = Point{} }
func (m *Point) String() string { return proto.CompactTextString(m) }
func (*Point) ProtoMessage()    {}
func (*Point) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{0}
}
func (m *Point) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Point) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Point.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 *Point) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Point.Merge(m, src)
}
func (m *Point) XXX_Size() int {
	return m.Size()
}
func (m *Point) XXX_DiscardUnknown() {
	xxx_messageInfo_Point.DiscardUnknown(m)
}

var xxx_messageInfo_Point proto.InternalMessageInfo

func (m *Point) GetLat() float64 {
	if m != nil {
		return m.Lat
	}
	return 0
}

func (m *Point) GetLng() float64 {
	if m != nil {
		return m.Lng
	}
	return 0
}

type Sector struct {
	Azimuth  int32  `protobuf:"varint,1,opt,name=azimuth,proto3" json:"azimuth,omitempty"`
	Arc      int32  `protobuf:"varint,2,opt,name=arc,proto3" json:"arc,omitempty"`
	Centroid *Point `protobuf:"bytes,3,opt,name=centroid,proto3" json:"centroid,omitempty"`
	Height   int32  `protobuf:"varint,4,opt,name=height,proto3" json:"height,omitempty"`
	Tilt     int32  `protobuf:"varint,5,opt,name=tilt,proto3" json:"tilt,omitempty"`
}

func (m *Sector) Reset()         { *m = Sector{} }
func (m *Sector) String() string { return proto.CompactTextString(m) }
func (*Sector) ProtoMessage()    {}
func (*Sector) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{1}
}
func (m *Sector) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Sector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Sector.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 *Sector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Sector.Merge(m, src)
}
func (m *Sector) XXX_Size() int {
	return m.Size()
}
func (m *Sector) XXX_DiscardUnknown() {
	xxx_messageInfo_Sector.DiscardUnknown(m)
}

var xxx_messageInfo_Sector proto.InternalMessageInfo

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

func (m *Sector) GetArc() int32 {
	if m != nil {
		return m.Arc
	}
	return 0
}

func (m *Sector) GetCentroid() *Point {
	if m != nil {
		return m.Centroid
	}
	return nil
}

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

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

type Route struct {
	RouteID    IMSI     `protobuf:"varint,1,opt,name=name,proto3,casttype=IMSI" json:"name,omitempty"`
	Waypoints  []*Point `protobuf:"bytes,2,rep,name=waypoints,proto3" json:"waypoints,omitempty"`
	Color      string   `protobuf:"bytes,3,opt,name=color,proto3" json:"color,omitempty"`
	SpeedAvg   uint32   `protobuf:"varint,4,opt,name=speed_avg,json=speedAvg,proto3" json:"speed_avg,omitempty"`
	SpeedStdev uint32   `protobuf:"varint,5,opt,name=speed_stdev,json=speedStdev,proto3" json:"speed_stdev,omitempty"`
	Reverse    bool     `protobuf:"varint,6,opt,name=reverse,proto3" json:"reverse,omitempty"`
	NextPoint  uint32   `protobuf:"varint,7,opt,name=next_point,json=nextPoint,proto3" json:"next_point,omitempty"`
}

func (m *Route) Reset()         { *m = Route{} }
func (m *Route) String() string { return proto.CompactTextString(m) }
func (*Route) ProtoMessage()    {}
func (*Route) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{2}
}
func (m *Route) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Route) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Route.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 *Route) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Route.Merge(m, src)
}
func (m *Route) XXX_Size() int {
	return m.Size()
}
func (m *Route) XXX_DiscardUnknown() {
	xxx_messageInfo_Route.DiscardUnknown(m)
}

var xxx_messageInfo_Route proto.InternalMessageInfo

func (m *Route) GetRouteID() IMSI {
	if m != nil {
		return m.RouteID
	}
	return 0
}

func (m *Route) GetWaypoints() []*Point {
	if m != nil {
		return m.Waypoints
	}
	return nil
}

func (m *Route) GetColor() string {
	if m != nil {
		return m.Color
	}
	return ""
}

func (m *Route) GetSpeedAvg() uint32 {
	if m != nil {
		return m.SpeedAvg
	}
	return 0
}

func (m *Route) GetSpeedStdev() uint32 {
	if m != nil {
		return m.SpeedStdev
	}
	return 0
}

func (m *Route) GetReverse() bool {
	if m != nil {
		return m.Reverse
	}
	return false
}

func (m *Route) GetNextPoint() uint32 {
	if m != nil {
		return m.NextPoint
	}
	return 0
}

type Ue struct {
	IMSI                 IMSI        `protobuf:"varint,1,opt,name=imsi,proto3,casttype=IMSI" json:"imsi,omitempty"`
	Type                 string      `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
	Position             *Point      `protobuf:"bytes,4,opt,name=position,proto3" json:"position,omitempty"`
	Rotation             uint32      `protobuf:"varint,5,opt,name=rotation,proto3" json:"rotation,omitempty"`
	ServingTower         NCGI        `protobuf:"varint,7,opt,name=serving_tower,json=servingTower,proto3,casttype=NCGI" json:"serving_tower,omitempty"`
	ServingTowerStrength float64     `protobuf:"fixed64,8,opt,name=serving_tower_strength,json=servingTowerStrength,proto3" json:"serving_tower_strength,omitempty"`
	Tower1               NCGI        `protobuf:"varint,9,opt,name=tower1,proto3,casttype=NCGI" json:"tower1,omitempty"`
	Tower1Strength       float64     `protobuf:"fixed64,10,opt,name=tower1_strength,json=tower1Strength,proto3" json:"tower1_strength,omitempty"`
	Tower2               NCGI        `protobuf:"varint,11,opt,name=tower2,proto3,casttype=NCGI" json:"tower2,omitempty"`
	Tower2Strength       float64     `protobuf:"fixed64,12,opt,name=tower2_strength,json=tower2Strength,proto3" json:"tower2_strength,omitempty"`
	Tower3               NCGI        `protobuf:"varint,13,opt,name=tower3,proto3,casttype=NCGI" json:"tower3,omitempty"`
	Tower3Strength       float64     `protobuf:"fixed64,14,opt,name=tower3_strength,json=tower3Strength,proto3" json:"tower3_strength,omitempty"`
	CRNTI                CRNTI       `protobuf:"varint,15,opt,name=crnti,proto3,casttype=CRNTI" json:"crnti,omitempty"`
	Admitted             bool        `protobuf:"varint,16,opt,name=admitted,proto3" json:"admitted,omitempty"`
	Metrics              *UeMetrics  `protobuf:"bytes,17,opt,name=metrics,proto3" json:"metrics,omitempty"`
	RrcState             uint32      `protobuf:"varint,18,opt,name=rrc_state,json=rrcState,proto3" json:"rrc_state,omitempty"`
	FiveQi               int32       `protobuf:"varint,19,opt,name=five_qi,json=fiveQi,proto3" json:"five_qi,omitempty"`
	Ueid                 *UeIdentity `protobuf:"bytes,20,opt,name=ueid,proto3" json:"ueid,omitempty"`
}

func (m *Ue) Reset()         { *m = Ue{} }
func (m *Ue) String() string { return proto.CompactTextString(m) }
func (*Ue) ProtoMessage()    {}
func (*Ue) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{3}
}
func (m *Ue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Ue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Ue.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 *Ue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Ue.Merge(m, src)
}
func (m *Ue) XXX_Size() int {
	return m.Size()
}
func (m *Ue) XXX_DiscardUnknown() {
	xxx_messageInfo_Ue.DiscardUnknown(m)
}

var xxx_messageInfo_Ue proto.InternalMessageInfo

func (m *Ue) GetIMSI() IMSI {
	if m != nil {
		return m.IMSI
	}
	return 0
}

func (m *Ue) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *Ue) GetPosition() *Point {
	if m != nil {
		return m.Position
	}
	return nil
}

func (m *Ue) GetRotation() uint32 {
	if m != nil {
		return m.Rotation
	}
	return 0
}

func (m *Ue) GetServingTower() NCGI {
	if m != nil {
		return m.ServingTower
	}
	return 0
}

func (m *Ue) GetServingTowerStrength() float64 {
	if m != nil {
		return m.ServingTowerStrength
	}
	return 0
}

func (m *Ue) GetTower1() NCGI {
	if m != nil {
		return m.Tower1
	}
	return 0
}

func (m *Ue) GetTower1Strength() float64 {
	if m != nil {
		return m.Tower1Strength
	}
	return 0
}

func (m *Ue) GetTower2() NCGI {
	if m != nil {
		return m.Tower2
	}
	return 0
}

func (m *Ue) GetTower2Strength() float64 {
	if m != nil {
		return m.Tower2Strength
	}
	return 0
}

func (m *Ue) GetTower3() NCGI {
	if m != nil {
		return m.Tower3
	}
	return 0
}

func (m *Ue) GetTower3Strength() float64 {
	if m != nil {
		return m.Tower3Strength
	}
	return 0
}

func (m *Ue) GetCRNTI() CRNTI {
	if m != nil {
		return m.CRNTI
	}
	return 0
}

func (m *Ue) GetAdmitted() bool {
	if m != nil {
		return m.Admitted
	}
	return false
}

func (m *Ue) GetMetrics() *UeMetrics {
	if m != nil {
		return m.Metrics
	}
	return nil
}

func (m *Ue) GetRrcState() uint32 {
	if m != nil {
		return m.RrcState
	}
	return 0
}

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

func (m *Ue) GetUeid() *UeIdentity {
	if m != nil {
		return m.Ueid
	}
	return nil
}

type UeIdentity struct {
	Guami       *Guami      `protobuf:"bytes,1,opt,name=guami,proto3" json:"guami,omitempty"`
	AmfUeNgapId AmfUENgapID `protobuf:"varint,2,opt,name=amf_ue_ngap_id,json=amfUeNgapId,proto3,casttype=AmfUENgapID" json:"amf_ue_ngap_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_4b9d0257bd7c07d7, []int{4}
}
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) GetGuami() *Guami {
	if m != nil {
		return m.Guami
	}
	return nil
}

func (m *UeIdentity) GetAmfUeNgapId() AmfUENgapID {
	if m != nil {
		return m.AmfUeNgapId
	}
	return 0
}

type Guami struct {
	Plmnid      uint32 `protobuf:"varint,1,opt,name=plmnid,proto3" json:"plmnid,omitempty"`
	AmfRegionId uint32 `protobuf:"varint,2,opt,name=amf_region_id,json=amfRegionId,proto3" json:"amf_region_id,omitempty"`
	AmfSetId    uint32 `protobuf:"varint,3,opt,name=amf_set_id,json=amfSetId,proto3" json:"amf_set_id,omitempty"`
	AmfPointer  uint32 `protobuf:"varint,4,opt,name=amf_pointer,json=amfPointer,proto3" json:"amf_pointer,omitempty"`
}

func (m *Guami) Reset()         { *m = Guami{} }
func (m *Guami) String() string { return proto.CompactTextString(m) }
func (*Guami) ProtoMessage()    {}
func (*Guami) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{5}
}
func (m *Guami) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Guami) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Guami.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 *Guami) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Guami.Merge(m, src)
}
func (m *Guami) XXX_Size() int {
	return m.Size()
}
func (m *Guami) XXX_DiscardUnknown() {
	xxx_messageInfo_Guami.DiscardUnknown(m)
}

var xxx_messageInfo_Guami proto.InternalMessageInfo

func (m *Guami) GetPlmnid() uint32 {
	if m != nil {
		return m.Plmnid
	}
	return 0
}

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

func (m *Guami) GetAmfSetId() uint32 {
	if m != nil {
		return m.AmfSetId
	}
	return 0
}

func (m *Guami) GetAmfPointer() uint32 {
	if m != nil {
		return m.AmfPointer
	}
	return 0
}

type UeMetrics struct {
	// Latency (in nanoseconds) of the most recent hand-over
	HoLatency int64 `protobuf:"varint,1,opt,name=ho_latency,json=hoLatency,proto3" json:"ho_latency,omitempty"`
	// Handover report timestamp (in nanoseconds since epoch)
	HoReportTimestamp int64 `protobuf:"varint,2,opt,name=ho_report_timestamp,json=hoReportTimestamp,proto3" json:"ho_report_timestamp,omitempty"`
	// flag to indicate the first measurement
	IsFirst bool `protobuf:"varint,3,opt,name=is_first,json=isFirst,proto3" json:"is_first,omitempty"`
}

func (m *UeMetrics) Reset()         { *m = UeMetrics{} }
func (m *UeMetrics) String() string { return proto.CompactTextString(m) }
func (*UeMetrics) ProtoMessage()    {}
func (*UeMetrics) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{6}
}
func (m *UeMetrics) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UeMetrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UeMetrics.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 *UeMetrics) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UeMetrics.Merge(m, src)
}
func (m *UeMetrics) XXX_Size() int {
	return m.Size()
}
func (m *UeMetrics) XXX_DiscardUnknown() {
	xxx_messageInfo_UeMetrics.DiscardUnknown(m)
}

var xxx_messageInfo_UeMetrics proto.InternalMessageInfo

func (m *UeMetrics) GetHoLatency() int64 {
	if m != nil {
		return m.HoLatency
	}
	return 0
}

func (m *UeMetrics) GetHoReportTimestamp() int64 {
	if m != nil {
		return m.HoReportTimestamp
	}
	return 0
}

func (m *UeMetrics) GetIsFirst() bool {
	if m != nil {
		return m.IsFirst
	}
	return false
}

type Cell struct {
	NCGI      NCGI    `protobuf:"varint,1,opt,name=ecgi,proto3,casttype=NCGI" json:"ecgi,omitempty"`
	Location  *Point  `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"`
	Sector    *Sector `protobuf:"bytes,4,opt,name=sector,proto3" json:"sector,omitempty"`
	Color     string  `protobuf:"bytes,5,opt,name=color,proto3" json:"color,omitempty"`
	MaxUEs    uint32  `protobuf:"varint,6,opt,name=max_ues,json=maxUes,proto3" json:"max_ues,omitempty"`
	Neighbors []NCGI  `protobuf:"varint,7,rep,packed,name=neighbors,proto3,casttype=NCGI" json:"neighbors,omitempty"`
	// The cell transmit power in decibels
	TxPowerdB         float64            `protobuf:"fixed64,8,opt,name=tx_power_db,json=txPowerDb,proto3" json:"tx_power_db,omitempty"`
	MeasurementParams *MeasurementParams `protobuf:"bytes,9,opt,name=measurement_params,json=measurementParams,proto3" json:"measurement_params,omitempty"`
	// crntis maps a ue's name to its crnti
	CrntiMap          map[CRNTI]IMSI `protobuf:"bytes,10,rep,name=crnti_map,json=crntiMap,proto3,castkey=CRNTI,castvalue=IMSI" json:"crnti_map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	CrntiIndex        uint32         `protobuf:"varint,11,opt,name=crnti_index,json=crntiIndex,proto3" json:"crnti_index,omitempty"`
	Port              uint32         `protobuf:"varint,12,opt,name=port,proto3" json:"port,omitempty"`
	Pci               uint32         `protobuf:"varint,13,opt,name=pci,proto3" json:"pci,omitempty"`
	Earfcn            uint32         `protobuf:"varint,14,opt,name=earfcn,proto3" json:"earfcn,omitempty"`
	CellType          CellType       `protobuf:"varint,15,opt,name=cell_type,json=cellType,proto3,enum=onos.ransim.types.CellType" json:"cell_type,omitempty"`
	RrcIdleCount      uint32         `protobuf:"varint,16,opt,name=rrc_idle_count,json=rrcIdleCount,proto3" json:"rrc_idle_count,omitempty"`
	RrcConnectedCount uint32         `protobuf:"varint,17,opt,name=rrc_connected_count,json=rrcConnectedCount,proto3" json:"rrc_connected_count,omitempty"`
}

func (m *Cell) Reset()         { *m = Cell{} }
func (m *Cell) String() string { return proto.CompactTextString(m) }
func (*Cell) ProtoMessage()    {}
func (*Cell) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{7}
}
func (m *Cell) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Cell) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Cell.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 *Cell) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Cell.Merge(m, src)
}
func (m *Cell) XXX_Size() int {
	return m.Size()
}
func (m *Cell) XXX_DiscardUnknown() {
	xxx_messageInfo_Cell.DiscardUnknown(m)
}

var xxx_messageInfo_Cell proto.InternalMessageInfo

func (m *Cell) GetNCGI() NCGI {
	if m != nil {
		return m.NCGI
	}
	return 0
}

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

func (m *Cell) GetSector() *Sector {
	if m != nil {
		return m.Sector
	}
	return nil
}

func (m *Cell) GetColor() string {
	if m != nil {
		return m.Color
	}
	return ""
}

func (m *Cell) GetMaxUEs() uint32 {
	if m != nil {
		return m.MaxUEs
	}
	return 0
}

func (m *Cell) GetNeighbors() []NCGI {
	if m != nil {
		return m.Neighbors
	}
	return nil
}

func (m *Cell) GetTxPowerdB() float64 {
	if m != nil {
		return m.TxPowerdB
	}
	return 0
}

func (m *Cell) GetMeasurementParams() *MeasurementParams {
	if m != nil {
		return m.MeasurementParams
	}
	return nil
}

func (m *Cell) GetCrntiMap() map[CRNTI]IMSI {
	if m != nil {
		return m.CrntiMap
	}
	return nil
}

func (m *Cell) GetCrntiIndex() uint32 {
	if m != nil {
		return m.CrntiIndex
	}
	return 0
}

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

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

func (m *Cell) GetEarfcn() uint32 {
	if m != nil {
		return m.Earfcn
	}
	return 0
}

func (m *Cell) GetCellType() CellType {
	if m != nil {
		return m.CellType
	}
	return CellType_FEMTO
}

func (m *Cell) GetRrcIdleCount() uint32 {
	if m != nil {
		return m.RrcIdleCount
	}
	return 0
}

func (m *Cell) GetRrcConnectedCount() uint32 {
	if m != nil {
		return m.RrcConnectedCount
	}
	return 0
}

type MeasurementParams struct {
	TimeToTrigger          int32          `protobuf:"varint,1,opt,name=time_to_trigger,json=timeToTrigger,proto3" json:"time_to_trigger,omitempty"`
	FrequencyOffset        int32          `protobuf:"varint,2,opt,name=frequency_offset,json=frequencyOffset,proto3" json:"frequency_offset,omitempty"`
	PcellIndividualOffset  int32          `protobuf:"varint,3,opt,name=pcell_individual_offset,json=pcellIndividualOffset,proto3" json:"pcell_individual_offset,omitempty"`
	NcellIndividualOffsets map[NCGI]int32 `protobuf:"bytes,4,rep,name=ncell_individual_offsets,json=ncellIndividualOffsets,proto3,castkey=NCGI" json:"ncell_individual_offsets,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Hysteresis             int32          `protobuf:"varint,5,opt,name=hysteresis,proto3" json:"hysteresis,omitempty"`
	EventA3Params          *EventA3Params `protobuf:"bytes,6,opt,name=event_a3_params,json=eventA3Params,proto3" json:"event_a3_params,omitempty"`
}

func (m *MeasurementParams) Reset()         { *m = MeasurementParams{} }
func (m *MeasurementParams) String() string { return proto.CompactTextString(m) }
func (*MeasurementParams) ProtoMessage()    {}
func (*MeasurementParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{8}
}
func (m *MeasurementParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MeasurementParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MeasurementParams.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 *MeasurementParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeasurementParams.Merge(m, src)
}
func (m *MeasurementParams) XXX_Size() int {
	return m.Size()
}
func (m *MeasurementParams) XXX_DiscardUnknown() {
	xxx_messageInfo_MeasurementParams.DiscardUnknown(m)
}

var xxx_messageInfo_MeasurementParams proto.InternalMessageInfo

func (m *MeasurementParams) GetTimeToTrigger() int32 {
	if m != nil {
		return m.TimeToTrigger
	}
	return 0
}

func (m *MeasurementParams) GetFrequencyOffset() int32 {
	if m != nil {
		return m.FrequencyOffset
	}
	return 0
}

func (m *MeasurementParams) GetPcellIndividualOffset() int32 {
	if m != nil {
		return m.PcellIndividualOffset
	}
	return 0
}

func (m *MeasurementParams) GetNcellIndividualOffsets() map[NCGI]int32 {
	if m != nil {
		return m.NcellIndividualOffsets
	}
	return nil
}

func (m *MeasurementParams) GetHysteresis() int32 {
	if m != nil {
		return m.Hysteresis
	}
	return 0
}

func (m *MeasurementParams) GetEventA3Params() *EventA3Params {
	if m != nil {
		return m.EventA3Params
	}
	return nil
}

type EventA3Params struct {
	A3Offset      int32 `protobuf:"varint,1,opt,name=a3_offset,json=a3Offset,proto3" json:"a3_offset,omitempty"`
	ReportOnLeave bool  `protobuf:"varint,2,opt,name=report_on_leave,json=reportOnLeave,proto3" json:"report_on_leave,omitempty"`
}

func (m *EventA3Params) Reset()         { *m = EventA3Params{} }
func (m *EventA3Params) String() string { return proto.CompactTextString(m) }
func (*EventA3Params) ProtoMessage()    {}
func (*EventA3Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{9}
}
func (m *EventA3Params) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventA3Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventA3Params.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 *EventA3Params) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventA3Params.Merge(m, src)
}
func (m *EventA3Params) XXX_Size() int {
	return m.Size()
}
func (m *EventA3Params) XXX_DiscardUnknown() {
	xxx_messageInfo_EventA3Params.DiscardUnknown(m)
}

var xxx_messageInfo_EventA3Params proto.InternalMessageInfo

func (m *EventA3Params) GetA3Offset() int32 {
	if m != nil {
		return m.A3Offset
	}
	return 0
}

func (m *EventA3Params) GetReportOnLeave() bool {
	if m != nil {
		return m.ReportOnLeave
	}
	return false
}

type Node struct {
	GnbID         GnbID    `protobuf:"varint,1,opt,name=enbid,proto3,casttype=GnbID" json:"enbid,omitempty"`
	Controllers   []string `protobuf:"bytes,2,rep,name=controllers,proto3" json:"controllers,omitempty"`
	ServiceModels []string `protobuf:"bytes,3,rep,name=service_models,json=serviceModels,proto3" json:"service_models,omitempty"`
	CellNCGIs     []NCGI   `protobuf:"varint,4,rep,packed,name=cell_ecgis,json=cellEcgis,proto3,casttype=NCGI" json:"cell_ecgis,omitempty"`
	Status        string   `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *Node) Reset()         { *m = Node{} }
func (m *Node) String() string { return proto.CompactTextString(m) }
func (*Node) ProtoMessage()    {}
func (*Node) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{10}
}
func (m *Node) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Node.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 *Node) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Node.Merge(m, src)
}
func (m *Node) XXX_Size() int {
	return m.Size()
}
func (m *Node) XXX_DiscardUnknown() {
	xxx_messageInfo_Node.DiscardUnknown(m)
}

var xxx_messageInfo_Node proto.InternalMessageInfo

func (m *Node) GetGnbID() GnbID {
	if m != nil {
		return m.GnbID
	}
	return 0
}

func (m *Node) GetControllers() []string {
	if m != nil {
		return m.Controllers
	}
	return nil
}

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

func (m *Node) GetCellNCGIs() []NCGI {
	if m != nil {
		return m.CellNCGIs
	}
	return nil
}

func (m *Node) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

type MapLayout struct {
	// Map center latitude and longitude
	Center *Point `protobuf:"bytes,1,opt,name=center,proto3" json:"center,omitempty"`
	// The starting Zoom level
	Zoom float32 `protobuf:"fixed32,2,opt,name=zoom,proto3" json:"zoom,omitempty"`
	// Show map as faded on start
	Fade bool `protobuf:"varint,3,opt,name=fade,proto3" json:"fade,omitempty"`
	// Show routes on start
	ShowRoutes bool `protobuf:"varint,4,opt,name=show_routes,json=showRoutes,proto3" json:"show_routes,omitempty"`
	// Show power as circle on start
	ShowPower bool `protobuf:"varint,5,opt,name=show_power,json=showPower,proto3" json:"show_power,omitempty"`
	// Ratio of random locations diameter to tower grid width
	LocationsScale float32 `protobuf:"fixed32,9,opt,name=locations_scale,json=locationsScale,proto3" json:"locations_scale,omitempty"`
	// FIXME: These are deprecated; remove
	// Max number of UEs for complete simulation
	MinUes uint32 `protobuf:"varint,6,opt,name=min_ues,json=minUes,proto3" json:"min_ues,omitempty"`
	// Max number of UEs for complete simulation
	MaxUes uint32 `protobuf:"varint,7,opt,name=max_ues,json=maxUes,proto3" json:"max_ues,omitempty"`
	// the current number of routes
	CurrentRoutes uint32 `protobuf:"varint,8,opt,name=current_routes,json=currentRoutes,proto3" json:"current_routes,omitempty"`
}

func (m *MapLayout) Reset()         { *m = MapLayout{} }
func (m *MapLayout) String() string { return proto.CompactTextString(m) }
func (*MapLayout) ProtoMessage()    {}
func (*MapLayout) Descriptor() ([]byte, []int) {
	return fileDescriptor_4b9d0257bd7c07d7, []int{11}
}
func (m *MapLayout) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MapLayout) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MapLayout.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 *MapLayout) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MapLayout.Merge(m, src)
}
func (m *MapLayout) XXX_Size() int {
	return m.Size()
}
func (m *MapLayout) XXX_DiscardUnknown() {
	xxx_messageInfo_MapLayout.DiscardUnknown(m)
}

var xxx_messageInfo_MapLayout proto.InternalMessageInfo

func (m *MapLayout) GetCenter() *Point {
	if m != nil {
		return m.Center
	}
	return nil
}

func (m *MapLayout) GetZoom() float32 {
	if m != nil {
		return m.Zoom
	}
	return 0
}

func (m *MapLayout) GetFade() bool {
	if m != nil {
		return m.Fade
	}
	return false
}

func (m *MapLayout) GetShowRoutes() bool {
	if m != nil {
		return m.ShowRoutes
	}
	return false
}

func (m *MapLayout) GetShowPower() bool {
	if m != nil {
		return m.ShowPower
	}
	return false
}

func (m *MapLayout) GetLocationsScale() float32 {
	if m != nil {
		return m.LocationsScale
	}
	return 0
}

func (m *MapLayout) GetMinUes() uint32 {
	if m != nil {
		return m.MinUes
	}
	return 0
}

func (m *MapLayout) GetMaxUes() uint32 {
	if m != nil {
		return m.MaxUes
	}
	return 0
}

func (m *MapLayout) GetCurrentRoutes() uint32 {
	if m != nil {
		return m.CurrentRoutes
	}
	return 0
}

func init() {
	proto.RegisterEnum("onos.ransim.types.CellType", CellType_name, CellType_value)
	proto.RegisterType((*Point)(nil), "onos.ransim.types.Point")
	proto.RegisterType((*Sector)(nil), "onos.ransim.types.Sector")
	proto.RegisterType((*Route)(nil), "onos.ransim.types.Route")
	proto.RegisterType((*Ue)(nil), "onos.ransim.types.Ue")
	proto.RegisterType((*UeIdentity)(nil), "onos.ransim.types.UeIdentity")
	proto.RegisterType((*Guami)(nil), "onos.ransim.types.Guami")
	proto.RegisterType((*UeMetrics)(nil), "onos.ransim.types.UeMetrics")
	proto.RegisterType((*Cell)(nil), "onos.ransim.types.Cell")
	proto.RegisterMapType((map[CRNTI]IMSI)(nil), "onos.ransim.types.Cell.CrntiMapEntry")
	proto.RegisterType((*MeasurementParams)(nil), "onos.ransim.types.MeasurementParams")
	proto.RegisterMapType((map[NCGI]int32)(nil), "onos.ransim.types.MeasurementParams.NcellIndividualOffsetsEntry")
	proto.RegisterType((*EventA3Params)(nil), "onos.ransim.types.EventA3Params")
	proto.RegisterType((*Node)(nil), "onos.ransim.types.Node")
	proto.RegisterType((*MapLayout)(nil), "onos.ransim.types.MapLayout")
}

func init() { proto.RegisterFile("onos/ransim/types/types.proto", fileDescriptor_4b9d0257bd7c07d7) }

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

func (m *Point) 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 *Point) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Point) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *Sector) 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 *Sector) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Sector) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Tilt != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Tilt))
		i--
		dAtA[i] = 0x28
	}
	if m.Height != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x20
	}
	if m.Centroid != nil {
		{
			size, err := m.Centroid.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Arc != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Arc))
		i--
		dAtA[i] = 0x10
	}
	if m.Azimuth != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Azimuth))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Route) 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 *Route) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Route) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NextPoint != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.NextPoint))
		i--
		dAtA[i] = 0x38
	}
	if m.Reverse {
		i--
		if m.Reverse {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.SpeedStdev != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SpeedStdev))
		i--
		dAtA[i] = 0x28
	}
	if m.SpeedAvg != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SpeedAvg))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Color) > 0 {
		i -= len(m.Color)
		copy(dAtA[i:], m.Color)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Color)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Waypoints) > 0 {
		for iNdEx := len(m.Waypoints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Waypoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.RouteID != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.RouteID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Ue) 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 *Ue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Ue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Ueid != nil {
		{
			size, err := m.Ueid.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if m.FiveQi != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.FiveQi))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if m.RrcState != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.RrcState))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if m.Metrics != nil {
		{
			size, err := m.Metrics.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if m.Admitted {
		i--
		if m.Admitted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.CRNTI != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.CRNTI))
		i--
		dAtA[i] = 0x78
	}
	if m.Tower3Strength != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Tower3Strength))))
		i--
		dAtA[i] = 0x71
	}
	if m.Tower3 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Tower3))
		i--
		dAtA[i] = 0x68
	}
	if m.Tower2Strength != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Tower2Strength))))
		i--
		dAtA[i] = 0x61
	}
	if m.Tower2 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Tower2))
		i--
		dAtA[i] = 0x58
	}
	if m.Tower1Strength != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Tower1Strength))))
		i--
		dAtA[i] = 0x51
	}
	if m.Tower1 != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Tower1))
		i--
		dAtA[i] = 0x48
	}
	if m.ServingTowerStrength != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ServingTowerStrength))))
		i--
		dAtA[i] = 0x41
	}
	if m.ServingTower != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.ServingTower))
		i--
		dAtA[i] = 0x38
	}
	if m.Rotation != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Rotation))
		i--
		dAtA[i] = 0x28
	}
	if m.Position != nil {
		{
			size, err := m.Position.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0x12
	}
	if m.IMSI != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.IMSI))
		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.AmfUeNgapId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.AmfUeNgapId))
		i--
		dAtA[i] = 0x10
	}
	if m.Guami != nil {
		{
			size, err := m.Guami.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Guami) 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 *Guami) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Guami) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AmfPointer != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.AmfPointer))
		i--
		dAtA[i] = 0x20
	}
	if m.AmfSetId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.AmfSetId))
		i--
		dAtA[i] = 0x18
	}
	if m.AmfRegionId != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.AmfRegionId))
		i--
		dAtA[i] = 0x10
	}
	if m.Plmnid != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Plmnid))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *UeMetrics) 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 *UeMetrics) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UeMetrics) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsFirst {
		i--
		if m.IsFirst {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.HoReportTimestamp != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.HoReportTimestamp))
		i--
		dAtA[i] = 0x10
	}
	if m.HoLatency != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.HoLatency))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Cell) 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 *Cell) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Cell) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RrcConnectedCount != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.RrcConnectedCount))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.RrcIdleCount != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.RrcIdleCount))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.CellType != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.CellType))
		i--
		dAtA[i] = 0x78
	}
	if m.Earfcn != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Earfcn))
		i--
		dAtA[i] = 0x70
	}
	if m.Pci != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Pci))
		i--
		dAtA[i] = 0x68
	}
	if m.Port != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x60
	}
	if m.CrntiIndex != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.CrntiIndex))
		i--
		dAtA[i] = 0x58
	}
	if len(m.CrntiMap) > 0 {
		for k := range m.CrntiMap {
			v := m.CrntiMap[k]
			baseI := i
			i = encodeVarintTypes(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if m.MeasurementParams != nil {
		{
			size, err := m.MeasurementParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.TxPowerdB != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.TxPowerdB))))
		i--
		dAtA[i] = 0x41
	}
	if len(m.Neighbors) > 0 {
		dAtA8 := make([]byte, len(m.Neighbors)*10)
		var j7 int
		for _, num := range m.Neighbors {
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA8[:j7])
		i = encodeVarintTypes(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x3a
	}
	if m.MaxUEs != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MaxUEs))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Color) > 0 {
		i -= len(m.Color)
		copy(dAtA[i:], m.Color)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Color)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Sector != nil {
		{
			size, err := m.Sector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Location != nil {
		{
			size, err := m.Location.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.NCGI != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.NCGI))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MeasurementParams) 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 *MeasurementParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MeasurementParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EventA3Params != nil {
		{
			size, err := m.EventA3Params.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Hysteresis != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Hysteresis))
		i--
		dAtA[i] = 0x28
	}
	if len(m.NcellIndividualOffsets) > 0 {
		for k := range m.NcellIndividualOffsets {
			v := m.NcellIndividualOffsets[k]
			baseI := i
			i = encodeVarintTypes(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTypes(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTypes(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.PcellIndividualOffset != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.PcellIndividualOffset))
		i--
		dAtA[i] = 0x18
	}
	if m.FrequencyOffset != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.FrequencyOffset))
		i--
		dAtA[i] = 0x10
	}
	if m.TimeToTrigger != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.TimeToTrigger))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EventA3Params) 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 *EventA3Params) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventA3Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReportOnLeave {
		i--
		if m.ReportOnLeave {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.A3Offset != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.A3Offset))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Node) 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 *Node) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.CellNCGIs) > 0 {
		dAtA13 := make([]byte, len(m.CellNCGIs)*10)
		var j12 int
		for _, num := range m.CellNCGIs {
			for num >= 1<<7 {
				dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j12++
			}
			dAtA13[j12] = uint8(num)
			j12++
		}
		i -= j12
		copy(dAtA[i:], dAtA13[:j12])
		i = encodeVarintTypes(dAtA, i, uint64(j12))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ServiceModels) > 0 {
		for iNdEx := len(m.ServiceModels) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ServiceModels[iNdEx])
			copy(dAtA[i:], m.ServiceModels[iNdEx])
			i = encodeVarintTypes(dAtA, i, uint64(len(m.ServiceModels[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Controllers) > 0 {
		for iNdEx := len(m.Controllers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Controllers[iNdEx])
			copy(dAtA[i:], m.Controllers[iNdEx])
			i = encodeVarintTypes(dAtA, i, uint64(len(m.Controllers[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.GnbID != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.GnbID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *MapLayout) 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 *MapLayout) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MapLayout) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LocationsScale != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.LocationsScale))))
		i--
		dAtA[i] = 0x4d
	}
	if m.CurrentRoutes != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.CurrentRoutes))
		i--
		dAtA[i] = 0x40
	}
	if m.MaxUes != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MaxUes))
		i--
		dAtA[i] = 0x38
	}
	if m.MinUes != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MinUes))
		i--
		dAtA[i] = 0x30
	}
	if m.ShowPower {
		i--
		if m.ShowPower {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.ShowRoutes {
		i--
		if m.ShowRoutes {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Fade {
		i--
		if m.Fade {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Zoom != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Zoom))))
		i--
		dAtA[i] = 0x15
	}
	if m.Center != nil {
		{
			size, err := m.Center.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Sector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Azimuth != 0 {
		n += 1 + sovTypes(uint64(m.Azimuth))
	}
	if m.Arc != 0 {
		n += 1 + sovTypes(uint64(m.Arc))
	}
	if m.Centroid != nil {
		l = m.Centroid.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Height != 0 {
		n += 1 + sovTypes(uint64(m.Height))
	}
	if m.Tilt != 0 {
		n += 1 + sovTypes(uint64(m.Tilt))
	}
	return n
}

func (m *Route) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RouteID != 0 {
		n += 1 + sovTypes(uint64(m.RouteID))
	}
	if len(m.Waypoints) > 0 {
		for _, e := range m.Waypoints {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.SpeedAvg != 0 {
		n += 1 + sovTypes(uint64(m.SpeedAvg))
	}
	if m.SpeedStdev != 0 {
		n += 1 + sovTypes(uint64(m.SpeedStdev))
	}
	if m.Reverse {
		n += 2
	}
	if m.NextPoint != 0 {
		n += 1 + sovTypes(uint64(m.NextPoint))
	}
	return n
}

func (m *Ue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IMSI != 0 {
		n += 1 + sovTypes(uint64(m.IMSI))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Position != nil {
		l = m.Position.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Rotation != 0 {
		n += 1 + sovTypes(uint64(m.Rotation))
	}
	if m.ServingTower != 0 {
		n += 1 + sovTypes(uint64(m.ServingTower))
	}
	if m.ServingTowerStrength != 0 {
		n += 9
	}
	if m.Tower1 != 0 {
		n += 1 + sovTypes(uint64(m.Tower1))
	}
	if m.Tower1Strength != 0 {
		n += 9
	}
	if m.Tower2 != 0 {
		n += 1 + sovTypes(uint64(m.Tower2))
	}
	if m.Tower2Strength != 0 {
		n += 9
	}
	if m.Tower3 != 0 {
		n += 1 + sovTypes(uint64(m.Tower3))
	}
	if m.Tower3Strength != 0 {
		n += 9
	}
	if m.CRNTI != 0 {
		n += 1 + sovTypes(uint64(m.CRNTI))
	}
	if m.Admitted {
		n += 3
	}
	if m.Metrics != nil {
		l = m.Metrics.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	if m.RrcState != 0 {
		n += 2 + sovTypes(uint64(m.RrcState))
	}
	if m.FiveQi != 0 {
		n += 2 + sovTypes(uint64(m.FiveQi))
	}
	if m.Ueid != nil {
		l = m.Ueid.Size()
		n += 2 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *UeIdentity) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Guami != nil {
		l = m.Guami.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.AmfUeNgapId != 0 {
		n += 1 + sovTypes(uint64(m.AmfUeNgapId))
	}
	return n
}

func (m *Guami) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Plmnid != 0 {
		n += 1 + sovTypes(uint64(m.Plmnid))
	}
	if m.AmfRegionId != 0 {
		n += 1 + sovTypes(uint64(m.AmfRegionId))
	}
	if m.AmfSetId != 0 {
		n += 1 + sovTypes(uint64(m.AmfSetId))
	}
	if m.AmfPointer != 0 {
		n += 1 + sovTypes(uint64(m.AmfPointer))
	}
	return n
}

func (m *UeMetrics) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HoLatency != 0 {
		n += 1 + sovTypes(uint64(m.HoLatency))
	}
	if m.HoReportTimestamp != 0 {
		n += 1 + sovTypes(uint64(m.HoReportTimestamp))
	}
	if m.IsFirst {
		n += 2
	}
	return n
}

func (m *Cell) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NCGI != 0 {
		n += 1 + sovTypes(uint64(m.NCGI))
	}
	if m.Location != nil {
		l = m.Location.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Sector != nil {
		l = m.Sector.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.MaxUEs != 0 {
		n += 1 + sovTypes(uint64(m.MaxUEs))
	}
	if len(m.Neighbors) > 0 {
		l = 0
		for _, e := range m.Neighbors {
			l += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	if m.TxPowerdB != 0 {
		n += 9
	}
	if m.MeasurementParams != nil {
		l = m.MeasurementParams.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if len(m.CrntiMap) > 0 {
		for k, v := range m.CrntiMap {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + sovTypes(uint64(v))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.CrntiIndex != 0 {
		n += 1 + sovTypes(uint64(m.CrntiIndex))
	}
	if m.Port != 0 {
		n += 1 + sovTypes(uint64(m.Port))
	}
	if m.Pci != 0 {
		n += 1 + sovTypes(uint64(m.Pci))
	}
	if m.Earfcn != 0 {
		n += 1 + sovTypes(uint64(m.Earfcn))
	}
	if m.CellType != 0 {
		n += 1 + sovTypes(uint64(m.CellType))
	}
	if m.RrcIdleCount != 0 {
		n += 2 + sovTypes(uint64(m.RrcIdleCount))
	}
	if m.RrcConnectedCount != 0 {
		n += 2 + sovTypes(uint64(m.RrcConnectedCount))
	}
	return n
}

func (m *MeasurementParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TimeToTrigger != 0 {
		n += 1 + sovTypes(uint64(m.TimeToTrigger))
	}
	if m.FrequencyOffset != 0 {
		n += 1 + sovTypes(uint64(m.FrequencyOffset))
	}
	if m.PcellIndividualOffset != 0 {
		n += 1 + sovTypes(uint64(m.PcellIndividualOffset))
	}
	if len(m.NcellIndividualOffsets) > 0 {
		for k, v := range m.NcellIndividualOffsets {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTypes(uint64(k)) + 1 + sovTypes(uint64(v))
			n += mapEntrySize + 1 + sovTypes(uint64(mapEntrySize))
		}
	}
	if m.Hysteresis != 0 {
		n += 1 + sovTypes(uint64(m.Hysteresis))
	}
	if m.EventA3Params != nil {
		l = m.EventA3Params.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *EventA3Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.A3Offset != 0 {
		n += 1 + sovTypes(uint64(m.A3Offset))
	}
	if m.ReportOnLeave {
		n += 2
	}
	return n
}

func (m *Node) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GnbID != 0 {
		n += 1 + sovTypes(uint64(m.GnbID))
	}
	if len(m.Controllers) > 0 {
		for _, s := range m.Controllers {
			l = len(s)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.ServiceModels) > 0 {
		for _, s := range m.ServiceModels {
			l = len(s)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.CellNCGIs) > 0 {
		l = 0
		for _, e := range m.CellNCGIs {
			l += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *MapLayout) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Center != nil {
		l = m.Center.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Zoom != 0 {
		n += 5
	}
	if m.Fade {
		n += 2
	}
	if m.ShowRoutes {
		n += 2
	}
	if m.ShowPower {
		n += 2
	}
	if m.MinUes != 0 {
		n += 1 + sovTypes(uint64(m.MinUes))
	}
	if m.MaxUes != 0 {
		n += 1 + sovTypes(uint64(m.MaxUes))
	}
	if m.CurrentRoutes != 0 {
		n += 1 + sovTypes(uint64(m.CurrentRoutes))
	}
	if m.LocationsScale != 0 {
		n += 5
	}
	return n
}

func sovTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Point) 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 ErrIntOverflowTypes
			}
			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: Point: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Point: 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))
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sector) 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 ErrIntOverflowTypes
			}
			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: Sector: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sector: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Azimuth |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Arc", wireType)
			}
			m.Arc = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Arc |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Centroid", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Centroid == nil {
				m.Centroid = &Point{}
			}
			if err := m.Centroid.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowTypes
				}
				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 := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Route) 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 ErrIntOverflowTypes
			}
			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: Route: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Route: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RouteID", wireType)
			}
			m.RouteID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RouteID |= IMSI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Waypoints = append(m.Waypoints, &Point{})
			if err := m.Waypoints[len(m.Waypoints)-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 Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpeedAvg", wireType)
			}
			m.SpeedAvg = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SpeedAvg |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpeedStdev", wireType)
			}
			m.SpeedStdev = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SpeedStdev |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reverse", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Reverse = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextPoint", wireType)
			}
			m.NextPoint = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextPoint |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Ue) 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 ErrIntOverflowTypes
			}
			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: Ue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IMSI", wireType)
			}
			m.IMSI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IMSI |= IMSI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Position == nil {
				m.Position = &Point{}
			}
			if err := m.Position.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rotation", wireType)
			}
			m.Rotation = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Rotation |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServingTower", wireType)
			}
			m.ServingTower = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ServingTower |= NCGI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServingTowerStrength", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.ServingTowerStrength = float64(math.Float64frombits(v))
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tower1", wireType)
			}
			m.Tower1 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tower1 |= NCGI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tower1Strength", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Tower1Strength = float64(math.Float64frombits(v))
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tower2", wireType)
			}
			m.Tower2 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tower2 |= NCGI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tower2Strength", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Tower2Strength = float64(math.Float64frombits(v))
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tower3", wireType)
			}
			m.Tower3 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tower3 |= NCGI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tower3Strength", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Tower3Strength = float64(math.Float64frombits(v))
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CRNTI", wireType)
			}
			m.CRNTI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CRNTI |= CRNTI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admitted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Admitted = bool(v != 0)
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metrics == nil {
				m.Metrics = &UeMetrics{}
			}
			if err := m.Metrics.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RrcState", wireType)
			}
			m.RrcState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RrcState |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FiveQi", wireType)
			}
			m.FiveQi = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FiveQi |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ueid", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Ueid == nil {
				m.Ueid = &UeIdentity{}
			}
			if err := m.Ueid.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			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 ErrIntOverflowTypes
			}
			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 Guami", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Guami == nil {
				m.Guami = &Guami{}
			}
			if err := m.Guami.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmfUeNgapId", wireType)
			}
			m.AmfUeNgapId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AmfUeNgapId |= AmfUENgapID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Guami) 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 ErrIntOverflowTypes
			}
			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: Guami: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Guami: 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 ErrIntOverflowTypes
				}
				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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AmfRegionId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmfSetId", wireType)
			}
			m.AmfSetId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AmfSetId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmfPointer", wireType)
			}
			m.AmfPointer = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AmfPointer |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UeMetrics) 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 ErrIntOverflowTypes
			}
			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: UeMetrics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UeMetrics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HoLatency", wireType)
			}
			m.HoLatency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HoLatency |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HoReportTimestamp", wireType)
			}
			m.HoReportTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HoReportTimestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsFirst", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsFirst = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Cell) 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 ErrIntOverflowTypes
			}
			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: Cell: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Cell: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NCGI", wireType)
			}
			m.NCGI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NCGI |= NCGI(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Location == nil {
				m.Location = &Point{}
			}
			if err := m.Location.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sector == nil {
				m.Sector = &Sector{}
			}
			if err := m.Sector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUEs", wireType)
			}
			m.MaxUEs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxUEs |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType == 0 {
				var v NCGI
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= NCGI(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Neighbors = append(m.Neighbors, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.Neighbors) == 0 {
					m.Neighbors = make([]NCGI, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v NCGI
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= NCGI(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Neighbors = append(m.Neighbors, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Neighbors", wireType)
			}
		case 8:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxPowerdB", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.TxPowerdB = float64(math.Float64frombits(v))
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MeasurementParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MeasurementParams == nil {
				m.MeasurementParams = &MeasurementParams{}
			}
			if err := m.MeasurementParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CrntiMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CrntiMap == nil {
				m.CrntiMap = make(map[CRNTI]IMSI)
			}
			var mapkey uint32
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.CrntiMap[CRNTI(mapkey)] = ((IMSI)(mapvalue))
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CrntiIndex", wireType)
			}
			m.CrntiIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CrntiIndex |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pci |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Earfcn", wireType)
			}
			m.Earfcn = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Earfcn |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellType", wireType)
			}
			m.CellType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CellType |= CellType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RrcIdleCount", wireType)
			}
			m.RrcIdleCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RrcIdleCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RrcConnectedCount", wireType)
			}
			m.RrcConnectedCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RrcConnectedCount |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeasurementParams) 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 ErrIntOverflowTypes
			}
			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: MeasurementParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MeasurementParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeToTrigger", wireType)
			}
			m.TimeToTrigger = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeToTrigger |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrequencyOffset", wireType)
			}
			m.FrequencyOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FrequencyOffset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PcellIndividualOffset", wireType)
			}
			m.PcellIndividualOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PcellIndividualOffset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NcellIndividualOffsets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NcellIndividualOffsets == nil {
				m.NcellIndividualOffsets = make(map[NCGI]int32)
			}
			var mapkey uint64
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTypes(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTypes
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NcellIndividualOffsets[NCGI(mapkey)] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hysteresis", wireType)
			}
			m.Hysteresis = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Hysteresis |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventA3Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EventA3Params == nil {
				m.EventA3Params = &EventA3Params{}
			}
			if err := m.EventA3Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventA3Params) 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 ErrIntOverflowTypes
			}
			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: EventA3Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventA3Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field A3Offset", wireType)
			}
			m.A3Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.A3Offset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportOnLeave", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReportOnLeave = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Node) 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 ErrIntOverflowTypes
			}
			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: Node: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GnbID |= GnbID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Controllers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Controllers = append(m.Controllers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceModels", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceModels = append(m.ServiceModels, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType == 0 {
				var v NCGI
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= NCGI(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.CellNCGIs = append(m.CellNCGIs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				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.CellNCGIs) == 0 {
					m.CellNCGIs = make([]NCGI, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v NCGI
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= NCGI(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.CellNCGIs = append(m.CellNCGIs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field CellNCGIs", wireType)
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MapLayout) 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 ErrIntOverflowTypes
			}
			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: MapLayout: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MapLayout: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Center", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Center == nil {
				m.Center = &Point{}
			}
			if err := m.Center.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Zoom", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Zoom = float32(math.Float32frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fade", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Fade = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShowRoutes", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ShowRoutes = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShowPower", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ShowPower = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinUes", wireType)
			}
			m.MinUes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinUes |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUes", wireType)
			}
			m.MaxUes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxUes |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentRoutes", wireType)
			}
			m.CurrentRoutes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CurrentRoutes |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocationsScale", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.LocationsScale = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTypes(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, ErrIntOverflowTypes
			}
			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, ErrIntOverflowTypes
				}
				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, ErrIntOverflowTypes
				}
				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, ErrInvalidLengthTypes
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTypes
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTypes
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)