Add Golang module files

[ric-plt/streaming-protobufs.git] / protogen / go / streaming_protobufs / x2ap_common_types.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: x2ap_common_types.proto

package streaming_protobufs

import (
        fmt "fmt"
        proto "github.com/golang/protobuf/proto"
        wrappers "github.com/golang/protobuf/ptypes/wrappers"
        math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type EN_DC_ResourceConfiguration_Status int32

const (
        EN_DC_ResourceConfiguration_protobuf_unspecified EN_DC_ResourceConfiguration_Status = 0
        EN_DC_ResourceConfiguration_present              EN_DC_ResourceConfiguration_Status = 1
        EN_DC_ResourceConfiguration_not_present          EN_DC_ResourceConfiguration_Status = 2
)

var EN_DC_ResourceConfiguration_Status_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "present",
        2: "not_present",
}

var EN_DC_ResourceConfiguration_Status_value = map[string]int32{
        "protobuf_unspecified": 0,
        "present":              1,
        "not_present":          2,
}

func (x EN_DC_ResourceConfiguration_Status) String() string {
        return proto.EnumName(EN_DC_ResourceConfiguration_Status_name, int32(x))
}

func (EN_DC_ResourceConfiguration_Status) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{0, 0}
}

type PreEmptionVulnerability_Value int32

const (
        PreEmptionVulnerability_protobuf_unspecified PreEmptionVulnerability_Value = 0
        PreEmptionVulnerability_not_pre_emptable     PreEmptionVulnerability_Value = 1
        PreEmptionVulnerability_pre_emptable         PreEmptionVulnerability_Value = 2
)

var PreEmptionVulnerability_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "not_pre_emptable",
        2: "pre_emptable",
}

var PreEmptionVulnerability_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "not_pre_emptable":     1,
        "pre_emptable":         2,
}

func (x PreEmptionVulnerability_Value) String() string {
        return proto.EnumName(PreEmptionVulnerability_Value_name, int32(x))
}

func (PreEmptionVulnerability_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{3, 0}
}

type PreEmptionCapability_Value int32

const (
        PreEmptionCapability_protobuf_unspecified          PreEmptionCapability_Value = 0
        PreEmptionCapability_shall_not_trigger_pre_emption PreEmptionCapability_Value = 1
        PreEmptionCapability_may_trigger_pre_emption       PreEmptionCapability_Value = 2
)

var PreEmptionCapability_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "shall_not_trigger_pre_emption",
        2: "may_trigger_pre_emption",
}

var PreEmptionCapability_Value_value = map[string]int32{
        "protobuf_unspecified":          0,
        "shall_not_trigger_pre_emption": 1,
        "may_trigger_pre_emption":       2,
}

func (x PreEmptionCapability_Value) String() string {
        return proto.EnumName(PreEmptionCapability_Value_name, int32(x))
}

func (PreEmptionCapability_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{4, 0}
}

type RLCMode_Value int32

const (
        RLCMode_protobuf_unspecified     RLCMode_Value = 0
        RLCMode_rlc_am                   RLCMode_Value = 1
        RLCMode_rlc_um_bidirectional     RLCMode_Value = 2
        RLCMode_rlc_um_unidirectional_ul RLCMode_Value = 3
        RLCMode_rlc_um_unidirectional_dl RLCMode_Value = 4
)

var RLCMode_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "rlc_am",
        2: "rlc_um_bidirectional",
        3: "rlc_um_unidirectional_ul",
        4: "rlc_um_unidirectional_dl",
}

var RLCMode_Value_value = map[string]int32{
        "protobuf_unspecified":     0,
        "rlc_am":                   1,
        "rlc_um_bidirectional":     2,
        "rlc_um_unidirectional_ul": 3,
        "rlc_um_unidirectional_dl": 4,
}

func (x RLCMode_Value) String() string {
        return proto.EnumName(RLCMode_Value_name, int32(x))
}

func (RLCMode_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{13, 0}
}

type RLC_Status_Reestablishment_Indication int32

const (
        RLC_Status_protobuf_unspecified RLC_Status_Reestablishment_Indication = 0
        RLC_Status_reestablished        RLC_Status_Reestablishment_Indication = 1
)

var RLC_Status_Reestablishment_Indication_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "reestablished",
}

var RLC_Status_Reestablishment_Indication_value = map[string]int32{
        "protobuf_unspecified": 0,
        "reestablished":        1,
}

func (x RLC_Status_Reestablishment_Indication) String() string {
        return proto.EnumName(RLC_Status_Reestablishment_Indication_name, int32(x))
}

func (RLC_Status_Reestablishment_Indication) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{14, 0}
}

type ULConfiguration_UL_UE_Configuration int32

const (
        ULConfiguration_protobuf_unspecified ULConfiguration_UL_UE_Configuration = 0
        ULConfiguration_no_data              ULConfiguration_UL_UE_Configuration = 1
        ULConfiguration_shared               ULConfiguration_UL_UE_Configuration = 2
        ULConfiguration_only                 ULConfiguration_UL_UE_Configuration = 3
)

var ULConfiguration_UL_UE_Configuration_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "no_data",
        2: "shared",
        3: "only",
}

var ULConfiguration_UL_UE_Configuration_value = map[string]int32{
        "protobuf_unspecified": 0,
        "no_data":              1,
        "shared":               2,
        "only":                 3,
}

func (x ULConfiguration_UL_UE_Configuration) String() string {
        return proto.EnumName(ULConfiguration_UL_UE_Configuration_name, int32(x))
}

func (ULConfiguration_UL_UE_Configuration) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{15, 0}
}

type PDCPSnLength_Value int32

const (
        PDCPSnLength_protobuf_unspecified PDCPSnLength_Value = 0
        PDCPSnLength_twelve_bits          PDCPSnLength_Value = 1
        PDCPSnLength_eighteen_bits        PDCPSnLength_Value = 2
)

var PDCPSnLength_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "twelve_bits",
        2: "eighteen_bits",
}

var PDCPSnLength_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "twelve_bits":          1,
        "eighteen_bits":        2,
}

func (x PDCPSnLength_Value) String() string {
        return proto.EnumName(PDCPSnLength_Value_name, int32(x))
}

func (PDCPSnLength_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{16, 0}
}

type PDCPChangeIndication_Value int32

const (
        PDCPChangeIndication_protobuf_unspecified        PDCPChangeIndication_Value = 0
        PDCPChangeIndication_s_KgNB_update_required      PDCPChangeIndication_Value = 1
        PDCPChangeIndication_pDCP_data_recovery_required PDCPChangeIndication_Value = 2
)

var PDCPChangeIndication_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "s_KgNB_update_required",
        2: "pDCP_data_recovery_required",
}

var PDCPChangeIndication_Value_value = map[string]int32{
        "protobuf_unspecified":        0,
        "s_KgNB_update_required":      1,
        "pDCP_data_recovery_required": 2,
}

func (x PDCPChangeIndication_Value) String() string {
        return proto.EnumName(PDCPChangeIndication_Value_name, int32(x))
}

func (PDCPChangeIndication_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{17, 0}
}

type SplitSRBs_Value int32

const (
        SplitSRBs_protobuf_unspecified SplitSRBs_Value = 0
        SplitSRBs_srb1                 SplitSRBs_Value = 1
        SplitSRBs_srb2                 SplitSRBs_Value = 2
        SplitSRBs_srb1and2             SplitSRBs_Value = 3
)

var SplitSRBs_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "srb1",
        2: "srb2",
        3: "srb1and2",
}

var SplitSRBs_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "srb1":                 1,
        "srb2":                 2,
        "srb1and2":             3,
}

func (x SplitSRBs_Value) String() string {
        return proto.EnumName(SplitSRBs_Value_name, int32(x))
}

func (SplitSRBs_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{18, 0}
}

type UserPlaneTrafficActivityReport_Value int32

const (
        UserPlaneTrafficActivityReport_protobuf_unspecified UserPlaneTrafficActivityReport_Value = 0
        UserPlaneTrafficActivityReport_inactive             UserPlaneTrafficActivityReport_Value = 1
        UserPlaneTrafficActivityReport_re_activated         UserPlaneTrafficActivityReport_Value = 2
)

var UserPlaneTrafficActivityReport_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "inactive",
        2: "re_activated",
}

var UserPlaneTrafficActivityReport_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "inactive":             1,
        "re_activated":         2,
}

func (x UserPlaneTrafficActivityReport_Value) String() string {
        return proto.EnumName(UserPlaneTrafficActivityReport_Value_name, int32(x))
}

func (UserPlaneTrafficActivityReport_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{28, 0}
}

type GNBOverloadInformation_Value int32

const (
        GNBOverloadInformation_protobuf_unspecified GNBOverloadInformation_Value = 0
        GNBOverloadInformation_overloaded           GNBOverloadInformation_Value = 1
        GNBOverloadInformation_not_overloaded       GNBOverloadInformation_Value = 2
)

var GNBOverloadInformation_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "overloaded",
        2: "not_overloaded",
}

var GNBOverloadInformation_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "overloaded":           1,
        "not_overloaded":       2,
}

func (x GNBOverloadInformation_Value) String() string {
        return proto.EnumName(GNBOverloadInformation_Value_name, int32(x))
}

func (GNBOverloadInformation_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{29, 0}
}

type TriggeringMessage_Value int32

const (
        TriggeringMessage_protobuf_unspecified TriggeringMessage_Value = 0
        TriggeringMessage_initiating_message   TriggeringMessage_Value = 1
        TriggeringMessage_successful_outcome   TriggeringMessage_Value = 2
        TriggeringMessage_unsuccessful_outcome TriggeringMessage_Value = 3
)

var TriggeringMessage_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "initiating_message",
        2: "successful_outcome",
        3: "unsuccessful_outcome",
}

var TriggeringMessage_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "initiating_message":   1,
        "successful_outcome":   2,
        "unsuccessful_outcome": 3,
}

func (x TriggeringMessage_Value) String() string {
        return proto.EnumName(TriggeringMessage_Value_name, int32(x))
}

func (TriggeringMessage_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{31, 0}
}

type Criticality_Value int32

const (
        Criticality_protobuf_unspecified Criticality_Value = 0
        Criticality_reject               Criticality_Value = 1
        Criticality_ignore               Criticality_Value = 2
        Criticality_notify               Criticality_Value = 3
)

var Criticality_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "reject",
        2: "ignore",
        3: "notify",
}

var Criticality_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "reject":               1,
        "ignore":               2,
        "notify":               3,
}

func (x Criticality_Value) String() string {
        return proto.EnumName(Criticality_Value_name, int32(x))
}

func (Criticality_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{32, 0}
}

type TypeOfError_Value int32

const (
        TypeOfError_protobuf_unspecified TypeOfError_Value = 0
        TypeOfError_not_understood       TypeOfError_Value = 1
        TypeOfError_missing              TypeOfError_Value = 2
)

var TypeOfError_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "not_understood",
        2: "missing",
}

var TypeOfError_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "not_understood":       1,
        "missing":              2,
}

func (x TypeOfError_Value) String() string {
        return proto.EnumName(TypeOfError_Value_name, int32(x))
}

func (TypeOfError_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{35, 0}
}

type SgNBCoordinationAssistanceInformation_Value int32

const (
        SgNBCoordinationAssistanceInformation_protobuf_unspecified      SgNBCoordinationAssistanceInformation_Value = 0
        SgNBCoordinationAssistanceInformation_coordination_not_required SgNBCoordinationAssistanceInformation_Value = 1
)

var SgNBCoordinationAssistanceInformation_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "coordination_not_required",
}

var SgNBCoordinationAssistanceInformation_Value_value = map[string]int32{
        "protobuf_unspecified":      0,
        "coordination_not_required": 1,
}

func (x SgNBCoordinationAssistanceInformation_Value) String() string {
        return proto.EnumName(SgNBCoordinationAssistanceInformation_Value_name, int32(x))
}

func (SgNBCoordinationAssistanceInformation_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{39, 0}
}

type RRC_Config_Ind_Value int32

const (
        RRC_Config_Ind_protobuf_unspecified RRC_Config_Ind_Value = 0
        RRC_Config_Ind_full_config          RRC_Config_Ind_Value = 1
        RRC_Config_Ind_delta_config         RRC_Config_Ind_Value = 2
)

var RRC_Config_Ind_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "full_config",
        2: "delta_config",
}

var RRC_Config_Ind_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "full_config":          1,
        "delta_config":         2,
}

func (x RRC_Config_Ind_Value) String() string {
        return proto.EnumName(RRC_Config_Ind_Value_name, int32(x))
}

func (RRC_Config_Ind_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{40, 0}
}

type ForbiddenInterRATs_Value int32

const (
        ForbiddenInterRATs_protobuf_unspecified ForbiddenInterRATs_Value = 0
        ForbiddenInterRATs_all                  ForbiddenInterRATs_Value = 1
        ForbiddenInterRATs_geran                ForbiddenInterRATs_Value = 2
        ForbiddenInterRATs_utran                ForbiddenInterRATs_Value = 3
        ForbiddenInterRATs_cdma2000             ForbiddenInterRATs_Value = 4
        ForbiddenInterRATs_geranandutran        ForbiddenInterRATs_Value = 5
        ForbiddenInterRATs_cdma2000andutran     ForbiddenInterRATs_Value = 6
)

var ForbiddenInterRATs_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "all",
        2: "geran",
        3: "utran",
        4: "cdma2000",
        5: "geranandutran",
        6: "cdma2000andutran",
}

var ForbiddenInterRATs_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "all":                  1,
        "geran":                2,
        "utran":                3,
        "cdma2000":             4,
        "geranandutran":        5,
        "cdma2000andutran":     6,
}

func (x ForbiddenInterRATs_Value) String() string {
        return proto.EnumName(ForbiddenInterRATs_Value_name, int32(x))
}

func (ForbiddenInterRATs_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{49, 0}
}

type NRrestrictioninEPSasSecondaryRAT_Value int32

const (
        NRrestrictioninEPSasSecondaryRAT_protobuf_unspecified            NRrestrictioninEPSasSecondaryRAT_Value = 0
        NRrestrictioninEPSasSecondaryRAT_nRrestrictedinEPSasSecondaryRAT NRrestrictioninEPSasSecondaryRAT_Value = 1
)

var NRrestrictioninEPSasSecondaryRAT_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "nRrestrictedinEPSasSecondaryRAT",
}

var NRrestrictioninEPSasSecondaryRAT_Value_value = map[string]int32{
        "protobuf_unspecified":            0,
        "nRrestrictedinEPSasSecondaryRAT": 1,
}

func (x NRrestrictioninEPSasSecondaryRAT_Value) String() string {
        return proto.EnumName(NRrestrictioninEPSasSecondaryRAT_Value_name, int32(x))
}

func (NRrestrictioninEPSasSecondaryRAT_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{51, 0}
}

type CNTypeRestrictionsItem_CNType int32

const (
        CNTypeRestrictionsItem_protobuf_unspecified CNTypeRestrictionsItem_CNType = 0
        CNTypeRestrictionsItem_fiveGC_forbidden     CNTypeRestrictionsItem_CNType = 1
)

var CNTypeRestrictionsItem_CNType_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "fiveGC_forbidden",
}

var CNTypeRestrictionsItem_CNType_value = map[string]int32{
        "protobuf_unspecified": 0,
        "fiveGC_forbidden":     1,
}

func (x CNTypeRestrictionsItem_CNType) String() string {
        return proto.EnumName(CNTypeRestrictionsItem_CNType_name, int32(x))
}

func (CNTypeRestrictionsItem_CNType) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{53, 0}
}

type NRrestrictionin5GS_Value int32

const (
        NRrestrictionin5GS_protobuf_unspecified NRrestrictionin5GS_Value = 0
        NRrestrictionin5GS_nRrestrictedin5GS    NRrestrictionin5GS_Value = 1
)

var NRrestrictionin5GS_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "nRrestrictedin5GS",
}

var NRrestrictionin5GS_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "nRrestrictedin5GS":    1,
}

func (x NRrestrictionin5GS_Value) String() string {
        return proto.EnumName(NRrestrictionin5GS_Value_name, int32(x))
}

func (NRrestrictionin5GS_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{54, 0}
}

type DL_Forwarding_Value int32

const (
        DL_Forwarding_protobuf_unspecified  DL_Forwarding_Value = 0
        DL_Forwarding_dL_forwardingProposed DL_Forwarding_Value = 1
)

var DL_Forwarding_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "dL_forwardingProposed",
}

var DL_Forwarding_Value_value = map[string]int32{
        "protobuf_unspecified":  0,
        "dL_forwardingProposed": 1,
}

func (x DL_Forwarding_Value) String() string {
        return proto.EnumName(DL_Forwarding_Value_name, int32(x))
}

func (DL_Forwarding_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{58, 0}
}

type DuplicationActivation_Value int32

const (
        DuplicationActivation_protobuf_unspecified DuplicationActivation_Value = 0
        DuplicationActivation_active               DuplicationActivation_Value = 1
        DuplicationActivation_inactive             DuplicationActivation_Value = 2
)

var DuplicationActivation_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "active",
        2: "inactive",
}

var DuplicationActivation_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "active":               1,
        "inactive":             2,
}

func (x DuplicationActivation_Value) String() string {
        return proto.EnumName(DuplicationActivation_Value_name, int32(x))
}

func (DuplicationActivation_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{59, 0}
}

type MeNBCoordinationAssistanceInformation_Value int32

const (
        MeNBCoordinationAssistanceInformation_protobuf_unspecified      MeNBCoordinationAssistanceInformation_Value = 0
        MeNBCoordinationAssistanceInformation_coordination_not_required MeNBCoordinationAssistanceInformation_Value = 1
)

var MeNBCoordinationAssistanceInformation_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "coordination_not_required",
}

var MeNBCoordinationAssistanceInformation_Value_value = map[string]int32{
        "protobuf_unspecified":      0,
        "coordination_not_required": 1,
}

func (x MeNBCoordinationAssistanceInformation_Value) String() string {
        return proto.EnumName(MeNBCoordinationAssistanceInformation_Value_name, int32(x))
}

func (MeNBCoordinationAssistanceInformation_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{62, 0}
}

type ExpectedHOInterval_Value int32

const (
        ExpectedHOInterval_protobuf_unspecified ExpectedHOInterval_Value = 0
        ExpectedHOInterval_sec15                ExpectedHOInterval_Value = 1
        ExpectedHOInterval_sec30                ExpectedHOInterval_Value = 2
        ExpectedHOInterval_sec60                ExpectedHOInterval_Value = 3
        ExpectedHOInterval_sec90                ExpectedHOInterval_Value = 4
        ExpectedHOInterval_sec120               ExpectedHOInterval_Value = 5
        ExpectedHOInterval_sec180               ExpectedHOInterval_Value = 6
        ExpectedHOInterval_long_time            ExpectedHOInterval_Value = 7
)

var ExpectedHOInterval_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "sec15",
        2: "sec30",
        3: "sec60",
        4: "sec90",
        5: "sec120",
        6: "sec180",
        7: "long_time",
}

var ExpectedHOInterval_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "sec15":                1,
        "sec30":                2,
        "sec60":                3,
        "sec90":                4,
        "sec120":               5,
        "sec180":               6,
        "long_time":            7,
}

func (x ExpectedHOInterval_Value) String() string {
        return proto.EnumName(ExpectedHOInterval_Value_name, int32(x))
}

func (ExpectedHOInterval_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{69, 0}
}

type SourceOfUEActivityBehaviourInformation_Value int32

const (
        SourceOfUEActivityBehaviourInformation_protobuf_unspecified     SourceOfUEActivityBehaviourInformation_Value = 0
        SourceOfUEActivityBehaviourInformation_subscription_information SourceOfUEActivityBehaviourInformation_Value = 1
        SourceOfUEActivityBehaviourInformation_statistics               SourceOfUEActivityBehaviourInformation_Value = 2
)

var SourceOfUEActivityBehaviourInformation_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "subscription_information",
        2: "statistics",
}

var SourceOfUEActivityBehaviourInformation_Value_value = map[string]int32{
        "protobuf_unspecified":     0,
        "subscription_information": 1,
        "statistics":               2,
}

func (x SourceOfUEActivityBehaviourInformation_Value) String() string {
        return proto.EnumName(SourceOfUEActivityBehaviourInformation_Value_name, int32(x))
}

func (SourceOfUEActivityBehaviourInformation_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{70, 0}
}

type SGNB_Addition_Trigger_Ind_Value int32

const (
        SGNB_Addition_Trigger_Ind_protobuf_unspecified SGNB_Addition_Trigger_Ind_Value = 0
        SGNB_Addition_Trigger_Ind_sn_change            SGNB_Addition_Trigger_Ind_Value = 1
        SGNB_Addition_Trigger_Ind_inter_eNB_HO         SGNB_Addition_Trigger_Ind_Value = 2
        SGNB_Addition_Trigger_Ind_intra_eNB_HO         SGNB_Addition_Trigger_Ind_Value = 3
)

var SGNB_Addition_Trigger_Ind_Value_name = map[int32]string{
        0: "protobuf_unspecified",
        1: "sn_change",
        2: "inter_eNB_HO",
        3: "intra_eNB_HO",
}

var SGNB_Addition_Trigger_Ind_Value_value = map[string]int32{
        "protobuf_unspecified": 0,
        "sn_change":            1,
        "inter_eNB_HO":         2,
        "intra_eNB_HO":         3,
}

func (x SGNB_Addition_Trigger_Ind_Value) String() string {
        return proto.EnumName(SGNB_Addition_Trigger_Ind_Value_name, int32(x))
}

func (SGNB_Addition_Trigger_Ind_Value) EnumDescriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{71, 0}
}

type EN_DC_ResourceConfiguration struct {
        PDCPatSgNB           EN_DC_ResourceConfiguration_Status `protobuf:"varint,1,opt,name=pDCPatSgNB,proto3,enum=streaming_protobufs.EN_DC_ResourceConfiguration_Status" json:"pDCPatSgNB,omitempty"`
        MCGresources         EN_DC_ResourceConfiguration_Status `protobuf:"varint,2,opt,name=mCGresources,proto3,enum=streaming_protobufs.EN_DC_ResourceConfiguration_Status" json:"mCGresources,omitempty"`
        SCGresources         EN_DC_ResourceConfiguration_Status `protobuf:"varint,3,opt,name=sCGresources,proto3,enum=streaming_protobufs.EN_DC_ResourceConfiguration_Status" json:"sCGresources,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
        XXX_unrecognized     []byte                             `json:"-"`
        XXX_sizecache        int32                              `json:"-"`
}

func (m *EN_DC_ResourceConfiguration) Reset()         { *m = EN_DC_ResourceConfiguration{} }
func (m *EN_DC_ResourceConfiguration) String() string { return proto.CompactTextString(m) }
func (*EN_DC_ResourceConfiguration) ProtoMessage()    {}
func (*EN_DC_ResourceConfiguration) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{0}
}

func (m *EN_DC_ResourceConfiguration) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_EN_DC_ResourceConfiguration.Unmarshal(m, b)
}
func (m *EN_DC_ResourceConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_EN_DC_ResourceConfiguration.Marshal(b, m, deterministic)
}
func (m *EN_DC_ResourceConfiguration) XXX_Merge(src proto.Message) {
        xxx_messageInfo_EN_DC_ResourceConfiguration.Merge(m, src)
}
func (m *EN_DC_ResourceConfiguration) XXX_Size() int {
        return xxx_messageInfo_EN_DC_ResourceConfiguration.Size(m)
}
func (m *EN_DC_ResourceConfiguration) XXX_DiscardUnknown() {
        xxx_messageInfo_EN_DC_ResourceConfiguration.DiscardUnknown(m)
}

var xxx_messageInfo_EN_DC_ResourceConfiguration proto.InternalMessageInfo

func (m *EN_DC_ResourceConfiguration) GetPDCPatSgNB() EN_DC_ResourceConfiguration_Status {
        if m != nil {
                return m.PDCPatSgNB
        }
        return EN_DC_ResourceConfiguration_protobuf_unspecified
}

func (m *EN_DC_ResourceConfiguration) GetMCGresources() EN_DC_ResourceConfiguration_Status {
        if m != nil {
                return m.MCGresources
        }
        return EN_DC_ResourceConfiguration_protobuf_unspecified
}

func (m *EN_DC_ResourceConfiguration) GetSCGresources() EN_DC_ResourceConfiguration_Status {
        if m != nil {
                return m.SCGresources
        }
        return EN_DC_ResourceConfiguration_protobuf_unspecified
}

type E_RAB_Level_QoS_Parameters struct {
        QCI                            uint32                               `protobuf:"varint,1,opt,name=qCI,proto3" json:"qCI,omitempty"`
        AllocationAndRetentionPriority *AllocationAndRetentionPriority      `protobuf:"bytes,2,opt,name=allocationAndRetentionPriority,proto3" json:"allocationAndRetentionPriority,omitempty"`
        GbrQosInformation              *GBR_QosInformation                  `protobuf:"bytes,3,opt,name=gbrQosInformation,proto3" json:"gbrQosInformation,omitempty"`
        IE_Extensions                  []*E_RAB_Level_QoS_Parameters_ExtIEs `protobuf:"bytes,4,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral           struct{}                             `json:"-"`
        XXX_unrecognized               []byte                               `json:"-"`
        XXX_sizecache                  int32                                `json:"-"`
}

func (m *E_RAB_Level_QoS_Parameters) Reset()         { *m = E_RAB_Level_QoS_Parameters{} }
func (m *E_RAB_Level_QoS_Parameters) String() string { return proto.CompactTextString(m) }
func (*E_RAB_Level_QoS_Parameters) ProtoMessage()    {}
func (*E_RAB_Level_QoS_Parameters) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{1}
}

func (m *E_RAB_Level_QoS_Parameters) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_E_RAB_Level_QoS_Parameters.Unmarshal(m, b)
}
func (m *E_RAB_Level_QoS_Parameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_E_RAB_Level_QoS_Parameters.Marshal(b, m, deterministic)
}
func (m *E_RAB_Level_QoS_Parameters) XXX_Merge(src proto.Message) {
        xxx_messageInfo_E_RAB_Level_QoS_Parameters.Merge(m, src)
}
func (m *E_RAB_Level_QoS_Parameters) XXX_Size() int {
        return xxx_messageInfo_E_RAB_Level_QoS_Parameters.Size(m)
}
func (m *E_RAB_Level_QoS_Parameters) XXX_DiscardUnknown() {
        xxx_messageInfo_E_RAB_Level_QoS_Parameters.DiscardUnknown(m)
}

var xxx_messageInfo_E_RAB_Level_QoS_Parameters proto.InternalMessageInfo

func (m *E_RAB_Level_QoS_Parameters) GetQCI() uint32 {
        if m != nil {
                return m.QCI
        }
        return 0
}

func (m *E_RAB_Level_QoS_Parameters) GetAllocationAndRetentionPriority() *AllocationAndRetentionPriority {
        if m != nil {
                return m.AllocationAndRetentionPriority
        }
        return nil
}

func (m *E_RAB_Level_QoS_Parameters) GetGbrQosInformation() *GBR_QosInformation {
        if m != nil {
                return m.GbrQosInformation
        }
        return nil
}

func (m *E_RAB_Level_QoS_Parameters) GetIE_Extensions() []*E_RAB_Level_QoS_Parameters_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type AllocationAndRetentionPriority struct {
        PriorityLevel           uint32                   `protobuf:"varint,1,opt,name=priorityLevel,proto3" json:"priorityLevel,omitempty"`
        PreEmptionCapability    *PreEmptionCapability    `protobuf:"bytes,2,opt,name=pre_emptionCapability,json=preEmptionCapability,proto3" json:"pre_emptionCapability,omitempty"`
        PreEmptionVulnerability *PreEmptionVulnerability `protobuf:"bytes,3,opt,name=pre_emptionVulnerability,json=preEmptionVulnerability,proto3" json:"pre_emptionVulnerability,omitempty"`
        XXX_NoUnkeyedLiteral    struct{}                 `json:"-"`
        XXX_unrecognized        []byte                   `json:"-"`
        XXX_sizecache           int32                    `json:"-"`
}

func (m *AllocationAndRetentionPriority) Reset()         { *m = AllocationAndRetentionPriority{} }
func (m *AllocationAndRetentionPriority) String() string { return proto.CompactTextString(m) }
func (*AllocationAndRetentionPriority) ProtoMessage()    {}
func (*AllocationAndRetentionPriority) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{2}
}

func (m *AllocationAndRetentionPriority) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_AllocationAndRetentionPriority.Unmarshal(m, b)
}
func (m *AllocationAndRetentionPriority) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_AllocationAndRetentionPriority.Marshal(b, m, deterministic)
}
func (m *AllocationAndRetentionPriority) XXX_Merge(src proto.Message) {
        xxx_messageInfo_AllocationAndRetentionPriority.Merge(m, src)
}
func (m *AllocationAndRetentionPriority) XXX_Size() int {
        return xxx_messageInfo_AllocationAndRetentionPriority.Size(m)
}
func (m *AllocationAndRetentionPriority) XXX_DiscardUnknown() {
        xxx_messageInfo_AllocationAndRetentionPriority.DiscardUnknown(m)
}

var xxx_messageInfo_AllocationAndRetentionPriority proto.InternalMessageInfo

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

func (m *AllocationAndRetentionPriority) GetPreEmptionCapability() *PreEmptionCapability {
        if m != nil {
                return m.PreEmptionCapability
        }
        return nil
}

func (m *AllocationAndRetentionPriority) GetPreEmptionVulnerability() *PreEmptionVulnerability {
        if m != nil {
                return m.PreEmptionVulnerability
        }
        return nil
}

type PreEmptionVulnerability struct {
        Value                PreEmptionVulnerability_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.PreEmptionVulnerability_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
        XXX_unrecognized     []byte                        `json:"-"`
        XXX_sizecache        int32                         `json:"-"`
}

func (m *PreEmptionVulnerability) Reset()         { *m = PreEmptionVulnerability{} }
func (m *PreEmptionVulnerability) String() string { return proto.CompactTextString(m) }
func (*PreEmptionVulnerability) ProtoMessage()    {}
func (*PreEmptionVulnerability) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{3}
}

func (m *PreEmptionVulnerability) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PreEmptionVulnerability.Unmarshal(m, b)
}
func (m *PreEmptionVulnerability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PreEmptionVulnerability.Marshal(b, m, deterministic)
}
func (m *PreEmptionVulnerability) XXX_Merge(src proto.Message) {
        xxx_messageInfo_PreEmptionVulnerability.Merge(m, src)
}
func (m *PreEmptionVulnerability) XXX_Size() int {
        return xxx_messageInfo_PreEmptionVulnerability.Size(m)
}
func (m *PreEmptionVulnerability) XXX_DiscardUnknown() {
        xxx_messageInfo_PreEmptionVulnerability.DiscardUnknown(m)
}

var xxx_messageInfo_PreEmptionVulnerability proto.InternalMessageInfo

func (m *PreEmptionVulnerability) GetValue() PreEmptionVulnerability_Value {
        if m != nil {
                return m.Value
        }
        return PreEmptionVulnerability_protobuf_unspecified
}

type PreEmptionCapability struct {
        Value                PreEmptionCapability_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.PreEmptionCapability_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
        XXX_unrecognized     []byte                     `json:"-"`
        XXX_sizecache        int32                      `json:"-"`
}

func (m *PreEmptionCapability) Reset()         { *m = PreEmptionCapability{} }
func (m *PreEmptionCapability) String() string { return proto.CompactTextString(m) }
func (*PreEmptionCapability) ProtoMessage()    {}
func (*PreEmptionCapability) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{4}
}

func (m *PreEmptionCapability) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PreEmptionCapability.Unmarshal(m, b)
}
func (m *PreEmptionCapability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PreEmptionCapability.Marshal(b, m, deterministic)
}
func (m *PreEmptionCapability) XXX_Merge(src proto.Message) {
        xxx_messageInfo_PreEmptionCapability.Merge(m, src)
}
func (m *PreEmptionCapability) XXX_Size() int {
        return xxx_messageInfo_PreEmptionCapability.Size(m)
}
func (m *PreEmptionCapability) XXX_DiscardUnknown() {
        xxx_messageInfo_PreEmptionCapability.DiscardUnknown(m)
}

var xxx_messageInfo_PreEmptionCapability proto.InternalMessageInfo

func (m *PreEmptionCapability) GetValue() PreEmptionCapability_Value {
        if m != nil {
                return m.Value
        }
        return PreEmptionCapability_protobuf_unspecified
}

type E_RAB_Level_QoS_Parameters_ExtIEs struct {
        Id_DownlinkPacketLossRate *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=id_DownlinkPacketLossRate,json=idDownlinkPacketLossRate,proto3" json:"id_DownlinkPacketLossRate,omitempty"`
        Id_UplinkPacketLossRate   *wrappers.UInt32Value `protobuf:"bytes,2,opt,name=id_UplinkPacketLossRate,json=idUplinkPacketLossRate,proto3" json:"id_UplinkPacketLossRate,omitempty"`
        XXX_NoUnkeyedLiteral      struct{}              `json:"-"`
        XXX_unrecognized          []byte                `json:"-"`
        XXX_sizecache             int32                 `json:"-"`
}

func (m *E_RAB_Level_QoS_Parameters_ExtIEs) Reset()         { *m = E_RAB_Level_QoS_Parameters_ExtIEs{} }
func (m *E_RAB_Level_QoS_Parameters_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*E_RAB_Level_QoS_Parameters_ExtIEs) ProtoMessage()    {}
func (*E_RAB_Level_QoS_Parameters_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{5}
}

func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.Unmarshal(m, b)
}
func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.Marshal(b, m, deterministic)
}
func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.Merge(m, src)
}
func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.Size(m)
}
func (m *E_RAB_Level_QoS_Parameters_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_E_RAB_Level_QoS_Parameters_ExtIEs proto.InternalMessageInfo

func (m *E_RAB_Level_QoS_Parameters_ExtIEs) GetId_DownlinkPacketLossRate() *wrappers.UInt32Value {
        if m != nil {
                return m.Id_DownlinkPacketLossRate
        }
        return nil
}

func (m *E_RAB_Level_QoS_Parameters_ExtIEs) GetId_UplinkPacketLossRate() *wrappers.UInt32Value {
        if m != nil {
                return m.Id_UplinkPacketLossRate
        }
        return nil
}

type GBR_QosInformation struct {
        E_RAB_MaximumBitrateDL    uint64                       `protobuf:"varint,1,opt,name=e_RAB_MaximumBitrateDL,json=eRABMaximumBitrateDL,proto3" json:"e_RAB_MaximumBitrateDL,omitempty"`
        E_RAB_MaximumBitrateUL    uint64                       `protobuf:"varint,2,opt,name=e_RAB_MaximumBitrateUL,json=eRABMaximumBitrateUL,proto3" json:"e_RAB_MaximumBitrateUL,omitempty"`
        E_RAB_GuaranteedBitrateDL uint64                       `protobuf:"varint,3,opt,name=e_RAB_GuaranteedBitrateDL,json=eRABGuaranteedBitrateDL,proto3" json:"e_RAB_GuaranteedBitrateDL,omitempty"`
        E_RAB_GuaranteedBitrateUL uint64                       `protobuf:"varint,4,opt,name=e_RAB_GuaranteedBitrateUL,json=eRABGuaranteedBitrateUL,proto3" json:"e_RAB_GuaranteedBitrateUL,omitempty"`
        IE_Extensions             []*GBR_QosInformation_ExtIEs `protobuf:"bytes,5,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral      struct{}                     `json:"-"`
        XXX_unrecognized          []byte                       `json:"-"`
        XXX_sizecache             int32                        `json:"-"`
}

func (m *GBR_QosInformation) Reset()         { *m = GBR_QosInformation{} }
func (m *GBR_QosInformation) String() string { return proto.CompactTextString(m) }
func (*GBR_QosInformation) ProtoMessage()    {}
func (*GBR_QosInformation) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{6}
}

func (m *GBR_QosInformation) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GBR_QosInformation.Unmarshal(m, b)
}
func (m *GBR_QosInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GBR_QosInformation.Marshal(b, m, deterministic)
}
func (m *GBR_QosInformation) XXX_Merge(src proto.Message) {
        xxx_messageInfo_GBR_QosInformation.Merge(m, src)
}
func (m *GBR_QosInformation) XXX_Size() int {
        return xxx_messageInfo_GBR_QosInformation.Size(m)
}
func (m *GBR_QosInformation) XXX_DiscardUnknown() {
        xxx_messageInfo_GBR_QosInformation.DiscardUnknown(m)
}

var xxx_messageInfo_GBR_QosInformation proto.InternalMessageInfo

func (m *GBR_QosInformation) GetE_RAB_MaximumBitrateDL() uint64 {
        if m != nil {
                return m.E_RAB_MaximumBitrateDL
        }
        return 0
}

func (m *GBR_QosInformation) GetE_RAB_MaximumBitrateUL() uint64 {
        if m != nil {
                return m.E_RAB_MaximumBitrateUL
        }
        return 0
}

func (m *GBR_QosInformation) GetE_RAB_GuaranteedBitrateDL() uint64 {
        if m != nil {
                return m.E_RAB_GuaranteedBitrateDL
        }
        return 0
}

func (m *GBR_QosInformation) GetE_RAB_GuaranteedBitrateUL() uint64 {
        if m != nil {
                return m.E_RAB_GuaranteedBitrateUL
        }
        return 0
}

func (m *GBR_QosInformation) GetIE_Extensions() []*GBR_QosInformation_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type GBR_QosInformation_ExtIEs struct {
        IdExtendedE_RAB_MaximumBitrateDL    *wrappers.UInt64Value `protobuf:"bytes,1,opt,name=id_extended_e_RAB_MaximumBitrateDL,json=idExtendedERABMaximumBitrateDL,proto3" json:"id_extended_e_RAB_MaximumBitrateDL,omitempty"`
        IdExtendedE_RAB_MaximumBitrateUL    *wrappers.UInt64Value `protobuf:"bytes,2,opt,name=id_extended_e_RAB_MaximumBitrateUL,json=idExtendedERABMaximumBitrateUL,proto3" json:"id_extended_e_RAB_MaximumBitrateUL,omitempty"`
        IdExtendedE_RAB_GuaranteedBitrateDL *wrappers.UInt64Value `protobuf:"bytes,3,opt,name=id_extended_e_RAB_GuaranteedBitrateDL,json=idExtendedERABGuaranteedBitrateDL,proto3" json:"id_extended_e_RAB_GuaranteedBitrateDL,omitempty"`
        IdExtendedE_RAB_GuaranteedBitrateUL *wrappers.UInt64Value `protobuf:"bytes,4,opt,name=id_extended_e_RAB_GuaranteedBitrateUL,json=idExtendedERABGuaranteedBitrateUL,proto3" json:"id_extended_e_RAB_GuaranteedBitrateUL,omitempty"`
        XXX_NoUnkeyedLiteral                struct{}              `json:"-"`
        XXX_unrecognized                    []byte                `json:"-"`
        XXX_sizecache                       int32                 `json:"-"`
}

func (m *GBR_QosInformation_ExtIEs) Reset()         { *m = GBR_QosInformation_ExtIEs{} }
func (m *GBR_QosInformation_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*GBR_QosInformation_ExtIEs) ProtoMessage()    {}
func (*GBR_QosInformation_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{7}
}

func (m *GBR_QosInformation_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GBR_QosInformation_ExtIEs.Unmarshal(m, b)
}
func (m *GBR_QosInformation_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GBR_QosInformation_ExtIEs.Marshal(b, m, deterministic)
}
func (m *GBR_QosInformation_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_GBR_QosInformation_ExtIEs.Merge(m, src)
}
func (m *GBR_QosInformation_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_GBR_QosInformation_ExtIEs.Size(m)
}
func (m *GBR_QosInformation_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_GBR_QosInformation_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_GBR_QosInformation_ExtIEs proto.InternalMessageInfo

func (m *GBR_QosInformation_ExtIEs) GetIdExtendedE_RAB_MaximumBitrateDL() *wrappers.UInt64Value {
        if m != nil {
                return m.IdExtendedE_RAB_MaximumBitrateDL
        }
        return nil
}

func (m *GBR_QosInformation_ExtIEs) GetIdExtendedE_RAB_MaximumBitrateUL() *wrappers.UInt64Value {
        if m != nil {
                return m.IdExtendedE_RAB_MaximumBitrateUL
        }
        return nil
}

func (m *GBR_QosInformation_ExtIEs) GetIdExtendedE_RAB_GuaranteedBitrateDL() *wrappers.UInt64Value {
        if m != nil {
                return m.IdExtendedE_RAB_GuaranteedBitrateDL
        }
        return nil
}

func (m *GBR_QosInformation_ExtIEs) GetIdExtendedE_RAB_GuaranteedBitrateUL() *wrappers.UInt64Value {
        if m != nil {
                return m.IdExtendedE_RAB_GuaranteedBitrateUL
        }
        return nil
}

type GlobalGNB_ID struct {
        PLMN_Identity        []byte                 `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"`
        GNB_ID               *GNB_ID                `protobuf:"bytes,2,opt,name=gNB_ID,json=gNBID,proto3" json:"gNB_ID,omitempty"`
        IE_Extensions        []*GlobalGNB_ID_ExtIEs `protobuf:"bytes,3,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral struct{}               `json:"-"`
        XXX_unrecognized     []byte                 `json:"-"`
        XXX_sizecache        int32                  `json:"-"`
}

func (m *GlobalGNB_ID) Reset()         { *m = GlobalGNB_ID{} }
func (m *GlobalGNB_ID) String() string { return proto.CompactTextString(m) }
func (*GlobalGNB_ID) ProtoMessage()    {}
func (*GlobalGNB_ID) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{8}
}

func (m *GlobalGNB_ID) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GlobalGNB_ID.Unmarshal(m, b)
}
func (m *GlobalGNB_ID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GlobalGNB_ID.Marshal(b, m, deterministic)
}
func (m *GlobalGNB_ID) XXX_Merge(src proto.Message) {
        xxx_messageInfo_GlobalGNB_ID.Merge(m, src)
}
func (m *GlobalGNB_ID) XXX_Size() int {
        return xxx_messageInfo_GlobalGNB_ID.Size(m)
}
func (m *GlobalGNB_ID) XXX_DiscardUnknown() {
        xxx_messageInfo_GlobalGNB_ID.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalGNB_ID proto.InternalMessageInfo

func (m *GlobalGNB_ID) GetPLMN_Identity() []byte {
        if m != nil {
                return m.PLMN_Identity
        }
        return nil
}

func (m *GlobalGNB_ID) GetGNB_ID() *GNB_ID {
        if m != nil {
                return m.GNB_ID
        }
        return nil
}

func (m *GlobalGNB_ID) GetIE_Extensions() []*GlobalGNB_ID_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type GNB_ID struct {
        // Types that are valid to be assigned to C:
        //      *GNB_ID_GNB_ID
        C                    isGNB_ID_C `protobuf_oneof:"c"`
        XXX_NoUnkeyedLiteral struct{}   `json:"-"`
        XXX_unrecognized     []byte     `json:"-"`
        XXX_sizecache        int32      `json:"-"`
}

func (m *GNB_ID) Reset()         { *m = GNB_ID{} }
func (m *GNB_ID) String() string { return proto.CompactTextString(m) }
func (*GNB_ID) ProtoMessage()    {}
func (*GNB_ID) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{9}
}

func (m *GNB_ID) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GNB_ID.Unmarshal(m, b)
}
func (m *GNB_ID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GNB_ID.Marshal(b, m, deterministic)
}
func (m *GNB_ID) XXX_Merge(src proto.Message) {
        xxx_messageInfo_GNB_ID.Merge(m, src)
}
func (m *GNB_ID) XXX_Size() int {
        return xxx_messageInfo_GNB_ID.Size(m)
}
func (m *GNB_ID) XXX_DiscardUnknown() {
        xxx_messageInfo_GNB_ID.DiscardUnknown(m)
}

var xxx_messageInfo_GNB_ID proto.InternalMessageInfo

type isGNB_ID_C interface {
        isGNB_ID_C()
}

type GNB_ID_GNB_ID struct {
        GNB_ID []byte `protobuf:"bytes,1,opt,name=gNB_ID,json=gNBID,proto3,oneof"`
}

func (*GNB_ID_GNB_ID) isGNB_ID_C() {}

func (m *GNB_ID) GetC() isGNB_ID_C {
        if m != nil {
                return m.C
        }
        return nil
}

func (m *GNB_ID) GetGNB_ID() []byte {
        if x, ok := m.GetC().(*GNB_ID_GNB_ID); ok {
                return x.GNB_ID
        }
        return nil
}

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

type GlobalGNB_ID_ExtIEs struct {
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *GlobalGNB_ID_ExtIEs) Reset()         { *m = GlobalGNB_ID_ExtIEs{} }
func (m *GlobalGNB_ID_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*GlobalGNB_ID_ExtIEs) ProtoMessage()    {}
func (*GlobalGNB_ID_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{10}
}

func (m *GlobalGNB_ID_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GlobalGNB_ID_ExtIEs.Unmarshal(m, b)
}
func (m *GlobalGNB_ID_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GlobalGNB_ID_ExtIEs.Marshal(b, m, deterministic)
}
func (m *GlobalGNB_ID_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_GlobalGNB_ID_ExtIEs.Merge(m, src)
}
func (m *GlobalGNB_ID_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_GlobalGNB_ID_ExtIEs.Size(m)
}
func (m *GlobalGNB_ID_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_GlobalGNB_ID_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_GlobalGNB_ID_ExtIEs proto.InternalMessageInfo

type GTPtunnelEndpoint struct {
        TransportLayerAddress []byte                      `protobuf:"bytes,1,opt,name=transportLayerAddress,proto3" json:"transportLayerAddress,omitempty"`
        GTP_TEID              []byte                      `protobuf:"bytes,2,opt,name=gTP_TEID,json=gTPTEID,proto3" json:"gTP_TEID,omitempty"`
        IE_Extensions         []*GTPtunnelEndpoint_ExtIEs `protobuf:"bytes,3,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral  struct{}                    `json:"-"`
        XXX_unrecognized      []byte                      `json:"-"`
        XXX_sizecache         int32                       `json:"-"`
}

func (m *GTPtunnelEndpoint) Reset()         { *m = GTPtunnelEndpoint{} }
func (m *GTPtunnelEndpoint) String() string { return proto.CompactTextString(m) }
func (*GTPtunnelEndpoint) ProtoMessage()    {}
func (*GTPtunnelEndpoint) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{11}
}

func (m *GTPtunnelEndpoint) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GTPtunnelEndpoint.Unmarshal(m, b)
}
func (m *GTPtunnelEndpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GTPtunnelEndpoint.Marshal(b, m, deterministic)
}
func (m *GTPtunnelEndpoint) XXX_Merge(src proto.Message) {
        xxx_messageInfo_GTPtunnelEndpoint.Merge(m, src)
}
func (m *GTPtunnelEndpoint) XXX_Size() int {
        return xxx_messageInfo_GTPtunnelEndpoint.Size(m)
}
func (m *GTPtunnelEndpoint) XXX_DiscardUnknown() {
        xxx_messageInfo_GTPtunnelEndpoint.DiscardUnknown(m)
}

var xxx_messageInfo_GTPtunnelEndpoint proto.InternalMessageInfo

func (m *GTPtunnelEndpoint) GetTransportLayerAddress() []byte {
        if m != nil {
                return m.TransportLayerAddress
        }
        return nil
}

func (m *GTPtunnelEndpoint) GetGTP_TEID() []byte {
        if m != nil {
                return m.GTP_TEID
        }
        return nil
}

func (m *GTPtunnelEndpoint) GetIE_Extensions() []*GTPtunnelEndpoint_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type GTPtunnelEndpoint_ExtIEs struct {
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *GTPtunnelEndpoint_ExtIEs) Reset()         { *m = GTPtunnelEndpoint_ExtIEs{} }
func (m *GTPtunnelEndpoint_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*GTPtunnelEndpoint_ExtIEs) ProtoMessage()    {}
func (*GTPtunnelEndpoint_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{12}
}

func (m *GTPtunnelEndpoint_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.Unmarshal(m, b)
}
func (m *GTPtunnelEndpoint_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.Marshal(b, m, deterministic)
}
func (m *GTPtunnelEndpoint_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.Merge(m, src)
}
func (m *GTPtunnelEndpoint_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.Size(m)
}
func (m *GTPtunnelEndpoint_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_GTPtunnelEndpoint_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_GTPtunnelEndpoint_ExtIEs proto.InternalMessageInfo

type RLCMode struct {
        Value                RLCMode_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.RLCMode_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}      `json:"-"`
        XXX_unrecognized     []byte        `json:"-"`
        XXX_sizecache        int32         `json:"-"`
}

func (m *RLCMode) Reset()         { *m = RLCMode{} }
func (m *RLCMode) String() string { return proto.CompactTextString(m) }
func (*RLCMode) ProtoMessage()    {}
func (*RLCMode) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{13}
}

func (m *RLCMode) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_RLCMode.Unmarshal(m, b)
}
func (m *RLCMode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_RLCMode.Marshal(b, m, deterministic)
}
func (m *RLCMode) XXX_Merge(src proto.Message) {
        xxx_messageInfo_RLCMode.Merge(m, src)
}
func (m *RLCMode) XXX_Size() int {
        return xxx_messageInfo_RLCMode.Size(m)
}
func (m *RLCMode) XXX_DiscardUnknown() {
        xxx_messageInfo_RLCMode.DiscardUnknown(m)
}

var xxx_messageInfo_RLCMode proto.InternalMessageInfo

func (m *RLCMode) GetValue() RLCMode_Value {
        if m != nil {
                return m.Value
        }
        return RLCMode_protobuf_unspecified
}

type RLC_Status struct {
        Reestablishment_Indication RLC_Status_Reestablishment_Indication `protobuf:"varint,1,opt,name=reestablishment_Indication,json=reestablishmentIndication,proto3,enum=streaming_protobufs.RLC_Status_Reestablishment_Indication" json:"reestablishment_Indication,omitempty"`
        XXX_NoUnkeyedLiteral       struct{}                              `json:"-"`
        XXX_unrecognized           []byte                                `json:"-"`
        XXX_sizecache              int32                                 `json:"-"`
}

func (m *RLC_Status) Reset()         { *m = RLC_Status{} }
func (m *RLC_Status) String() string { return proto.CompactTextString(m) }
func (*RLC_Status) ProtoMessage()    {}
func (*RLC_Status) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{14}
}

func (m *RLC_Status) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_RLC_Status.Unmarshal(m, b)
}
func (m *RLC_Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_RLC_Status.Marshal(b, m, deterministic)
}
func (m *RLC_Status) XXX_Merge(src proto.Message) {
        xxx_messageInfo_RLC_Status.Merge(m, src)
}
func (m *RLC_Status) XXX_Size() int {
        return xxx_messageInfo_RLC_Status.Size(m)
}
func (m *RLC_Status) XXX_DiscardUnknown() {
        xxx_messageInfo_RLC_Status.DiscardUnknown(m)
}

var xxx_messageInfo_RLC_Status proto.InternalMessageInfo

func (m *RLC_Status) GetReestablishment_Indication() RLC_Status_Reestablishment_Indication {
        if m != nil {
                return m.Reestablishment_Indication
        }
        return RLC_Status_protobuf_unspecified
}

type ULConfiguration struct {
        UL_PDCP              ULConfiguration_UL_UE_Configuration `protobuf:"varint,1,opt,name=uL_PDCP,json=uLPDCP,proto3,enum=streaming_protobufs.ULConfiguration_UL_UE_Configuration" json:"uL_PDCP,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
        XXX_unrecognized     []byte                              `json:"-"`
        XXX_sizecache        int32                               `json:"-"`
}

func (m *ULConfiguration) Reset()         { *m = ULConfiguration{} }
func (m *ULConfiguration) String() string { return proto.CompactTextString(m) }
func (*ULConfiguration) ProtoMessage()    {}
func (*ULConfiguration) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{15}
}

func (m *ULConfiguration) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ULConfiguration.Unmarshal(m, b)
}
func (m *ULConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ULConfiguration.Marshal(b, m, deterministic)
}
func (m *ULConfiguration) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ULConfiguration.Merge(m, src)
}
func (m *ULConfiguration) XXX_Size() int {
        return xxx_messageInfo_ULConfiguration.Size(m)
}
func (m *ULConfiguration) XXX_DiscardUnknown() {
        xxx_messageInfo_ULConfiguration.DiscardUnknown(m)
}

var xxx_messageInfo_ULConfiguration proto.InternalMessageInfo

func (m *ULConfiguration) GetUL_PDCP() ULConfiguration_UL_UE_Configuration {
        if m != nil {
                return m.UL_PDCP
        }
        return ULConfiguration_protobuf_unspecified
}

type PDCPSnLength struct {
        Value                PDCPSnLength_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.PDCPSnLength_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}           `json:"-"`
        XXX_unrecognized     []byte             `json:"-"`
        XXX_sizecache        int32              `json:"-"`
}

func (m *PDCPSnLength) Reset()         { *m = PDCPSnLength{} }
func (m *PDCPSnLength) String() string { return proto.CompactTextString(m) }
func (*PDCPSnLength) ProtoMessage()    {}
func (*PDCPSnLength) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{16}
}

func (m *PDCPSnLength) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PDCPSnLength.Unmarshal(m, b)
}
func (m *PDCPSnLength) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PDCPSnLength.Marshal(b, m, deterministic)
}
func (m *PDCPSnLength) XXX_Merge(src proto.Message) {
        xxx_messageInfo_PDCPSnLength.Merge(m, src)
}
func (m *PDCPSnLength) XXX_Size() int {
        return xxx_messageInfo_PDCPSnLength.Size(m)
}
func (m *PDCPSnLength) XXX_DiscardUnknown() {
        xxx_messageInfo_PDCPSnLength.DiscardUnknown(m)
}

var xxx_messageInfo_PDCPSnLength proto.InternalMessageInfo

func (m *PDCPSnLength) GetValue() PDCPSnLength_Value {
        if m != nil {
                return m.Value
        }
        return PDCPSnLength_protobuf_unspecified
}

type PDCPChangeIndication struct {
        Value                PDCPChangeIndication_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.PDCPChangeIndication_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
        XXX_unrecognized     []byte                     `json:"-"`
        XXX_sizecache        int32                      `json:"-"`
}

func (m *PDCPChangeIndication) Reset()         { *m = PDCPChangeIndication{} }
func (m *PDCPChangeIndication) String() string { return proto.CompactTextString(m) }
func (*PDCPChangeIndication) ProtoMessage()    {}
func (*PDCPChangeIndication) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{17}
}

func (m *PDCPChangeIndication) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_PDCPChangeIndication.Unmarshal(m, b)
}
func (m *PDCPChangeIndication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_PDCPChangeIndication.Marshal(b, m, deterministic)
}
func (m *PDCPChangeIndication) XXX_Merge(src proto.Message) {
        xxx_messageInfo_PDCPChangeIndication.Merge(m, src)
}
func (m *PDCPChangeIndication) XXX_Size() int {
        return xxx_messageInfo_PDCPChangeIndication.Size(m)
}
func (m *PDCPChangeIndication) XXX_DiscardUnknown() {
        xxx_messageInfo_PDCPChangeIndication.DiscardUnknown(m)
}

var xxx_messageInfo_PDCPChangeIndication proto.InternalMessageInfo

func (m *PDCPChangeIndication) GetValue() PDCPChangeIndication_Value {
        if m != nil {
                return m.Value
        }
        return PDCPChangeIndication_protobuf_unspecified
}

type SplitSRBs struct {
        Value                SplitSRBs_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.SplitSRBs_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
        XXX_unrecognized     []byte          `json:"-"`
        XXX_sizecache        int32           `json:"-"`
}

func (m *SplitSRBs) Reset()         { *m = SplitSRBs{} }
func (m *SplitSRBs) String() string { return proto.CompactTextString(m) }
func (*SplitSRBs) ProtoMessage()    {}
func (*SplitSRBs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{18}
}

func (m *SplitSRBs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_SplitSRBs.Unmarshal(m, b)
}
func (m *SplitSRBs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_SplitSRBs.Marshal(b, m, deterministic)
}
func (m *SplitSRBs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_SplitSRBs.Merge(m, src)
}
func (m *SplitSRBs) XXX_Size() int {
        return xxx_messageInfo_SplitSRBs.Size(m)
}
func (m *SplitSRBs) XXX_DiscardUnknown() {
        xxx_messageInfo_SplitSRBs.DiscardUnknown(m)
}

var xxx_messageInfo_SplitSRBs proto.InternalMessageInfo

func (m *SplitSRBs) GetValue() SplitSRBs_Value {
        if m != nil {
                return m.Value
        }
        return SplitSRBs_protobuf_unspecified
}

type NRCGI struct {
        PLMN_Identity        []byte          `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"`
        NRcellIdentifier     []byte          `protobuf:"bytes,2,opt,name=nRcellIdentifier,proto3" json:"nRcellIdentifier,omitempty"`
        IE_Extensions        []*NRCGI_ExtIEs `protobuf:"bytes,3,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral struct{}        `json:"-"`
        XXX_unrecognized     []byte          `json:"-"`
        XXX_sizecache        int32           `json:"-"`
}

func (m *NRCGI) Reset()         { *m = NRCGI{} }
func (m *NRCGI) String() string { return proto.CompactTextString(m) }
func (*NRCGI) ProtoMessage()    {}
func (*NRCGI) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{19}
}

func (m *NRCGI) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_NRCGI.Unmarshal(m, b)
}
func (m *NRCGI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_NRCGI.Marshal(b, m, deterministic)
}
func (m *NRCGI) XXX_Merge(src proto.Message) {
        xxx_messageInfo_NRCGI.Merge(m, src)
}
func (m *NRCGI) XXX_Size() int {
        return xxx_messageInfo_NRCGI.Size(m)
}
func (m *NRCGI) XXX_DiscardUnknown() {
        xxx_messageInfo_NRCGI.DiscardUnknown(m)
}

var xxx_messageInfo_NRCGI proto.InternalMessageInfo

func (m *NRCGI) GetPLMN_Identity() []byte {
        if m != nil {
                return m.PLMN_Identity
        }
        return nil
}

func (m *NRCGI) GetNRcellIdentifier() []byte {
        if m != nil {
                return m.NRcellIdentifier
        }
        return nil
}

func (m *NRCGI) GetIE_Extensions() []*NRCGI_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type NRCGI_ExtIEs struct {
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *NRCGI_ExtIEs) Reset()         { *m = NRCGI_ExtIEs{} }
func (m *NRCGI_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*NRCGI_ExtIEs) ProtoMessage()    {}
func (*NRCGI_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{20}
}

func (m *NRCGI_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_NRCGI_ExtIEs.Unmarshal(m, b)
}
func (m *NRCGI_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_NRCGI_ExtIEs.Marshal(b, m, deterministic)
}
func (m *NRCGI_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_NRCGI_ExtIEs.Merge(m, src)
}
func (m *NRCGI_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_NRCGI_ExtIEs.Size(m)
}
func (m *NRCGI_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_NRCGI_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_NRCGI_ExtIEs proto.InternalMessageInfo

type ECGI struct {
        PLMN_Identity        []byte   `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"`
        EUTRANcellIdentifier []byte   `protobuf:"bytes,2,opt,name=eUTRANcellIdentifier,proto3" json:"eUTRANcellIdentifier,omitempty"`
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *ECGI) Reset()         { *m = ECGI{} }
func (m *ECGI) String() string { return proto.CompactTextString(m) }
func (*ECGI) ProtoMessage()    {}
func (*ECGI) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{21}
}

func (m *ECGI) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ECGI.Unmarshal(m, b)
}
func (m *ECGI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ECGI.Marshal(b, m, deterministic)
}
func (m *ECGI) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ECGI.Merge(m, src)
}
func (m *ECGI) XXX_Size() int {
        return xxx_messageInfo_ECGI.Size(m)
}
func (m *ECGI) XXX_DiscardUnknown() {
        xxx_messageInfo_ECGI.DiscardUnknown(m)
}

var xxx_messageInfo_ECGI proto.InternalMessageInfo

func (m *ECGI) GetPLMN_Identity() []byte {
        if m != nil {
                return m.PLMN_Identity
        }
        return nil
}

func (m *ECGI) GetEUTRANcellIdentifier() []byte {
        if m != nil {
                return m.EUTRANcellIdentifier
        }
        return nil
}

type E_RAB_List struct {
        Items                []*E_RAB_ItemIEs `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
        XXX_NoUnkeyedLiteral struct{}         `json:"-"`
        XXX_unrecognized     []byte           `json:"-"`
        XXX_sizecache        int32            `json:"-"`
}

func (m *E_RAB_List) Reset()         { *m = E_RAB_List{} }
func (m *E_RAB_List) String() string { return proto.CompactTextString(m) }
func (*E_RAB_List) ProtoMessage()    {}
func (*E_RAB_List) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{22}
}

func (m *E_RAB_List) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_E_RAB_List.Unmarshal(m, b)
}
func (m *E_RAB_List) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_E_RAB_List.Marshal(b, m, deterministic)
}
func (m *E_RAB_List) XXX_Merge(src proto.Message) {
        xxx_messageInfo_E_RAB_List.Merge(m, src)
}
func (m *E_RAB_List) XXX_Size() int {
        return xxx_messageInfo_E_RAB_List.Size(m)
}
func (m *E_RAB_List) XXX_DiscardUnknown() {
        xxx_messageInfo_E_RAB_List.DiscardUnknown(m)
}

var xxx_messageInfo_E_RAB_List proto.InternalMessageInfo

func (m *E_RAB_List) GetItems() []*E_RAB_ItemIEs {
        if m != nil {
                return m.Items
        }
        return nil
}

type E_RAB_ItemIEs struct {
        Id_E_RAB_Item        *E_RAB_Item `protobuf:"bytes,1,opt,name=id_E_RAB_Item,json=idERABItem,proto3" json:"id_E_RAB_Item,omitempty"`
        XXX_NoUnkeyedLiteral struct{}    `json:"-"`
        XXX_unrecognized     []byte      `json:"-"`
        XXX_sizecache        int32       `json:"-"`
}

func (m *E_RAB_ItemIEs) Reset()         { *m = E_RAB_ItemIEs{} }
func (m *E_RAB_ItemIEs) String() string { return proto.CompactTextString(m) }
func (*E_RAB_ItemIEs) ProtoMessage()    {}
func (*E_RAB_ItemIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{23}
}

func (m *E_RAB_ItemIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_E_RAB_ItemIEs.Unmarshal(m, b)
}
func (m *E_RAB_ItemIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_E_RAB_ItemIEs.Marshal(b, m, deterministic)
}
func (m *E_RAB_ItemIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_E_RAB_ItemIEs.Merge(m, src)
}
func (m *E_RAB_ItemIEs) XXX_Size() int {
        return xxx_messageInfo_E_RAB_ItemIEs.Size(m)
}
func (m *E_RAB_ItemIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_E_RAB_ItemIEs.DiscardUnknown(m)
}

var xxx_messageInfo_E_RAB_ItemIEs proto.InternalMessageInfo

func (m *E_RAB_ItemIEs) GetId_E_RAB_Item() *E_RAB_Item {
        if m != nil {
                return m.Id_E_RAB_Item
        }
        return nil
}

type E_RAB_Item struct {
        E_RAB_ID             uint32   `protobuf:"varint,1,opt,name=e_RAB_ID,json=eRABID,proto3" json:"e_RAB_ID,omitempty"`
        Cause                *Cause   `protobuf:"bytes,2,opt,name=cause,proto3" json:"cause,omitempty"`
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *E_RAB_Item) Reset()         { *m = E_RAB_Item{} }
func (m *E_RAB_Item) String() string { return proto.CompactTextString(m) }
func (*E_RAB_Item) ProtoMessage()    {}
func (*E_RAB_Item) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{24}
}

func (m *E_RAB_Item) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_E_RAB_Item.Unmarshal(m, b)
}
func (m *E_RAB_Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_E_RAB_Item.Marshal(b, m, deterministic)
}
func (m *E_RAB_Item) XXX_Merge(src proto.Message) {
        xxx_messageInfo_E_RAB_Item.Merge(m, src)
}
func (m *E_RAB_Item) XXX_Size() int {
        return xxx_messageInfo_E_RAB_Item.Size(m)
}
func (m *E_RAB_Item) XXX_DiscardUnknown() {
        xxx_messageInfo_E_RAB_Item.DiscardUnknown(m)
}

var xxx_messageInfo_E_RAB_Item proto.InternalMessageInfo

func (m *E_RAB_Item) GetE_RAB_ID() uint32 {
        if m != nil {
                return m.E_RAB_ID
        }
        return 0
}

func (m *E_RAB_Item) GetCause() *Cause {
        if m != nil {
                return m.Cause
        }
        return nil
}

type ERABActivityNotifyItemList struct {
        Items                []*ERABActivityNotifyItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
        XXX_unrecognized     []byte                    `json:"-"`
        XXX_sizecache        int32                     `json:"-"`
}

func (m *ERABActivityNotifyItemList) Reset()         { *m = ERABActivityNotifyItemList{} }
func (m *ERABActivityNotifyItemList) String() string { return proto.CompactTextString(m) }
func (*ERABActivityNotifyItemList) ProtoMessage()    {}
func (*ERABActivityNotifyItemList) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{25}
}

func (m *ERABActivityNotifyItemList) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ERABActivityNotifyItemList.Unmarshal(m, b)
}
func (m *ERABActivityNotifyItemList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ERABActivityNotifyItemList.Marshal(b, m, deterministic)
}
func (m *ERABActivityNotifyItemList) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ERABActivityNotifyItemList.Merge(m, src)
}
func (m *ERABActivityNotifyItemList) XXX_Size() int {
        return xxx_messageInfo_ERABActivityNotifyItemList.Size(m)
}
func (m *ERABActivityNotifyItemList) XXX_DiscardUnknown() {
        xxx_messageInfo_ERABActivityNotifyItemList.DiscardUnknown(m)
}

var xxx_messageInfo_ERABActivityNotifyItemList proto.InternalMessageInfo

func (m *ERABActivityNotifyItemList) GetItems() []*ERABActivityNotifyItem {
        if m != nil {
                return m.Items
        }
        return nil
}

type ERABActivityNotifyItem struct {
        E_RAB_ID             uint32                          `protobuf:"varint,1,opt,name=e_RAB_ID,json=eRABID,proto3" json:"e_RAB_ID,omitempty"`
        ActivityReport       *UserPlaneTrafficActivityReport `protobuf:"bytes,2,opt,name=activityReport,proto3" json:"activityReport,omitempty"`
        IE_Extensions        *ERABActivityNotifyItem_ExtIEs  `protobuf:"bytes,3,opt,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
        XXX_unrecognized     []byte                          `json:"-"`
        XXX_sizecache        int32                           `json:"-"`
}

func (m *ERABActivityNotifyItem) Reset()         { *m = ERABActivityNotifyItem{} }
func (m *ERABActivityNotifyItem) String() string { return proto.CompactTextString(m) }
func (*ERABActivityNotifyItem) ProtoMessage()    {}
func (*ERABActivityNotifyItem) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{26}
}

func (m *ERABActivityNotifyItem) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ERABActivityNotifyItem.Unmarshal(m, b)
}
func (m *ERABActivityNotifyItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ERABActivityNotifyItem.Marshal(b, m, deterministic)
}
func (m *ERABActivityNotifyItem) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ERABActivityNotifyItem.Merge(m, src)
}
func (m *ERABActivityNotifyItem) XXX_Size() int {
        return xxx_messageInfo_ERABActivityNotifyItem.Size(m)
}
func (m *ERABActivityNotifyItem) XXX_DiscardUnknown() {
        xxx_messageInfo_ERABActivityNotifyItem.DiscardUnknown(m)
}

var xxx_messageInfo_ERABActivityNotifyItem proto.InternalMessageInfo

func (m *ERABActivityNotifyItem) GetE_RAB_ID() uint32 {
        if m != nil {
                return m.E_RAB_ID
        }
        return 0
}

func (m *ERABActivityNotifyItem) GetActivityReport() *UserPlaneTrafficActivityReport {
        if m != nil {
                return m.ActivityReport
        }
        return nil
}

func (m *ERABActivityNotifyItem) GetIE_Extensions() *ERABActivityNotifyItem_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type ERABActivityNotifyItem_ExtIEs struct {
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *ERABActivityNotifyItem_ExtIEs) Reset()         { *m = ERABActivityNotifyItem_ExtIEs{} }
func (m *ERABActivityNotifyItem_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*ERABActivityNotifyItem_ExtIEs) ProtoMessage()    {}
func (*ERABActivityNotifyItem_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{27}
}

func (m *ERABActivityNotifyItem_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.Unmarshal(m, b)
}
func (m *ERABActivityNotifyItem_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.Marshal(b, m, deterministic)
}
func (m *ERABActivityNotifyItem_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.Merge(m, src)
}
func (m *ERABActivityNotifyItem_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.Size(m)
}
func (m *ERABActivityNotifyItem_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_ERABActivityNotifyItem_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_ERABActivityNotifyItem_ExtIEs proto.InternalMessageInfo

type UserPlaneTrafficActivityReport struct {
        Value                UserPlaneTrafficActivityReport_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.UserPlaneTrafficActivityReport_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
        XXX_unrecognized     []byte                               `json:"-"`
        XXX_sizecache        int32                                `json:"-"`
}

func (m *UserPlaneTrafficActivityReport) Reset()         { *m = UserPlaneTrafficActivityReport{} }
func (m *UserPlaneTrafficActivityReport) String() string { return proto.CompactTextString(m) }
func (*UserPlaneTrafficActivityReport) ProtoMessage()    {}
func (*UserPlaneTrafficActivityReport) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{28}
}

func (m *UserPlaneTrafficActivityReport) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_UserPlaneTrafficActivityReport.Unmarshal(m, b)
}
func (m *UserPlaneTrafficActivityReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_UserPlaneTrafficActivityReport.Marshal(b, m, deterministic)
}
func (m *UserPlaneTrafficActivityReport) XXX_Merge(src proto.Message) {
        xxx_messageInfo_UserPlaneTrafficActivityReport.Merge(m, src)
}
func (m *UserPlaneTrafficActivityReport) XXX_Size() int {
        return xxx_messageInfo_UserPlaneTrafficActivityReport.Size(m)
}
func (m *UserPlaneTrafficActivityReport) XXX_DiscardUnknown() {
        xxx_messageInfo_UserPlaneTrafficActivityReport.DiscardUnknown(m)
}

var xxx_messageInfo_UserPlaneTrafficActivityReport proto.InternalMessageInfo

func (m *UserPlaneTrafficActivityReport) GetValue() UserPlaneTrafficActivityReport_Value {
        if m != nil {
                return m.Value
        }
        return UserPlaneTrafficActivityReport_protobuf_unspecified
}

type GNBOverloadInformation struct {
        Value                GNBOverloadInformation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.GNBOverloadInformation_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
        XXX_unrecognized     []byte                       `json:"-"`
        XXX_sizecache        int32                        `json:"-"`
}

func (m *GNBOverloadInformation) Reset()         { *m = GNBOverloadInformation{} }
func (m *GNBOverloadInformation) String() string { return proto.CompactTextString(m) }
func (*GNBOverloadInformation) ProtoMessage()    {}
func (*GNBOverloadInformation) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{29}
}

func (m *GNBOverloadInformation) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_GNBOverloadInformation.Unmarshal(m, b)
}
func (m *GNBOverloadInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_GNBOverloadInformation.Marshal(b, m, deterministic)
}
func (m *GNBOverloadInformation) XXX_Merge(src proto.Message) {
        xxx_messageInfo_GNBOverloadInformation.Merge(m, src)
}
func (m *GNBOverloadInformation) XXX_Size() int {
        return xxx_messageInfo_GNBOverloadInformation.Size(m)
}
func (m *GNBOverloadInformation) XXX_DiscardUnknown() {
        xxx_messageInfo_GNBOverloadInformation.DiscardUnknown(m)
}

var xxx_messageInfo_GNBOverloadInformation proto.InternalMessageInfo

func (m *GNBOverloadInformation) GetValue() GNBOverloadInformation_Value {
        if m != nil {
                return m.Value
        }
        return GNBOverloadInformation_protobuf_unspecified
}

type CriticalityDiagnostics struct {
        ProcedureCode             *wrappers.UInt32Value            `protobuf:"bytes,1,opt,name=procedureCode,proto3" json:"procedureCode,omitempty"`
        TriggeringMessage         *TriggeringMessage               `protobuf:"bytes,2,opt,name=triggeringMessage,proto3" json:"triggeringMessage,omitempty"`
        ProcedureCriticality      *Criticality                     `protobuf:"bytes,3,opt,name=procedureCriticality,proto3" json:"procedureCriticality,omitempty"`
        IEsCriticalityDiagnostics *CriticalityDiagnostics_IE_List  `protobuf:"bytes,4,opt,name=iEsCriticalityDiagnostics,proto3" json:"iEsCriticalityDiagnostics,omitempty"`
        IE_Extensions             []*CriticalityDiagnostics_ExtIEs `protobuf:"bytes,5,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral      struct{}                         `json:"-"`
        XXX_unrecognized          []byte                           `json:"-"`
        XXX_sizecache             int32                            `json:"-"`
}

func (m *CriticalityDiagnostics) Reset()         { *m = CriticalityDiagnostics{} }
func (m *CriticalityDiagnostics) String() string { return proto.CompactTextString(m) }
func (*CriticalityDiagnostics) ProtoMessage()    {}
func (*CriticalityDiagnostics) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{30}
}

func (m *CriticalityDiagnostics) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_CriticalityDiagnostics.Unmarshal(m, b)
}
func (m *CriticalityDiagnostics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_CriticalityDiagnostics.Marshal(b, m, deterministic)
}
func (m *CriticalityDiagnostics) XXX_Merge(src proto.Message) {
        xxx_messageInfo_CriticalityDiagnostics.Merge(m, src)
}
func (m *CriticalityDiagnostics) XXX_Size() int {
        return xxx_messageInfo_CriticalityDiagnostics.Size(m)
}
func (m *CriticalityDiagnostics) XXX_DiscardUnknown() {
        xxx_messageInfo_CriticalityDiagnostics.DiscardUnknown(m)
}

var xxx_messageInfo_CriticalityDiagnostics proto.InternalMessageInfo

func (m *CriticalityDiagnostics) GetProcedureCode() *wrappers.UInt32Value {
        if m != nil {
                return m.ProcedureCode
        }
        return nil
}

func (m *CriticalityDiagnostics) GetTriggeringMessage() *TriggeringMessage {
        if m != nil {
                return m.TriggeringMessage
        }
        return nil
}

func (m *CriticalityDiagnostics) GetProcedureCriticality() *Criticality {
        if m != nil {
                return m.ProcedureCriticality
        }
        return nil
}

func (m *CriticalityDiagnostics) GetIEsCriticalityDiagnostics() *CriticalityDiagnostics_IE_List {
        if m != nil {
                return m.IEsCriticalityDiagnostics
        }
        return nil
}

func (m *CriticalityDiagnostics) GetIE_Extensions() []*CriticalityDiagnostics_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type TriggeringMessage struct {
        Value                TriggeringMessage_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.TriggeringMessage_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                `json:"-"`
        XXX_unrecognized     []byte                  `json:"-"`
        XXX_sizecache        int32                   `json:"-"`
}

func (m *TriggeringMessage) Reset()         { *m = TriggeringMessage{} }
func (m *TriggeringMessage) String() string { return proto.CompactTextString(m) }
func (*TriggeringMessage) ProtoMessage()    {}
func (*TriggeringMessage) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{31}
}

func (m *TriggeringMessage) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_TriggeringMessage.Unmarshal(m, b)
}
func (m *TriggeringMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_TriggeringMessage.Marshal(b, m, deterministic)
}
func (m *TriggeringMessage) XXX_Merge(src proto.Message) {
        xxx_messageInfo_TriggeringMessage.Merge(m, src)
}
func (m *TriggeringMessage) XXX_Size() int {
        return xxx_messageInfo_TriggeringMessage.Size(m)
}
func (m *TriggeringMessage) XXX_DiscardUnknown() {
        xxx_messageInfo_TriggeringMessage.DiscardUnknown(m)
}

var xxx_messageInfo_TriggeringMessage proto.InternalMessageInfo

func (m *TriggeringMessage) GetValue() TriggeringMessage_Value {
        if m != nil {
                return m.Value
        }
        return TriggeringMessage_protobuf_unspecified
}

type Criticality struct {
        Value                Criticality_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.Criticality_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
        XXX_unrecognized     []byte            `json:"-"`
        XXX_sizecache        int32             `json:"-"`
}

func (m *Criticality) Reset()         { *m = Criticality{} }
func (m *Criticality) String() string { return proto.CompactTextString(m) }
func (*Criticality) ProtoMessage()    {}
func (*Criticality) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{32}
}

func (m *Criticality) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_Criticality.Unmarshal(m, b)
}
func (m *Criticality) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_Criticality.Marshal(b, m, deterministic)
}
func (m *Criticality) XXX_Merge(src proto.Message) {
        xxx_messageInfo_Criticality.Merge(m, src)
}
func (m *Criticality) XXX_Size() int {
        return xxx_messageInfo_Criticality.Size(m)
}
func (m *Criticality) XXX_DiscardUnknown() {
        xxx_messageInfo_Criticality.DiscardUnknown(m)
}

var xxx_messageInfo_Criticality proto.InternalMessageInfo

func (m *Criticality) GetValue() Criticality_Value {
        if m != nil {
                return m.Value
        }
        return Criticality_protobuf_unspecified
}

type CriticalityDiagnostics_IE_List struct {
        Items                []*CriticalityDiagnostics_IE_List_Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
        XXX_unrecognized     []byte                                 `json:"-"`
        XXX_sizecache        int32                                  `json:"-"`
}

func (m *CriticalityDiagnostics_IE_List) Reset()         { *m = CriticalityDiagnostics_IE_List{} }
func (m *CriticalityDiagnostics_IE_List) String() string { return proto.CompactTextString(m) }
func (*CriticalityDiagnostics_IE_List) ProtoMessage()    {}
func (*CriticalityDiagnostics_IE_List) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{33}
}

func (m *CriticalityDiagnostics_IE_List) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_CriticalityDiagnostics_IE_List.Unmarshal(m, b)
}
func (m *CriticalityDiagnostics_IE_List) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_CriticalityDiagnostics_IE_List.Marshal(b, m, deterministic)
}
func (m *CriticalityDiagnostics_IE_List) XXX_Merge(src proto.Message) {
        xxx_messageInfo_CriticalityDiagnostics_IE_List.Merge(m, src)
}
func (m *CriticalityDiagnostics_IE_List) XXX_Size() int {
        return xxx_messageInfo_CriticalityDiagnostics_IE_List.Size(m)
}
func (m *CriticalityDiagnostics_IE_List) XXX_DiscardUnknown() {
        xxx_messageInfo_CriticalityDiagnostics_IE_List.DiscardUnknown(m)
}

var xxx_messageInfo_CriticalityDiagnostics_IE_List proto.InternalMessageInfo

func (m *CriticalityDiagnostics_IE_List) GetItems() []*CriticalityDiagnostics_IE_List_Item {
        if m != nil {
                return m.Items
        }
        return nil
}

type CriticalityDiagnostics_IE_List_Item struct {
        IECriticality        *Criticality `protobuf:"bytes,1,opt,name=iECriticality,proto3" json:"iECriticality,omitempty"`
        IE_ID                uint32       `protobuf:"varint,2,opt,name=iE_ID,json=iEID,proto3" json:"iE_ID,omitempty"`
        TypeOfError          *TypeOfError `protobuf:"bytes,3,opt,name=typeOfError,proto3" json:"typeOfError,omitempty"`
        XXX_NoUnkeyedLiteral struct{}     `json:"-"`
        XXX_unrecognized     []byte       `json:"-"`
        XXX_sizecache        int32        `json:"-"`
}

func (m *CriticalityDiagnostics_IE_List_Item) Reset()         { *m = CriticalityDiagnostics_IE_List_Item{} }
func (m *CriticalityDiagnostics_IE_List_Item) String() string { return proto.CompactTextString(m) }
func (*CriticalityDiagnostics_IE_List_Item) ProtoMessage()    {}
func (*CriticalityDiagnostics_IE_List_Item) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{34}
}

func (m *CriticalityDiagnostics_IE_List_Item) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.Unmarshal(m, b)
}
func (m *CriticalityDiagnostics_IE_List_Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.Marshal(b, m, deterministic)
}
func (m *CriticalityDiagnostics_IE_List_Item) XXX_Merge(src proto.Message) {
        xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.Merge(m, src)
}
func (m *CriticalityDiagnostics_IE_List_Item) XXX_Size() int {
        return xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.Size(m)
}
func (m *CriticalityDiagnostics_IE_List_Item) XXX_DiscardUnknown() {
        xxx_messageInfo_CriticalityDiagnostics_IE_List_Item.DiscardUnknown(m)
}

var xxx_messageInfo_CriticalityDiagnostics_IE_List_Item proto.InternalMessageInfo

func (m *CriticalityDiagnostics_IE_List_Item) GetIECriticality() *Criticality {
        if m != nil {
                return m.IECriticality
        }
        return nil
}

func (m *CriticalityDiagnostics_IE_List_Item) GetIE_ID() uint32 {
        if m != nil {
                return m.IE_ID
        }
        return 0
}

func (m *CriticalityDiagnostics_IE_List_Item) GetTypeOfError() *TypeOfError {
        if m != nil {
                return m.TypeOfError
        }
        return nil
}

type TypeOfError struct {
        Value                TypeOfError_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.TypeOfError_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}          `json:"-"`
        XXX_unrecognized     []byte            `json:"-"`
        XXX_sizecache        int32             `json:"-"`
}

func (m *TypeOfError) Reset()         { *m = TypeOfError{} }
func (m *TypeOfError) String() string { return proto.CompactTextString(m) }
func (*TypeOfError) ProtoMessage()    {}
func (*TypeOfError) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{35}
}

func (m *TypeOfError) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_TypeOfError.Unmarshal(m, b)
}
func (m *TypeOfError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_TypeOfError.Marshal(b, m, deterministic)
}
func (m *TypeOfError) XXX_Merge(src proto.Message) {
        xxx_messageInfo_TypeOfError.Merge(m, src)
}
func (m *TypeOfError) XXX_Size() int {
        return xxx_messageInfo_TypeOfError.Size(m)
}
func (m *TypeOfError) XXX_DiscardUnknown() {
        xxx_messageInfo_TypeOfError.DiscardUnknown(m)
}

var xxx_messageInfo_TypeOfError proto.InternalMessageInfo

func (m *TypeOfError) GetValue() TypeOfError_Value {
        if m != nil {
                return m.Value
        }
        return TypeOfError_protobuf_unspecified
}

type CriticalityDiagnostics_ExtIEs struct {
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *CriticalityDiagnostics_ExtIEs) Reset()         { *m = CriticalityDiagnostics_ExtIEs{} }
func (m *CriticalityDiagnostics_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*CriticalityDiagnostics_ExtIEs) ProtoMessage()    {}
func (*CriticalityDiagnostics_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{36}
}

func (m *CriticalityDiagnostics_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_CriticalityDiagnostics_ExtIEs.Unmarshal(m, b)
}
func (m *CriticalityDiagnostics_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_CriticalityDiagnostics_ExtIEs.Marshal(b, m, deterministic)
}
func (m *CriticalityDiagnostics_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_CriticalityDiagnostics_ExtIEs.Merge(m, src)
}
func (m *CriticalityDiagnostics_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_CriticalityDiagnostics_ExtIEs.Size(m)
}
func (m *CriticalityDiagnostics_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_CriticalityDiagnostics_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_CriticalityDiagnostics_ExtIEs proto.InternalMessageInfo

type SgNBResourceCoordinationInformation struct {
        NR_CGI                    *NRCGI                                       `protobuf:"bytes,1,opt,name=nR_CGI,json=nRCGI,proto3" json:"nR_CGI,omitempty"`
        ULCoordinationInformation []byte                                       `protobuf:"bytes,2,opt,name=uLCoordinationInformation,proto3" json:"uLCoordinationInformation,omitempty"`
        DLCoordinationInformation *wrappers.BytesValue                         `protobuf:"bytes,3,opt,name=dLCoordinationInformation,proto3" json:"dLCoordinationInformation,omitempty"`
        IE_Extensions             []*SgNBResourceCoordinationInformationExtIEs `protobuf:"bytes,4,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral      struct{}                                     `json:"-"`
        XXX_unrecognized          []byte                                       `json:"-"`
        XXX_sizecache             int32                                        `json:"-"`
}

func (m *SgNBResourceCoordinationInformation) Reset()         { *m = SgNBResourceCoordinationInformation{} }
func (m *SgNBResourceCoordinationInformation) String() string { return proto.CompactTextString(m) }
func (*SgNBResourceCoordinationInformation) ProtoMessage()    {}
func (*SgNBResourceCoordinationInformation) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{37}
}

func (m *SgNBResourceCoordinationInformation) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_SgNBResourceCoordinationInformation.Unmarshal(m, b)
}
func (m *SgNBResourceCoordinationInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_SgNBResourceCoordinationInformation.Marshal(b, m, deterministic)
}
func (m *SgNBResourceCoordinationInformation) XXX_Merge(src proto.Message) {
        xxx_messageInfo_SgNBResourceCoordinationInformation.Merge(m, src)
}
func (m *SgNBResourceCoordinationInformation) XXX_Size() int {
        return xxx_messageInfo_SgNBResourceCoordinationInformation.Size(m)
}
func (m *SgNBResourceCoordinationInformation) XXX_DiscardUnknown() {
        xxx_messageInfo_SgNBResourceCoordinationInformation.DiscardUnknown(m)
}

var xxx_messageInfo_SgNBResourceCoordinationInformation proto.InternalMessageInfo

func (m *SgNBResourceCoordinationInformation) GetNR_CGI() *NRCGI {
        if m != nil {
                return m.NR_CGI
        }
        return nil
}

func (m *SgNBResourceCoordinationInformation) GetULCoordinationInformation() []byte {
        if m != nil {
                return m.ULCoordinationInformation
        }
        return nil
}

func (m *SgNBResourceCoordinationInformation) GetDLCoordinationInformation() *wrappers.BytesValue {
        if m != nil {
                return m.DLCoordinationInformation
        }
        return nil
}

func (m *SgNBResourceCoordinationInformation) GetIE_Extensions() []*SgNBResourceCoordinationInformationExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type SgNBResourceCoordinationInformationExtIEs struct {
        Id_ECGI                                  *ECGI                                  `protobuf:"bytes,1,opt,name=id_ECGI,json=idECGI,proto3" json:"id_ECGI,omitempty"`
        Id_SgNBCoordinationAssistanceInformation *SgNBCoordinationAssistanceInformation `protobuf:"bytes,2,opt,name=id_SgNBCoordinationAssistanceInformation,json=idSgNBCoordinationAssistanceInformation,proto3" json:"id_SgNBCoordinationAssistanceInformation,omitempty"`
        XXX_NoUnkeyedLiteral                     struct{}                               `json:"-"`
        XXX_unrecognized                         []byte                                 `json:"-"`
        XXX_sizecache                            int32                                  `json:"-"`
}

func (m *SgNBResourceCoordinationInformationExtIEs) Reset() {
        *m = SgNBResourceCoordinationInformationExtIEs{}
}
func (m *SgNBResourceCoordinationInformationExtIEs) String() string { return proto.CompactTextString(m) }
func (*SgNBResourceCoordinationInformationExtIEs) ProtoMessage()    {}
func (*SgNBResourceCoordinationInformationExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{38}
}

func (m *SgNBResourceCoordinationInformationExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.Unmarshal(m, b)
}
func (m *SgNBResourceCoordinationInformationExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.Marshal(b, m, deterministic)
}
func (m *SgNBResourceCoordinationInformationExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.Merge(m, src)
}
func (m *SgNBResourceCoordinationInformationExtIEs) XXX_Size() int {
        return xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.Size(m)
}
func (m *SgNBResourceCoordinationInformationExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_SgNBResourceCoordinationInformationExtIEs proto.InternalMessageInfo

func (m *SgNBResourceCoordinationInformationExtIEs) GetId_ECGI() *ECGI {
        if m != nil {
                return m.Id_ECGI
        }
        return nil
}

func (m *SgNBResourceCoordinationInformationExtIEs) GetId_SgNBCoordinationAssistanceInformation() *SgNBCoordinationAssistanceInformation {
        if m != nil {
                return m.Id_SgNBCoordinationAssistanceInformation
        }
        return nil
}

type SgNBCoordinationAssistanceInformation struct {
        Value                SgNBCoordinationAssistanceInformation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.SgNBCoordinationAssistanceInformation_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
        XXX_unrecognized     []byte                                      `json:"-"`
        XXX_sizecache        int32                                       `json:"-"`
}

func (m *SgNBCoordinationAssistanceInformation) Reset()         { *m = SgNBCoordinationAssistanceInformation{} }
func (m *SgNBCoordinationAssistanceInformation) String() string { return proto.CompactTextString(m) }
func (*SgNBCoordinationAssistanceInformation) ProtoMessage()    {}
func (*SgNBCoordinationAssistanceInformation) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{39}
}

func (m *SgNBCoordinationAssistanceInformation) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_SgNBCoordinationAssistanceInformation.Unmarshal(m, b)
}
func (m *SgNBCoordinationAssistanceInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_SgNBCoordinationAssistanceInformation.Marshal(b, m, deterministic)
}
func (m *SgNBCoordinationAssistanceInformation) XXX_Merge(src proto.Message) {
        xxx_messageInfo_SgNBCoordinationAssistanceInformation.Merge(m, src)
}
func (m *SgNBCoordinationAssistanceInformation) XXX_Size() int {
        return xxx_messageInfo_SgNBCoordinationAssistanceInformation.Size(m)
}
func (m *SgNBCoordinationAssistanceInformation) XXX_DiscardUnknown() {
        xxx_messageInfo_SgNBCoordinationAssistanceInformation.DiscardUnknown(m)
}

var xxx_messageInfo_SgNBCoordinationAssistanceInformation proto.InternalMessageInfo

func (m *SgNBCoordinationAssistanceInformation) GetValue() SgNBCoordinationAssistanceInformation_Value {
        if m != nil {
                return m.Value
        }
        return SgNBCoordinationAssistanceInformation_protobuf_unspecified
}

type RRC_Config_Ind struct {
        Value                RRC_Config_Ind_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.RRC_Config_Ind_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}             `json:"-"`
        XXX_unrecognized     []byte               `json:"-"`
        XXX_sizecache        int32                `json:"-"`
}

func (m *RRC_Config_Ind) Reset()         { *m = RRC_Config_Ind{} }
func (m *RRC_Config_Ind) String() string { return proto.CompactTextString(m) }
func (*RRC_Config_Ind) ProtoMessage()    {}
func (*RRC_Config_Ind) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{40}
}

func (m *RRC_Config_Ind) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_RRC_Config_Ind.Unmarshal(m, b)
}
func (m *RRC_Config_Ind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_RRC_Config_Ind.Marshal(b, m, deterministic)
}
func (m *RRC_Config_Ind) XXX_Merge(src proto.Message) {
        xxx_messageInfo_RRC_Config_Ind.Merge(m, src)
}
func (m *RRC_Config_Ind) XXX_Size() int {
        return xxx_messageInfo_RRC_Config_Ind.Size(m)
}
func (m *RRC_Config_Ind) XXX_DiscardUnknown() {
        xxx_messageInfo_RRC_Config_Ind.DiscardUnknown(m)
}

var xxx_messageInfo_RRC_Config_Ind proto.InternalMessageInfo

func (m *RRC_Config_Ind) GetValue() RRC_Config_Ind_Value {
        if m != nil {
                return m.Value
        }
        return RRC_Config_Ind_protobuf_unspecified
}

type HandoverRestrictionList struct {
        ServingPLMN          []byte                            `protobuf:"bytes,1,opt,name=servingPLMN,proto3" json:"servingPLMN,omitempty"`
        EquivalentPLMNs      *EPLMNs                           `protobuf:"bytes,2,opt,name=equivalentPLMNs,proto3" json:"equivalentPLMNs,omitempty"`
        ForbiddenTAs         *ForbiddenTAs                     `protobuf:"bytes,3,opt,name=forbiddenTAs,proto3" json:"forbiddenTAs,omitempty"`
        ForbiddenLAs         *ForbiddenLAs                     `protobuf:"bytes,4,opt,name=forbiddenLAs,proto3" json:"forbiddenLAs,omitempty"`
        ForbiddenInterRATs   *ForbiddenInterRATs               `protobuf:"bytes,5,opt,name=forbiddenInterRATs,proto3" json:"forbiddenInterRATs,omitempty"`
        IE_Extensions        []*HandoverRestrictionList_ExtIEs `protobuf:"bytes,6,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
        XXX_unrecognized     []byte                            `json:"-"`
        XXX_sizecache        int32                             `json:"-"`
}

func (m *HandoverRestrictionList) Reset()         { *m = HandoverRestrictionList{} }
func (m *HandoverRestrictionList) String() string { return proto.CompactTextString(m) }
func (*HandoverRestrictionList) ProtoMessage()    {}
func (*HandoverRestrictionList) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{41}
}

func (m *HandoverRestrictionList) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_HandoverRestrictionList.Unmarshal(m, b)
}
func (m *HandoverRestrictionList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_HandoverRestrictionList.Marshal(b, m, deterministic)
}
func (m *HandoverRestrictionList) XXX_Merge(src proto.Message) {
        xxx_messageInfo_HandoverRestrictionList.Merge(m, src)
}
func (m *HandoverRestrictionList) XXX_Size() int {
        return xxx_messageInfo_HandoverRestrictionList.Size(m)
}
func (m *HandoverRestrictionList) XXX_DiscardUnknown() {
        xxx_messageInfo_HandoverRestrictionList.DiscardUnknown(m)
}

var xxx_messageInfo_HandoverRestrictionList proto.InternalMessageInfo

func (m *HandoverRestrictionList) GetServingPLMN() []byte {
        if m != nil {
                return m.ServingPLMN
        }
        return nil
}

func (m *HandoverRestrictionList) GetEquivalentPLMNs() *EPLMNs {
        if m != nil {
                return m.EquivalentPLMNs
        }
        return nil
}

func (m *HandoverRestrictionList) GetForbiddenTAs() *ForbiddenTAs {
        if m != nil {
                return m.ForbiddenTAs
        }
        return nil
}

func (m *HandoverRestrictionList) GetForbiddenLAs() *ForbiddenLAs {
        if m != nil {
                return m.ForbiddenLAs
        }
        return nil
}

func (m *HandoverRestrictionList) GetForbiddenInterRATs() *ForbiddenInterRATs {
        if m != nil {
                return m.ForbiddenInterRATs
        }
        return nil
}

func (m *HandoverRestrictionList) GetIE_Extensions() []*HandoverRestrictionList_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type EPLMNs struct {
        Items                [][]byte `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *EPLMNs) Reset()         { *m = EPLMNs{} }
func (m *EPLMNs) String() string { return proto.CompactTextString(m) }
func (*EPLMNs) ProtoMessage()    {}
func (*EPLMNs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{42}
}

func (m *EPLMNs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_EPLMNs.Unmarshal(m, b)
}
func (m *EPLMNs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_EPLMNs.Marshal(b, m, deterministic)
}
func (m *EPLMNs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_EPLMNs.Merge(m, src)
}
func (m *EPLMNs) XXX_Size() int {
        return xxx_messageInfo_EPLMNs.Size(m)
}
func (m *EPLMNs) XXX_DiscardUnknown() {
        xxx_messageInfo_EPLMNs.DiscardUnknown(m)
}

var xxx_messageInfo_EPLMNs proto.InternalMessageInfo

func (m *EPLMNs) GetItems() [][]byte {
        if m != nil {
                return m.Items
        }
        return nil
}

type ForbiddenTAs struct {
        Items                []*ForbiddenTAs_Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
        XXX_NoUnkeyedLiteral struct{}             `json:"-"`
        XXX_unrecognized     []byte               `json:"-"`
        XXX_sizecache        int32                `json:"-"`
}

func (m *ForbiddenTAs) Reset()         { *m = ForbiddenTAs{} }
func (m *ForbiddenTAs) String() string { return proto.CompactTextString(m) }
func (*ForbiddenTAs) ProtoMessage()    {}
func (*ForbiddenTAs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{43}
}

func (m *ForbiddenTAs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ForbiddenTAs.Unmarshal(m, b)
}
func (m *ForbiddenTAs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ForbiddenTAs.Marshal(b, m, deterministic)
}
func (m *ForbiddenTAs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ForbiddenTAs.Merge(m, src)
}
func (m *ForbiddenTAs) XXX_Size() int {
        return xxx_messageInfo_ForbiddenTAs.Size(m)
}
func (m *ForbiddenTAs) XXX_DiscardUnknown() {
        xxx_messageInfo_ForbiddenTAs.DiscardUnknown(m)
}

var xxx_messageInfo_ForbiddenTAs proto.InternalMessageInfo

func (m *ForbiddenTAs) GetItems() []*ForbiddenTAs_Item {
        if m != nil {
                return m.Items
        }
        return nil
}

type ForbiddenTAs_Item struct {
        PLMN_Identity        []byte         `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"`
        ForbiddenTACs        *ForbiddenTACs `protobuf:"bytes,2,opt,name=forbiddenTACs,proto3" json:"forbiddenTACs,omitempty"`
        XXX_NoUnkeyedLiteral struct{}       `json:"-"`
        XXX_unrecognized     []byte         `json:"-"`
        XXX_sizecache        int32          `json:"-"`
}

func (m *ForbiddenTAs_Item) Reset()         { *m = ForbiddenTAs_Item{} }
func (m *ForbiddenTAs_Item) String() string { return proto.CompactTextString(m) }
func (*ForbiddenTAs_Item) ProtoMessage()    {}
func (*ForbiddenTAs_Item) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{44}
}

func (m *ForbiddenTAs_Item) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ForbiddenTAs_Item.Unmarshal(m, b)
}
func (m *ForbiddenTAs_Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ForbiddenTAs_Item.Marshal(b, m, deterministic)
}
func (m *ForbiddenTAs_Item) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ForbiddenTAs_Item.Merge(m, src)
}
func (m *ForbiddenTAs_Item) XXX_Size() int {
        return xxx_messageInfo_ForbiddenTAs_Item.Size(m)
}
func (m *ForbiddenTAs_Item) XXX_DiscardUnknown() {
        xxx_messageInfo_ForbiddenTAs_Item.DiscardUnknown(m)
}

var xxx_messageInfo_ForbiddenTAs_Item proto.InternalMessageInfo

func (m *ForbiddenTAs_Item) GetPLMN_Identity() []byte {
        if m != nil {
                return m.PLMN_Identity
        }
        return nil
}

func (m *ForbiddenTAs_Item) GetForbiddenTACs() *ForbiddenTACs {
        if m != nil {
                return m.ForbiddenTACs
        }
        return nil
}

type ForbiddenTACs struct {
        Items                [][]byte `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *ForbiddenTACs) Reset()         { *m = ForbiddenTACs{} }
func (m *ForbiddenTACs) String() string { return proto.CompactTextString(m) }
func (*ForbiddenTACs) ProtoMessage()    {}
func (*ForbiddenTACs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{45}
}

func (m *ForbiddenTACs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ForbiddenTACs.Unmarshal(m, b)
}
func (m *ForbiddenTACs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ForbiddenTACs.Marshal(b, m, deterministic)
}
func (m *ForbiddenTACs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ForbiddenTACs.Merge(m, src)
}
func (m *ForbiddenTACs) XXX_Size() int {
        return xxx_messageInfo_ForbiddenTACs.Size(m)
}
func (m *ForbiddenTACs) XXX_DiscardUnknown() {
        xxx_messageInfo_ForbiddenTACs.DiscardUnknown(m)
}

var xxx_messageInfo_ForbiddenTACs proto.InternalMessageInfo

func (m *ForbiddenTACs) GetItems() [][]byte {
        if m != nil {
                return m.Items
        }
        return nil
}

type ForbiddenLAs struct {
        Items                []*ForbiddenLAs_Item `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
        XXX_NoUnkeyedLiteral struct{}             `json:"-"`
        XXX_unrecognized     []byte               `json:"-"`
        XXX_sizecache        int32                `json:"-"`
}

func (m *ForbiddenLAs) Reset()         { *m = ForbiddenLAs{} }
func (m *ForbiddenLAs) String() string { return proto.CompactTextString(m) }
func (*ForbiddenLAs) ProtoMessage()    {}
func (*ForbiddenLAs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{46}
}

func (m *ForbiddenLAs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ForbiddenLAs.Unmarshal(m, b)
}
func (m *ForbiddenLAs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ForbiddenLAs.Marshal(b, m, deterministic)
}
func (m *ForbiddenLAs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ForbiddenLAs.Merge(m, src)
}
func (m *ForbiddenLAs) XXX_Size() int {
        return xxx_messageInfo_ForbiddenLAs.Size(m)
}
func (m *ForbiddenLAs) XXX_DiscardUnknown() {
        xxx_messageInfo_ForbiddenLAs.DiscardUnknown(m)
}

var xxx_messageInfo_ForbiddenLAs proto.InternalMessageInfo

func (m *ForbiddenLAs) GetItems() []*ForbiddenLAs_Item {
        if m != nil {
                return m.Items
        }
        return nil
}

type ForbiddenLAs_Item struct {
        PLMN_Identity        []byte         `protobuf:"bytes,1,opt,name=pLMN_Identity,json=pLMNIdentity,proto3" json:"pLMN_Identity,omitempty"`
        ForbiddenLACs        *ForbiddenLACs `protobuf:"bytes,2,opt,name=forbiddenLACs,proto3" json:"forbiddenLACs,omitempty"`
        XXX_NoUnkeyedLiteral struct{}       `json:"-"`
        XXX_unrecognized     []byte         `json:"-"`
        XXX_sizecache        int32          `json:"-"`
}

func (m *ForbiddenLAs_Item) Reset()         { *m = ForbiddenLAs_Item{} }
func (m *ForbiddenLAs_Item) String() string { return proto.CompactTextString(m) }
func (*ForbiddenLAs_Item) ProtoMessage()    {}
func (*ForbiddenLAs_Item) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{47}
}

func (m *ForbiddenLAs_Item) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ForbiddenLAs_Item.Unmarshal(m, b)
}
func (m *ForbiddenLAs_Item) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ForbiddenLAs_Item.Marshal(b, m, deterministic)
}
func (m *ForbiddenLAs_Item) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ForbiddenLAs_Item.Merge(m, src)
}
func (m *ForbiddenLAs_Item) XXX_Size() int {
        return xxx_messageInfo_ForbiddenLAs_Item.Size(m)
}
func (m *ForbiddenLAs_Item) XXX_DiscardUnknown() {
        xxx_messageInfo_ForbiddenLAs_Item.DiscardUnknown(m)
}

var xxx_messageInfo_ForbiddenLAs_Item proto.InternalMessageInfo

func (m *ForbiddenLAs_Item) GetPLMN_Identity() []byte {
        if m != nil {
                return m.PLMN_Identity
        }
        return nil
}

func (m *ForbiddenLAs_Item) GetForbiddenLACs() *ForbiddenLACs {
        if m != nil {
                return m.ForbiddenLACs
        }
        return nil
}

type ForbiddenLACs struct {
        Items                [][]byte `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *ForbiddenLACs) Reset()         { *m = ForbiddenLACs{} }
func (m *ForbiddenLACs) String() string { return proto.CompactTextString(m) }
func (*ForbiddenLACs) ProtoMessage()    {}
func (*ForbiddenLACs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{48}
}

func (m *ForbiddenLACs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ForbiddenLACs.Unmarshal(m, b)
}
func (m *ForbiddenLACs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ForbiddenLACs.Marshal(b, m, deterministic)
}
func (m *ForbiddenLACs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ForbiddenLACs.Merge(m, src)
}
func (m *ForbiddenLACs) XXX_Size() int {
        return xxx_messageInfo_ForbiddenLACs.Size(m)
}
func (m *ForbiddenLACs) XXX_DiscardUnknown() {
        xxx_messageInfo_ForbiddenLACs.DiscardUnknown(m)
}

var xxx_messageInfo_ForbiddenLACs proto.InternalMessageInfo

func (m *ForbiddenLACs) GetItems() [][]byte {
        if m != nil {
                return m.Items
        }
        return nil
}

type ForbiddenInterRATs struct {
        Value                ForbiddenInterRATs_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.ForbiddenInterRATs_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
        XXX_unrecognized     []byte                   `json:"-"`
        XXX_sizecache        int32                    `json:"-"`
}

func (m *ForbiddenInterRATs) Reset()         { *m = ForbiddenInterRATs{} }
func (m *ForbiddenInterRATs) String() string { return proto.CompactTextString(m) }
func (*ForbiddenInterRATs) ProtoMessage()    {}
func (*ForbiddenInterRATs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{49}
}

func (m *ForbiddenInterRATs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ForbiddenInterRATs.Unmarshal(m, b)
}
func (m *ForbiddenInterRATs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ForbiddenInterRATs.Marshal(b, m, deterministic)
}
func (m *ForbiddenInterRATs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ForbiddenInterRATs.Merge(m, src)
}
func (m *ForbiddenInterRATs) XXX_Size() int {
        return xxx_messageInfo_ForbiddenInterRATs.Size(m)
}
func (m *ForbiddenInterRATs) XXX_DiscardUnknown() {
        xxx_messageInfo_ForbiddenInterRATs.DiscardUnknown(m)
}

var xxx_messageInfo_ForbiddenInterRATs proto.InternalMessageInfo

func (m *ForbiddenInterRATs) GetValue() ForbiddenInterRATs_Value {
        if m != nil {
                return m.Value
        }
        return ForbiddenInterRATs_protobuf_unspecified
}

type HandoverRestrictionList_ExtIEs struct {
        Id_NRrestrictioninEPSasSecondaryRAT *NRrestrictioninEPSasSecondaryRAT `protobuf:"bytes,1,opt,name=id_NRrestrictioninEPSasSecondaryRAT,json=idNRrestrictioninEPSasSecondaryRAT,proto3" json:"id_NRrestrictioninEPSasSecondaryRAT,omitempty"`
        Id_CNTypeRestrictions               *CNTypeRestrictions               `protobuf:"bytes,2,opt,name=id_CNTypeRestrictions,json=idCNTypeRestrictions,proto3" json:"id_CNTypeRestrictions,omitempty"`
        Id_NRrestrictionin5GS               *NRrestrictionin5GS               `protobuf:"bytes,3,opt,name=id_NRrestrictionin5GS,json=idNRrestrictionin5GS,proto3" json:"id_NRrestrictionin5GS,omitempty"`
        XXX_NoUnkeyedLiteral                struct{}                          `json:"-"`
        XXX_unrecognized                    []byte                            `json:"-"`
        XXX_sizecache                       int32                             `json:"-"`
}

func (m *HandoverRestrictionList_ExtIEs) Reset()         { *m = HandoverRestrictionList_ExtIEs{} }
func (m *HandoverRestrictionList_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*HandoverRestrictionList_ExtIEs) ProtoMessage()    {}
func (*HandoverRestrictionList_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{50}
}

func (m *HandoverRestrictionList_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_HandoverRestrictionList_ExtIEs.Unmarshal(m, b)
}
func (m *HandoverRestrictionList_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_HandoverRestrictionList_ExtIEs.Marshal(b, m, deterministic)
}
func (m *HandoverRestrictionList_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_HandoverRestrictionList_ExtIEs.Merge(m, src)
}
func (m *HandoverRestrictionList_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_HandoverRestrictionList_ExtIEs.Size(m)
}
func (m *HandoverRestrictionList_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_HandoverRestrictionList_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_HandoverRestrictionList_ExtIEs proto.InternalMessageInfo

func (m *HandoverRestrictionList_ExtIEs) GetId_NRrestrictioninEPSasSecondaryRAT() *NRrestrictioninEPSasSecondaryRAT {
        if m != nil {
                return m.Id_NRrestrictioninEPSasSecondaryRAT
        }
        return nil
}

func (m *HandoverRestrictionList_ExtIEs) GetId_CNTypeRestrictions() *CNTypeRestrictions {
        if m != nil {
                return m.Id_CNTypeRestrictions
        }
        return nil
}

func (m *HandoverRestrictionList_ExtIEs) GetId_NRrestrictionin5GS() *NRrestrictionin5GS {
        if m != nil {
                return m.Id_NRrestrictionin5GS
        }
        return nil
}

type NRrestrictioninEPSasSecondaryRAT struct {
        Value                NRrestrictioninEPSasSecondaryRAT_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.NRrestrictioninEPSasSecondaryRAT_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
        XXX_unrecognized     []byte                                 `json:"-"`
        XXX_sizecache        int32                                  `json:"-"`
}

func (m *NRrestrictioninEPSasSecondaryRAT) Reset()         { *m = NRrestrictioninEPSasSecondaryRAT{} }
func (m *NRrestrictioninEPSasSecondaryRAT) String() string { return proto.CompactTextString(m) }
func (*NRrestrictioninEPSasSecondaryRAT) ProtoMessage()    {}
func (*NRrestrictioninEPSasSecondaryRAT) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{51}
}

func (m *NRrestrictioninEPSasSecondaryRAT) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.Unmarshal(m, b)
}
func (m *NRrestrictioninEPSasSecondaryRAT) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.Marshal(b, m, deterministic)
}
func (m *NRrestrictioninEPSasSecondaryRAT) XXX_Merge(src proto.Message) {
        xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.Merge(m, src)
}
func (m *NRrestrictioninEPSasSecondaryRAT) XXX_Size() int {
        return xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.Size(m)
}
func (m *NRrestrictioninEPSasSecondaryRAT) XXX_DiscardUnknown() {
        xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT.DiscardUnknown(m)
}

var xxx_messageInfo_NRrestrictioninEPSasSecondaryRAT proto.InternalMessageInfo

func (m *NRrestrictioninEPSasSecondaryRAT) GetValue() NRrestrictioninEPSasSecondaryRAT_Value {
        if m != nil {
                return m.Value
        }
        return NRrestrictioninEPSasSecondaryRAT_protobuf_unspecified
}

type CNTypeRestrictions struct {
        Items                []*CNTypeRestrictionsItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
        XXX_unrecognized     []byte                    `json:"-"`
        XXX_sizecache        int32                     `json:"-"`
}

func (m *CNTypeRestrictions) Reset()         { *m = CNTypeRestrictions{} }
func (m *CNTypeRestrictions) String() string { return proto.CompactTextString(m) }
func (*CNTypeRestrictions) ProtoMessage()    {}
func (*CNTypeRestrictions) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{52}
}

func (m *CNTypeRestrictions) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_CNTypeRestrictions.Unmarshal(m, b)
}
func (m *CNTypeRestrictions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_CNTypeRestrictions.Marshal(b, m, deterministic)
}
func (m *CNTypeRestrictions) XXX_Merge(src proto.Message) {
        xxx_messageInfo_CNTypeRestrictions.Merge(m, src)
}
func (m *CNTypeRestrictions) XXX_Size() int {
        return xxx_messageInfo_CNTypeRestrictions.Size(m)
}
func (m *CNTypeRestrictions) XXX_DiscardUnknown() {
        xxx_messageInfo_CNTypeRestrictions.DiscardUnknown(m)
}

var xxx_messageInfo_CNTypeRestrictions proto.InternalMessageInfo

func (m *CNTypeRestrictions) GetItems() []*CNTypeRestrictionsItem {
        if m != nil {
                return m.Items
        }
        return nil
}

type CNTypeRestrictionsItem struct {
        Plmn_Id              []byte                        `protobuf:"bytes,1,opt,name=plmn_Id,json=plmnId,proto3" json:"plmn_Id,omitempty"`
        CnType               CNTypeRestrictionsItem_CNType `protobuf:"varint,2,opt,name=cn_type,json=cnType,proto3,enum=streaming_protobufs.CNTypeRestrictionsItem_CNType" json:"cn_type,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
        XXX_unrecognized     []byte                        `json:"-"`
        XXX_sizecache        int32                         `json:"-"`
}

func (m *CNTypeRestrictionsItem) Reset()         { *m = CNTypeRestrictionsItem{} }
func (m *CNTypeRestrictionsItem) String() string { return proto.CompactTextString(m) }
func (*CNTypeRestrictionsItem) ProtoMessage()    {}
func (*CNTypeRestrictionsItem) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{53}
}

func (m *CNTypeRestrictionsItem) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_CNTypeRestrictionsItem.Unmarshal(m, b)
}
func (m *CNTypeRestrictionsItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_CNTypeRestrictionsItem.Marshal(b, m, deterministic)
}
func (m *CNTypeRestrictionsItem) XXX_Merge(src proto.Message) {
        xxx_messageInfo_CNTypeRestrictionsItem.Merge(m, src)
}
func (m *CNTypeRestrictionsItem) XXX_Size() int {
        return xxx_messageInfo_CNTypeRestrictionsItem.Size(m)
}
func (m *CNTypeRestrictionsItem) XXX_DiscardUnknown() {
        xxx_messageInfo_CNTypeRestrictionsItem.DiscardUnknown(m)
}

var xxx_messageInfo_CNTypeRestrictionsItem proto.InternalMessageInfo

func (m *CNTypeRestrictionsItem) GetPlmn_Id() []byte {
        if m != nil {
                return m.Plmn_Id
        }
        return nil
}

func (m *CNTypeRestrictionsItem) GetCnType() CNTypeRestrictionsItem_CNType {
        if m != nil {
                return m.CnType
        }
        return CNTypeRestrictionsItem_protobuf_unspecified
}

type NRrestrictionin5GS struct {
        Value                NRrestrictionin5GS_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.NRrestrictionin5GS_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
        XXX_unrecognized     []byte                   `json:"-"`
        XXX_sizecache        int32                    `json:"-"`
}

func (m *NRrestrictionin5GS) Reset()         { *m = NRrestrictionin5GS{} }
func (m *NRrestrictionin5GS) String() string { return proto.CompactTextString(m) }
func (*NRrestrictionin5GS) ProtoMessage()    {}
func (*NRrestrictionin5GS) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{54}
}

func (m *NRrestrictionin5GS) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_NRrestrictionin5GS.Unmarshal(m, b)
}
func (m *NRrestrictionin5GS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_NRrestrictionin5GS.Marshal(b, m, deterministic)
}
func (m *NRrestrictionin5GS) XXX_Merge(src proto.Message) {
        xxx_messageInfo_NRrestrictionin5GS.Merge(m, src)
}
func (m *NRrestrictionin5GS) XXX_Size() int {
        return xxx_messageInfo_NRrestrictionin5GS.Size(m)
}
func (m *NRrestrictionin5GS) XXX_DiscardUnknown() {
        xxx_messageInfo_NRrestrictionin5GS.DiscardUnknown(m)
}

var xxx_messageInfo_NRrestrictionin5GS proto.InternalMessageInfo

func (m *NRrestrictionin5GS) GetValue() NRrestrictionin5GS_Value {
        if m != nil {
                return m.Value
        }
        return NRrestrictionin5GS_protobuf_unspecified
}

type NRUESecurityCapabilities struct {
        NRencryptionAlgorithms          []byte   `protobuf:"bytes,1,opt,name=nRencryptionAlgorithms,proto3" json:"nRencryptionAlgorithms,omitempty"`
        NRintegrityProtectionAlgorithms []byte   `protobuf:"bytes,2,opt,name=nRintegrityProtectionAlgorithms,proto3" json:"nRintegrityProtectionAlgorithms,omitempty"`
        XXX_NoUnkeyedLiteral            struct{} `json:"-"`
        XXX_unrecognized                []byte   `json:"-"`
        XXX_sizecache                   int32    `json:"-"`
}

func (m *NRUESecurityCapabilities) Reset()         { *m = NRUESecurityCapabilities{} }
func (m *NRUESecurityCapabilities) String() string { return proto.CompactTextString(m) }
func (*NRUESecurityCapabilities) ProtoMessage()    {}
func (*NRUESecurityCapabilities) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{55}
}

func (m *NRUESecurityCapabilities) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_NRUESecurityCapabilities.Unmarshal(m, b)
}
func (m *NRUESecurityCapabilities) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_NRUESecurityCapabilities.Marshal(b, m, deterministic)
}
func (m *NRUESecurityCapabilities) XXX_Merge(src proto.Message) {
        xxx_messageInfo_NRUESecurityCapabilities.Merge(m, src)
}
func (m *NRUESecurityCapabilities) XXX_Size() int {
        return xxx_messageInfo_NRUESecurityCapabilities.Size(m)
}
func (m *NRUESecurityCapabilities) XXX_DiscardUnknown() {
        xxx_messageInfo_NRUESecurityCapabilities.DiscardUnknown(m)
}

var xxx_messageInfo_NRUESecurityCapabilities proto.InternalMessageInfo

func (m *NRUESecurityCapabilities) GetNRencryptionAlgorithms() []byte {
        if m != nil {
                return m.NRencryptionAlgorithms
        }
        return nil
}

func (m *NRUESecurityCapabilities) GetNRintegrityProtectionAlgorithms() []byte {
        if m != nil {
                return m.NRintegrityProtectionAlgorithms
        }
        return nil
}

type UEAggregateMaximumBitRate struct {
        UEaggregateMaximumBitRateDownlink uint64                               `protobuf:"varint,1,opt,name=uEaggregateMaximumBitRateDownlink,proto3" json:"uEaggregateMaximumBitRateDownlink,omitempty"`
        UEaggregateMaximumBitRateUplink   uint64                               `protobuf:"varint,2,opt,name=uEaggregateMaximumBitRateUplink,proto3" json:"uEaggregateMaximumBitRateUplink,omitempty"`
        IE_Extensions                     []*UEAggregate_MaximumBitrate_ExtIEs `protobuf:"bytes,3,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral              struct{}                             `json:"-"`
        XXX_unrecognized                  []byte                               `json:"-"`
        XXX_sizecache                     int32                                `json:"-"`
}

func (m *UEAggregateMaximumBitRate) Reset()         { *m = UEAggregateMaximumBitRate{} }
func (m *UEAggregateMaximumBitRate) String() string { return proto.CompactTextString(m) }
func (*UEAggregateMaximumBitRate) ProtoMessage()    {}
func (*UEAggregateMaximumBitRate) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{56}
}

func (m *UEAggregateMaximumBitRate) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_UEAggregateMaximumBitRate.Unmarshal(m, b)
}
func (m *UEAggregateMaximumBitRate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_UEAggregateMaximumBitRate.Marshal(b, m, deterministic)
}
func (m *UEAggregateMaximumBitRate) XXX_Merge(src proto.Message) {
        xxx_messageInfo_UEAggregateMaximumBitRate.Merge(m, src)
}
func (m *UEAggregateMaximumBitRate) XXX_Size() int {
        return xxx_messageInfo_UEAggregateMaximumBitRate.Size(m)
}
func (m *UEAggregateMaximumBitRate) XXX_DiscardUnknown() {
        xxx_messageInfo_UEAggregateMaximumBitRate.DiscardUnknown(m)
}

var xxx_messageInfo_UEAggregateMaximumBitRate proto.InternalMessageInfo

func (m *UEAggregateMaximumBitRate) GetUEaggregateMaximumBitRateDownlink() uint64 {
        if m != nil {
                return m.UEaggregateMaximumBitRateDownlink
        }
        return 0
}

func (m *UEAggregateMaximumBitRate) GetUEaggregateMaximumBitRateUplink() uint64 {
        if m != nil {
                return m.UEaggregateMaximumBitRateUplink
        }
        return 0
}

func (m *UEAggregateMaximumBitRate) GetIE_Extensions() []*UEAggregate_MaximumBitrate_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type UEAggregate_MaximumBitrate_ExtIEs struct {
        IdExtendedUEaggregateMaximumBitRateDownlink *wrappers.UInt64Value `protobuf:"bytes,1,opt,name=id_extended_uEaggregateMaximumBitRateDownlink,json=idExtendedUEaggregateMaximumBitRateDownlink,proto3" json:"id_extended_uEaggregateMaximumBitRateDownlink,omitempty"`
        IdExtendedUEaggregateMaximumBitRateUplink   *wrappers.UInt64Value `protobuf:"bytes,2,opt,name=id_extended_uEaggregateMaximumBitRateUplink,json=idExtendedUEaggregateMaximumBitRateUplink,proto3" json:"id_extended_uEaggregateMaximumBitRateUplink,omitempty"`
        XXX_NoUnkeyedLiteral                        struct{}              `json:"-"`
        XXX_unrecognized                            []byte                `json:"-"`
        XXX_sizecache                               int32                 `json:"-"`
}

func (m *UEAggregate_MaximumBitrate_ExtIEs) Reset()         { *m = UEAggregate_MaximumBitrate_ExtIEs{} }
func (m *UEAggregate_MaximumBitrate_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*UEAggregate_MaximumBitrate_ExtIEs) ProtoMessage()    {}
func (*UEAggregate_MaximumBitrate_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{57}
}

func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.Unmarshal(m, b)
}
func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.Marshal(b, m, deterministic)
}
func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.Merge(m, src)
}
func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.Size(m)
}
func (m *UEAggregate_MaximumBitrate_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_UEAggregate_MaximumBitrate_ExtIEs proto.InternalMessageInfo

func (m *UEAggregate_MaximumBitrate_ExtIEs) GetIdExtendedUEaggregateMaximumBitRateDownlink() *wrappers.UInt64Value {
        if m != nil {
                return m.IdExtendedUEaggregateMaximumBitRateDownlink
        }
        return nil
}

func (m *UEAggregate_MaximumBitrate_ExtIEs) GetIdExtendedUEaggregateMaximumBitRateUplink() *wrappers.UInt64Value {
        if m != nil {
                return m.IdExtendedUEaggregateMaximumBitRateUplink
        }
        return nil
}

type DL_Forwarding struct {
        Value                DL_Forwarding_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.DL_Forwarding_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}            `json:"-"`
        XXX_unrecognized     []byte              `json:"-"`
        XXX_sizecache        int32               `json:"-"`
}

func (m *DL_Forwarding) Reset()         { *m = DL_Forwarding{} }
func (m *DL_Forwarding) String() string { return proto.CompactTextString(m) }
func (*DL_Forwarding) ProtoMessage()    {}
func (*DL_Forwarding) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{58}
}

func (m *DL_Forwarding) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_DL_Forwarding.Unmarshal(m, b)
}
func (m *DL_Forwarding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_DL_Forwarding.Marshal(b, m, deterministic)
}
func (m *DL_Forwarding) XXX_Merge(src proto.Message) {
        xxx_messageInfo_DL_Forwarding.Merge(m, src)
}
func (m *DL_Forwarding) XXX_Size() int {
        return xxx_messageInfo_DL_Forwarding.Size(m)
}
func (m *DL_Forwarding) XXX_DiscardUnknown() {
        xxx_messageInfo_DL_Forwarding.DiscardUnknown(m)
}

var xxx_messageInfo_DL_Forwarding proto.InternalMessageInfo

func (m *DL_Forwarding) GetValue() DL_Forwarding_Value {
        if m != nil {
                return m.Value
        }
        return DL_Forwarding_protobuf_unspecified
}

type DuplicationActivation struct {
        Value                DuplicationActivation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.DuplicationActivation_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
        XXX_unrecognized     []byte                      `json:"-"`
        XXX_sizecache        int32                       `json:"-"`
}

func (m *DuplicationActivation) Reset()         { *m = DuplicationActivation{} }
func (m *DuplicationActivation) String() string { return proto.CompactTextString(m) }
func (*DuplicationActivation) ProtoMessage()    {}
func (*DuplicationActivation) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{59}
}

func (m *DuplicationActivation) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_DuplicationActivation.Unmarshal(m, b)
}
func (m *DuplicationActivation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_DuplicationActivation.Marshal(b, m, deterministic)
}
func (m *DuplicationActivation) XXX_Merge(src proto.Message) {
        xxx_messageInfo_DuplicationActivation.Merge(m, src)
}
func (m *DuplicationActivation) XXX_Size() int {
        return xxx_messageInfo_DuplicationActivation.Size(m)
}
func (m *DuplicationActivation) XXX_DiscardUnknown() {
        xxx_messageInfo_DuplicationActivation.DiscardUnknown(m)
}

var xxx_messageInfo_DuplicationActivation proto.InternalMessageInfo

func (m *DuplicationActivation) GetValue() DuplicationActivation_Value {
        if m != nil {
                return m.Value
        }
        return DuplicationActivation_protobuf_unspecified
}

type MeNBResourceCoordinationInformation struct {
        EUTRA_Cell_ID             *ECGI                                        `protobuf:"bytes,1,opt,name=eUTRA_Cell_ID,json=eUTRACellID,proto3" json:"eUTRA_Cell_ID,omitempty"`
        ULCoordinationInformation []byte                                       `protobuf:"bytes,2,opt,name=uLCoordinationInformation,proto3" json:"uLCoordinationInformation,omitempty"`
        DLCoordinationInformation *wrappers.BytesValue                         `protobuf:"bytes,3,opt,name=dLCoordinationInformation,proto3" json:"dLCoordinationInformation,omitempty"`
        IE_Extensions             []*MeNBResourceCoordinationInformationExtIEs `protobuf:"bytes,4,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral      struct{}                                     `json:"-"`
        XXX_unrecognized          []byte                                       `json:"-"`
        XXX_sizecache             int32                                        `json:"-"`
}

func (m *MeNBResourceCoordinationInformation) Reset()         { *m = MeNBResourceCoordinationInformation{} }
func (m *MeNBResourceCoordinationInformation) String() string { return proto.CompactTextString(m) }
func (*MeNBResourceCoordinationInformation) ProtoMessage()    {}
func (*MeNBResourceCoordinationInformation) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{60}
}

func (m *MeNBResourceCoordinationInformation) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_MeNBResourceCoordinationInformation.Unmarshal(m, b)
}
func (m *MeNBResourceCoordinationInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_MeNBResourceCoordinationInformation.Marshal(b, m, deterministic)
}
func (m *MeNBResourceCoordinationInformation) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MeNBResourceCoordinationInformation.Merge(m, src)
}
func (m *MeNBResourceCoordinationInformation) XXX_Size() int {
        return xxx_messageInfo_MeNBResourceCoordinationInformation.Size(m)
}
func (m *MeNBResourceCoordinationInformation) XXX_DiscardUnknown() {
        xxx_messageInfo_MeNBResourceCoordinationInformation.DiscardUnknown(m)
}

var xxx_messageInfo_MeNBResourceCoordinationInformation proto.InternalMessageInfo

func (m *MeNBResourceCoordinationInformation) GetEUTRA_Cell_ID() *ECGI {
        if m != nil {
                return m.EUTRA_Cell_ID
        }
        return nil
}

func (m *MeNBResourceCoordinationInformation) GetULCoordinationInformation() []byte {
        if m != nil {
                return m.ULCoordinationInformation
        }
        return nil
}

func (m *MeNBResourceCoordinationInformation) GetDLCoordinationInformation() *wrappers.BytesValue {
        if m != nil {
                return m.DLCoordinationInformation
        }
        return nil
}

func (m *MeNBResourceCoordinationInformation) GetIE_Extensions() []*MeNBResourceCoordinationInformationExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type MeNBResourceCoordinationInformationExtIEs struct {
        Id_NRCGI                                 *NRCGI                                 `protobuf:"bytes,1,opt,name=id_NRCGI,json=idNRCGI,proto3" json:"id_NRCGI,omitempty"`
        Id_MeNBCoordinationAssistanceInformation *MeNBCoordinationAssistanceInformation `protobuf:"bytes,2,opt,name=id_MeNBCoordinationAssistanceInformation,json=idMeNBCoordinationAssistanceInformation,proto3" json:"id_MeNBCoordinationAssistanceInformation,omitempty"`
        XXX_NoUnkeyedLiteral                     struct{}                               `json:"-"`
        XXX_unrecognized                         []byte                                 `json:"-"`
        XXX_sizecache                            int32                                  `json:"-"`
}

func (m *MeNBResourceCoordinationInformationExtIEs) Reset() {
        *m = MeNBResourceCoordinationInformationExtIEs{}
}
func (m *MeNBResourceCoordinationInformationExtIEs) String() string { return proto.CompactTextString(m) }
func (*MeNBResourceCoordinationInformationExtIEs) ProtoMessage()    {}
func (*MeNBResourceCoordinationInformationExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{61}
}

func (m *MeNBResourceCoordinationInformationExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.Unmarshal(m, b)
}
func (m *MeNBResourceCoordinationInformationExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.Marshal(b, m, deterministic)
}
func (m *MeNBResourceCoordinationInformationExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.Merge(m, src)
}
func (m *MeNBResourceCoordinationInformationExtIEs) XXX_Size() int {
        return xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.Size(m)
}
func (m *MeNBResourceCoordinationInformationExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_MeNBResourceCoordinationInformationExtIEs proto.InternalMessageInfo

func (m *MeNBResourceCoordinationInformationExtIEs) GetId_NRCGI() *NRCGI {
        if m != nil {
                return m.Id_NRCGI
        }
        return nil
}

func (m *MeNBResourceCoordinationInformationExtIEs) GetId_MeNBCoordinationAssistanceInformation() *MeNBCoordinationAssistanceInformation {
        if m != nil {
                return m.Id_MeNBCoordinationAssistanceInformation
        }
        return nil
}

type MeNBCoordinationAssistanceInformation struct {
        Value                MeNBCoordinationAssistanceInformation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.MeNBCoordinationAssistanceInformation_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
        XXX_unrecognized     []byte                                      `json:"-"`
        XXX_sizecache        int32                                       `json:"-"`
}

func (m *MeNBCoordinationAssistanceInformation) Reset()         { *m = MeNBCoordinationAssistanceInformation{} }
func (m *MeNBCoordinationAssistanceInformation) String() string { return proto.CompactTextString(m) }
func (*MeNBCoordinationAssistanceInformation) ProtoMessage()    {}
func (*MeNBCoordinationAssistanceInformation) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{62}
}

func (m *MeNBCoordinationAssistanceInformation) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_MeNBCoordinationAssistanceInformation.Unmarshal(m, b)
}
func (m *MeNBCoordinationAssistanceInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_MeNBCoordinationAssistanceInformation.Marshal(b, m, deterministic)
}
func (m *MeNBCoordinationAssistanceInformation) XXX_Merge(src proto.Message) {
        xxx_messageInfo_MeNBCoordinationAssistanceInformation.Merge(m, src)
}
func (m *MeNBCoordinationAssistanceInformation) XXX_Size() int {
        return xxx_messageInfo_MeNBCoordinationAssistanceInformation.Size(m)
}
func (m *MeNBCoordinationAssistanceInformation) XXX_DiscardUnknown() {
        xxx_messageInfo_MeNBCoordinationAssistanceInformation.DiscardUnknown(m)
}

var xxx_messageInfo_MeNBCoordinationAssistanceInformation proto.InternalMessageInfo

func (m *MeNBCoordinationAssistanceInformation) GetValue() MeNBCoordinationAssistanceInformation_Value {
        if m != nil {
                return m.Value
        }
        return MeNBCoordinationAssistanceInformation_protobuf_unspecified
}

type COUNTvalue struct {
        PDCP_SN              uint32   `protobuf:"varint,1,opt,name=pDCP_SN,json=pDCPSN,proto3" json:"pDCP_SN,omitempty"`
        HFN                  uint32   `protobuf:"varint,2,opt,name=hFN,proto3" json:"hFN,omitempty"`
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *COUNTvalue) Reset()         { *m = COUNTvalue{} }
func (m *COUNTvalue) String() string { return proto.CompactTextString(m) }
func (*COUNTvalue) ProtoMessage()    {}
func (*COUNTvalue) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{63}
}

func (m *COUNTvalue) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_COUNTvalue.Unmarshal(m, b)
}
func (m *COUNTvalue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_COUNTvalue.Marshal(b, m, deterministic)
}
func (m *COUNTvalue) XXX_Merge(src proto.Message) {
        xxx_messageInfo_COUNTvalue.Merge(m, src)
}
func (m *COUNTvalue) XXX_Size() int {
        return xxx_messageInfo_COUNTvalue.Size(m)
}
func (m *COUNTvalue) XXX_DiscardUnknown() {
        xxx_messageInfo_COUNTvalue.DiscardUnknown(m)
}

var xxx_messageInfo_COUNTvalue proto.InternalMessageInfo

func (m *COUNTvalue) GetPDCP_SN() uint32 {
        if m != nil {
                return m.PDCP_SN
        }
        return 0
}

func (m *COUNTvalue) GetHFN() uint32 {
        if m != nil {
                return m.HFN
        }
        return 0
}

type COUNTValueExtended struct {
        PDCP_SNExtended      uint32   `protobuf:"varint,1,opt,name=pDCP_SNExtended,json=pDCPSNExtended,proto3" json:"pDCP_SNExtended,omitempty"`
        HFNModified          uint32   `protobuf:"varint,2,opt,name=hFNModified,proto3" json:"hFNModified,omitempty"`
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *COUNTValueExtended) Reset()         { *m = COUNTValueExtended{} }
func (m *COUNTValueExtended) String() string { return proto.CompactTextString(m) }
func (*COUNTValueExtended) ProtoMessage()    {}
func (*COUNTValueExtended) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{64}
}

func (m *COUNTValueExtended) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_COUNTValueExtended.Unmarshal(m, b)
}
func (m *COUNTValueExtended) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_COUNTValueExtended.Marshal(b, m, deterministic)
}
func (m *COUNTValueExtended) XXX_Merge(src proto.Message) {
        xxx_messageInfo_COUNTValueExtended.Merge(m, src)
}
func (m *COUNTValueExtended) XXX_Size() int {
        return xxx_messageInfo_COUNTValueExtended.Size(m)
}
func (m *COUNTValueExtended) XXX_DiscardUnknown() {
        xxx_messageInfo_COUNTValueExtended.DiscardUnknown(m)
}

var xxx_messageInfo_COUNTValueExtended proto.InternalMessageInfo

func (m *COUNTValueExtended) GetPDCP_SNExtended() uint32 {
        if m != nil {
                return m.PDCP_SNExtended
        }
        return 0
}

func (m *COUNTValueExtended) GetHFNModified() uint32 {
        if m != nil {
                return m.HFNModified
        }
        return 0
}

type COUNTvaluePDCP_SNlength18 struct {
        PDCP_SNlength18       uint32   `protobuf:"varint,1,opt,name=pDCP_SNlength18,json=pDCPSNlength18,proto3" json:"pDCP_SNlength18,omitempty"`
        HFNforPDCP_SNlength18 uint32   `protobuf:"varint,2,opt,name=hFNforPDCP_SNlength18,json=hFNforPDCPSNlength18,proto3" json:"hFNforPDCP_SNlength18,omitempty"`
        XXX_NoUnkeyedLiteral  struct{} `json:"-"`
        XXX_unrecognized      []byte   `json:"-"`
        XXX_sizecache         int32    `json:"-"`
}

func (m *COUNTvaluePDCP_SNlength18) Reset()         { *m = COUNTvaluePDCP_SNlength18{} }
func (m *COUNTvaluePDCP_SNlength18) String() string { return proto.CompactTextString(m) }
func (*COUNTvaluePDCP_SNlength18) ProtoMessage()    {}
func (*COUNTvaluePDCP_SNlength18) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{65}
}

func (m *COUNTvaluePDCP_SNlength18) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_COUNTvaluePDCP_SNlength18.Unmarshal(m, b)
}
func (m *COUNTvaluePDCP_SNlength18) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_COUNTvaluePDCP_SNlength18.Marshal(b, m, deterministic)
}
func (m *COUNTvaluePDCP_SNlength18) XXX_Merge(src proto.Message) {
        xxx_messageInfo_COUNTvaluePDCP_SNlength18.Merge(m, src)
}
func (m *COUNTvaluePDCP_SNlength18) XXX_Size() int {
        return xxx_messageInfo_COUNTvaluePDCP_SNlength18.Size(m)
}
func (m *COUNTvaluePDCP_SNlength18) XXX_DiscardUnknown() {
        xxx_messageInfo_COUNTvaluePDCP_SNlength18.DiscardUnknown(m)
}

var xxx_messageInfo_COUNTvaluePDCP_SNlength18 proto.InternalMessageInfo

func (m *COUNTvaluePDCP_SNlength18) GetPDCP_SNlength18() uint32 {
        if m != nil {
                return m.PDCP_SNlength18
        }
        return 0
}

func (m *COUNTvaluePDCP_SNlength18) GetHFNforPDCP_SNlength18() uint32 {
        if m != nil {
                return m.HFNforPDCP_SNlength18
        }
        return 0
}

type ExpectedUEBehaviour struct {
        ExpectedActivity     *ExpectedUEActivityBehaviour `protobuf:"bytes,1,opt,name=expectedActivity,proto3" json:"expectedActivity,omitempty"`
        ExpectedHOInterval   *ExpectedHOInterval          `protobuf:"bytes,2,opt,name=expectedHOInterval,proto3" json:"expectedHOInterval,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
        XXX_unrecognized     []byte                       `json:"-"`
        XXX_sizecache        int32                        `json:"-"`
}

func (m *ExpectedUEBehaviour) Reset()         { *m = ExpectedUEBehaviour{} }
func (m *ExpectedUEBehaviour) String() string { return proto.CompactTextString(m) }
func (*ExpectedUEBehaviour) ProtoMessage()    {}
func (*ExpectedUEBehaviour) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{66}
}

func (m *ExpectedUEBehaviour) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ExpectedUEBehaviour.Unmarshal(m, b)
}
func (m *ExpectedUEBehaviour) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ExpectedUEBehaviour.Marshal(b, m, deterministic)
}
func (m *ExpectedUEBehaviour) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ExpectedUEBehaviour.Merge(m, src)
}
func (m *ExpectedUEBehaviour) XXX_Size() int {
        return xxx_messageInfo_ExpectedUEBehaviour.Size(m)
}
func (m *ExpectedUEBehaviour) XXX_DiscardUnknown() {
        xxx_messageInfo_ExpectedUEBehaviour.DiscardUnknown(m)
}

var xxx_messageInfo_ExpectedUEBehaviour proto.InternalMessageInfo

func (m *ExpectedUEBehaviour) GetExpectedActivity() *ExpectedUEActivityBehaviour {
        if m != nil {
                return m.ExpectedActivity
        }
        return nil
}

func (m *ExpectedUEBehaviour) GetExpectedHOInterval() *ExpectedHOInterval {
        if m != nil {
                return m.ExpectedHOInterval
        }
        return nil
}

type ExpectedUEActivityBehaviour struct {
        ExpectedActivityPeriod                 *wrappers.UInt32Value                   `protobuf:"bytes,1,opt,name=expectedActivityPeriod,proto3" json:"expectedActivityPeriod,omitempty"`
        ExpectedIdlePeriod                     *wrappers.UInt32Value                   `protobuf:"bytes,2,opt,name=expectedIdlePeriod,proto3" json:"expectedIdlePeriod,omitempty"`
        SourceOfUEActivityBehaviourInformation *SourceOfUEActivityBehaviourInformation `protobuf:"bytes,3,opt,name=sourceOfUEActivityBehaviourInformation,proto3" json:"sourceOfUEActivityBehaviourInformation,omitempty"`
        IE_Extensions                          []*ExpectedUEActivityBehaviour_ExtIEs   `protobuf:"bytes,4,rep,name=iE_Extensions,json=iEExtensions,proto3" json:"iE_Extensions,omitempty"`
        XXX_NoUnkeyedLiteral                   struct{}                                `json:"-"`
        XXX_unrecognized                       []byte                                  `json:"-"`
        XXX_sizecache                          int32                                   `json:"-"`
}

func (m *ExpectedUEActivityBehaviour) Reset()         { *m = ExpectedUEActivityBehaviour{} }
func (m *ExpectedUEActivityBehaviour) String() string { return proto.CompactTextString(m) }
func (*ExpectedUEActivityBehaviour) ProtoMessage()    {}
func (*ExpectedUEActivityBehaviour) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{67}
}

func (m *ExpectedUEActivityBehaviour) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ExpectedUEActivityBehaviour.Unmarshal(m, b)
}
func (m *ExpectedUEActivityBehaviour) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ExpectedUEActivityBehaviour.Marshal(b, m, deterministic)
}
func (m *ExpectedUEActivityBehaviour) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ExpectedUEActivityBehaviour.Merge(m, src)
}
func (m *ExpectedUEActivityBehaviour) XXX_Size() int {
        return xxx_messageInfo_ExpectedUEActivityBehaviour.Size(m)
}
func (m *ExpectedUEActivityBehaviour) XXX_DiscardUnknown() {
        xxx_messageInfo_ExpectedUEActivityBehaviour.DiscardUnknown(m)
}

var xxx_messageInfo_ExpectedUEActivityBehaviour proto.InternalMessageInfo

func (m *ExpectedUEActivityBehaviour) GetExpectedActivityPeriod() *wrappers.UInt32Value {
        if m != nil {
                return m.ExpectedActivityPeriod
        }
        return nil
}

func (m *ExpectedUEActivityBehaviour) GetExpectedIdlePeriod() *wrappers.UInt32Value {
        if m != nil {
                return m.ExpectedIdlePeriod
        }
        return nil
}

func (m *ExpectedUEActivityBehaviour) GetSourceOfUEActivityBehaviourInformation() *SourceOfUEActivityBehaviourInformation {
        if m != nil {
                return m.SourceOfUEActivityBehaviourInformation
        }
        return nil
}

func (m *ExpectedUEActivityBehaviour) GetIE_Extensions() []*ExpectedUEActivityBehaviour_ExtIEs {
        if m != nil {
                return m.IE_Extensions
        }
        return nil
}

type ExpectedUEActivityBehaviour_ExtIEs struct {
        XXX_NoUnkeyedLiteral struct{} `json:"-"`
        XXX_unrecognized     []byte   `json:"-"`
        XXX_sizecache        int32    `json:"-"`
}

func (m *ExpectedUEActivityBehaviour_ExtIEs) Reset()         { *m = ExpectedUEActivityBehaviour_ExtIEs{} }
func (m *ExpectedUEActivityBehaviour_ExtIEs) String() string { return proto.CompactTextString(m) }
func (*ExpectedUEActivityBehaviour_ExtIEs) ProtoMessage()    {}
func (*ExpectedUEActivityBehaviour_ExtIEs) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{68}
}

func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.Unmarshal(m, b)
}
func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.Marshal(b, m, deterministic)
}
func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.Merge(m, src)
}
func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_Size() int {
        return xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.Size(m)
}
func (m *ExpectedUEActivityBehaviour_ExtIEs) XXX_DiscardUnknown() {
        xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs.DiscardUnknown(m)
}

var xxx_messageInfo_ExpectedUEActivityBehaviour_ExtIEs proto.InternalMessageInfo

type ExpectedHOInterval struct {
        Value                ExpectedHOInterval_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.ExpectedHOInterval_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
        XXX_unrecognized     []byte                   `json:"-"`
        XXX_sizecache        int32                    `json:"-"`
}

func (m *ExpectedHOInterval) Reset()         { *m = ExpectedHOInterval{} }
func (m *ExpectedHOInterval) String() string { return proto.CompactTextString(m) }
func (*ExpectedHOInterval) ProtoMessage()    {}
func (*ExpectedHOInterval) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{69}
}

func (m *ExpectedHOInterval) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_ExpectedHOInterval.Unmarshal(m, b)
}
func (m *ExpectedHOInterval) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_ExpectedHOInterval.Marshal(b, m, deterministic)
}
func (m *ExpectedHOInterval) XXX_Merge(src proto.Message) {
        xxx_messageInfo_ExpectedHOInterval.Merge(m, src)
}
func (m *ExpectedHOInterval) XXX_Size() int {
        return xxx_messageInfo_ExpectedHOInterval.Size(m)
}
func (m *ExpectedHOInterval) XXX_DiscardUnknown() {
        xxx_messageInfo_ExpectedHOInterval.DiscardUnknown(m)
}

var xxx_messageInfo_ExpectedHOInterval proto.InternalMessageInfo

func (m *ExpectedHOInterval) GetValue() ExpectedHOInterval_Value {
        if m != nil {
                return m.Value
        }
        return ExpectedHOInterval_protobuf_unspecified
}

type SourceOfUEActivityBehaviourInformation struct {
        Value                SourceOfUEActivityBehaviourInformation_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.SourceOfUEActivityBehaviourInformation_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                                     `json:"-"`
        XXX_unrecognized     []byte                                       `json:"-"`
        XXX_sizecache        int32                                        `json:"-"`
}

func (m *SourceOfUEActivityBehaviourInformation) Reset() {
        *m = SourceOfUEActivityBehaviourInformation{}
}
func (m *SourceOfUEActivityBehaviourInformation) String() string { return proto.CompactTextString(m) }
func (*SourceOfUEActivityBehaviourInformation) ProtoMessage()    {}
func (*SourceOfUEActivityBehaviourInformation) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{70}
}

func (m *SourceOfUEActivityBehaviourInformation) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_SourceOfUEActivityBehaviourInformation.Unmarshal(m, b)
}
func (m *SourceOfUEActivityBehaviourInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_SourceOfUEActivityBehaviourInformation.Marshal(b, m, deterministic)
}
func (m *SourceOfUEActivityBehaviourInformation) XXX_Merge(src proto.Message) {
        xxx_messageInfo_SourceOfUEActivityBehaviourInformation.Merge(m, src)
}
func (m *SourceOfUEActivityBehaviourInformation) XXX_Size() int {
        return xxx_messageInfo_SourceOfUEActivityBehaviourInformation.Size(m)
}
func (m *SourceOfUEActivityBehaviourInformation) XXX_DiscardUnknown() {
        xxx_messageInfo_SourceOfUEActivityBehaviourInformation.DiscardUnknown(m)
}

var xxx_messageInfo_SourceOfUEActivityBehaviourInformation proto.InternalMessageInfo

func (m *SourceOfUEActivityBehaviourInformation) GetValue() SourceOfUEActivityBehaviourInformation_Value {
        if m != nil {
                return m.Value
        }
        return SourceOfUEActivityBehaviourInformation_protobuf_unspecified
}

type SGNB_Addition_Trigger_Ind struct {
        Value                SGNB_Addition_Trigger_Ind_Value `protobuf:"varint,1,opt,name=value,proto3,enum=streaming_protobufs.SGNB_Addition_Trigger_Ind_Value" json:"value,omitempty"`
        XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
        XXX_unrecognized     []byte                          `json:"-"`
        XXX_sizecache        int32                           `json:"-"`
}

func (m *SGNB_Addition_Trigger_Ind) Reset()         { *m = SGNB_Addition_Trigger_Ind{} }
func (m *SGNB_Addition_Trigger_Ind) String() string { return proto.CompactTextString(m) }
func (*SGNB_Addition_Trigger_Ind) ProtoMessage()    {}
func (*SGNB_Addition_Trigger_Ind) Descriptor() ([]byte, []int) {
        return fileDescriptor_e082a304e8406c6c, []int{71}
}

func (m *SGNB_Addition_Trigger_Ind) XXX_Unmarshal(b []byte) error {
        return xxx_messageInfo_SGNB_Addition_Trigger_Ind.Unmarshal(m, b)
}
func (m *SGNB_Addition_Trigger_Ind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
        return xxx_messageInfo_SGNB_Addition_Trigger_Ind.Marshal(b, m, deterministic)
}
func (m *SGNB_Addition_Trigger_Ind) XXX_Merge(src proto.Message) {
        xxx_messageInfo_SGNB_Addition_Trigger_Ind.Merge(m, src)
}
func (m *SGNB_Addition_Trigger_Ind) XXX_Size() int {
        return xxx_messageInfo_SGNB_Addition_Trigger_Ind.Size(m)
}
func (m *SGNB_Addition_Trigger_Ind) XXX_DiscardUnknown() {
        xxx_messageInfo_SGNB_Addition_Trigger_Ind.DiscardUnknown(m)
}

var xxx_messageInfo_SGNB_Addition_Trigger_Ind proto.InternalMessageInfo

func (m *SGNB_Addition_Trigger_Ind) GetValue() SGNB_Addition_Trigger_Ind_Value {
        if m != nil {
                return m.Value
        }
        return SGNB_Addition_Trigger_Ind_protobuf_unspecified
}

func init() {
        proto.RegisterEnum("streaming_protobufs.EN_DC_ResourceConfiguration_Status", EN_DC_ResourceConfiguration_Status_name, EN_DC_ResourceConfiguration_Status_value)
        proto.RegisterEnum("streaming_protobufs.PreEmptionVulnerability_Value", PreEmptionVulnerability_Value_name, PreEmptionVulnerability_Value_value)
        proto.RegisterEnum("streaming_protobufs.PreEmptionCapability_Value", PreEmptionCapability_Value_name, PreEmptionCapability_Value_value)
        proto.RegisterEnum("streaming_protobufs.RLCMode_Value", RLCMode_Value_name, RLCMode_Value_value)
        proto.RegisterEnum("streaming_protobufs.RLC_Status_Reestablishment_Indication", RLC_Status_Reestablishment_Indication_name, RLC_Status_Reestablishment_Indication_value)
        proto.RegisterEnum("streaming_protobufs.ULConfiguration_UL_UE_Configuration", ULConfiguration_UL_UE_Configuration_name, ULConfiguration_UL_UE_Configuration_value)
        proto.RegisterEnum("streaming_protobufs.PDCPSnLength_Value", PDCPSnLength_Value_name, PDCPSnLength_Value_value)
        proto.RegisterEnum("streaming_protobufs.PDCPChangeIndication_Value", PDCPChangeIndication_Value_name, PDCPChangeIndication_Value_value)
        proto.RegisterEnum("streaming_protobufs.SplitSRBs_Value", SplitSRBs_Value_name, SplitSRBs_Value_value)
        proto.RegisterEnum("streaming_protobufs.UserPlaneTrafficActivityReport_Value", UserPlaneTrafficActivityReport_Value_name, UserPlaneTrafficActivityReport_Value_value)
        proto.RegisterEnum("streaming_protobufs.GNBOverloadInformation_Value", GNBOverloadInformation_Value_name, GNBOverloadInformation_Value_value)
        proto.RegisterEnum("streaming_protobufs.TriggeringMessage_Value", TriggeringMessage_Value_name, TriggeringMessage_Value_value)
        proto.RegisterEnum("streaming_protobufs.Criticality_Value", Criticality_Value_name, Criticality_Value_value)
        proto.RegisterEnum("streaming_protobufs.TypeOfError_Value", TypeOfError_Value_name, TypeOfError_Value_value)
        proto.RegisterEnum("streaming_protobufs.SgNBCoordinationAssistanceInformation_Value", SgNBCoordinationAssistanceInformation_Value_name, SgNBCoordinationAssistanceInformation_Value_value)
        proto.RegisterEnum("streaming_protobufs.RRC_Config_Ind_Value", RRC_Config_Ind_Value_name, RRC_Config_Ind_Value_value)
        proto.RegisterEnum("streaming_protobufs.ForbiddenInterRATs_Value", ForbiddenInterRATs_Value_name, ForbiddenInterRATs_Value_value)
        proto.RegisterEnum("streaming_protobufs.NRrestrictioninEPSasSecondaryRAT_Value", NRrestrictioninEPSasSecondaryRAT_Value_name, NRrestrictioninEPSasSecondaryRAT_Value_value)
        proto.RegisterEnum("streaming_protobufs.CNTypeRestrictionsItem_CNType", CNTypeRestrictionsItem_CNType_name, CNTypeRestrictionsItem_CNType_value)
        proto.RegisterEnum("streaming_protobufs.NRrestrictionin5GS_Value", NRrestrictionin5GS_Value_name, NRrestrictionin5GS_Value_value)
        proto.RegisterEnum("streaming_protobufs.DL_Forwarding_Value", DL_Forwarding_Value_name, DL_Forwarding_Value_value)
        proto.RegisterEnum("streaming_protobufs.DuplicationActivation_Value", DuplicationActivation_Value_name, DuplicationActivation_Value_value)
        proto.RegisterEnum("streaming_protobufs.MeNBCoordinationAssistanceInformation_Value", MeNBCoordinationAssistanceInformation_Value_name, MeNBCoordinationAssistanceInformation_Value_value)
        proto.RegisterEnum("streaming_protobufs.ExpectedHOInterval_Value", ExpectedHOInterval_Value_name, ExpectedHOInterval_Value_value)
        proto.RegisterEnum("streaming_protobufs.SourceOfUEActivityBehaviourInformation_Value", SourceOfUEActivityBehaviourInformation_Value_name, SourceOfUEActivityBehaviourInformation_Value_value)
        proto.RegisterEnum("streaming_protobufs.SGNB_Addition_Trigger_Ind_Value", SGNB_Addition_Trigger_Ind_Value_name, SGNB_Addition_Trigger_Ind_Value_value)
        proto.RegisterType((*EN_DC_ResourceConfiguration)(nil), "streaming_protobufs.EN_DC_ResourceConfiguration")
        proto.RegisterType((*E_RAB_Level_QoS_Parameters)(nil), "streaming_protobufs.E_RAB_Level_QoS_Parameters")
        proto.RegisterType((*AllocationAndRetentionPriority)(nil), "streaming_protobufs.AllocationAndRetentionPriority")
        proto.RegisterType((*PreEmptionVulnerability)(nil), "streaming_protobufs.Pre_emptionVulnerability")
        proto.RegisterType((*PreEmptionCapability)(nil), "streaming_protobufs.Pre_emptionCapability")
        proto.RegisterType((*E_RAB_Level_QoS_Parameters_ExtIEs)(nil), "streaming_protobufs.E_RAB_Level_QoS_Parameters_ExtIEs")
        proto.RegisterType((*GBR_QosInformation)(nil), "streaming_protobufs.GBR_QosInformation")
        proto.RegisterType((*GBR_QosInformation_ExtIEs)(nil), "streaming_protobufs.GBR_QosInformation_ExtIEs")
        proto.RegisterType((*GlobalGNB_ID)(nil), "streaming_protobufs.GlobalGNB_ID")
        proto.RegisterType((*GNB_ID)(nil), "streaming_protobufs.GNB_ID")
        proto.RegisterType((*GlobalGNB_ID_ExtIEs)(nil), "streaming_protobufs.GlobalGNB_ID_ExtIEs")
        proto.RegisterType((*GTPtunnelEndpoint)(nil), "streaming_protobufs.GTPtunnelEndpoint")
        proto.RegisterType((*GTPtunnelEndpoint_ExtIEs)(nil), "streaming_protobufs.GTPtunnelEndpoint_ExtIEs")
        proto.RegisterType((*RLCMode)(nil), "streaming_protobufs.RLCMode")
        proto.RegisterType((*RLC_Status)(nil), "streaming_protobufs.RLC_Status")
        proto.RegisterType((*ULConfiguration)(nil), "streaming_protobufs.ULConfiguration")
        proto.RegisterType((*PDCPSnLength)(nil), "streaming_protobufs.PDCPSnLength")
        proto.RegisterType((*PDCPChangeIndication)(nil), "streaming_protobufs.PDCPChangeIndication")
        proto.RegisterType((*SplitSRBs)(nil), "streaming_protobufs.SplitSRBs")
        proto.RegisterType((*NRCGI)(nil), "streaming_protobufs.NRCGI")
        proto.RegisterType((*NRCGI_ExtIEs)(nil), "streaming_protobufs.NRCGI_ExtIEs")
        proto.RegisterType((*ECGI)(nil), "streaming_protobufs.ECGI")
        proto.RegisterType((*E_RAB_List)(nil), "streaming_protobufs.E_RAB_List")
        proto.RegisterType((*E_RAB_ItemIEs)(nil), "streaming_protobufs.E_RAB_ItemIEs")
        proto.RegisterType((*E_RAB_Item)(nil), "streaming_protobufs.E_RAB_Item")
        proto.RegisterType((*ERABActivityNotifyItemList)(nil), "streaming_protobufs.ERABActivityNotifyItemList")
        proto.RegisterType((*ERABActivityNotifyItem)(nil), "streaming_protobufs.ERABActivityNotifyItem")
        proto.RegisterType((*ERABActivityNotifyItem_ExtIEs)(nil), "streaming_protobufs.ERABActivityNotifyItem_ExtIEs")
        proto.RegisterType((*UserPlaneTrafficActivityReport)(nil), "streaming_protobufs.UserPlaneTrafficActivityReport")
        proto.RegisterType((*GNBOverloadInformation)(nil), "streaming_protobufs.GNBOverloadInformation")
        proto.RegisterType((*CriticalityDiagnostics)(nil), "streaming_protobufs.CriticalityDiagnostics")
        proto.RegisterType((*TriggeringMessage)(nil), "streaming_protobufs.TriggeringMessage")
        proto.RegisterType((*Criticality)(nil), "streaming_protobufs.Criticality")
        proto.RegisterType((*CriticalityDiagnostics_IE_List)(nil), "streaming_protobufs.CriticalityDiagnostics_IE_List")
        proto.RegisterType((*CriticalityDiagnostics_IE_List_Item)(nil), "streaming_protobufs.CriticalityDiagnostics_IE_List_Item")
        proto.RegisterType((*TypeOfError)(nil), "streaming_protobufs.TypeOfError")
        proto.RegisterType((*CriticalityDiagnostics_ExtIEs)(nil), "streaming_protobufs.CriticalityDiagnostics_ExtIEs")
        proto.RegisterType((*SgNBResourceCoordinationInformation)(nil), "streaming_protobufs.SgNBResourceCoordinationInformation")
        proto.RegisterType((*SgNBResourceCoordinationInformationExtIEs)(nil), "streaming_protobufs.SgNBResourceCoordinationInformationExtIEs")
        proto.RegisterType((*SgNBCoordinationAssistanceInformation)(nil), "streaming_protobufs.SgNBCoordinationAssistanceInformation")
        proto.RegisterType((*RRC_Config_Ind)(nil), "streaming_protobufs.RRC_Config_Ind")
        proto.RegisterType((*HandoverRestrictionList)(nil), "streaming_protobufs.HandoverRestrictionList")
        proto.RegisterType((*EPLMNs)(nil), "streaming_protobufs.EPLMNs")
        proto.RegisterType((*ForbiddenTAs)(nil), "streaming_protobufs.ForbiddenTAs")
        proto.RegisterType((*ForbiddenTAs_Item)(nil), "streaming_protobufs.ForbiddenTAs_Item")
        proto.RegisterType((*ForbiddenTACs)(nil), "streaming_protobufs.ForbiddenTACs")
        proto.RegisterType((*ForbiddenLAs)(nil), "streaming_protobufs.ForbiddenLAs")
        proto.RegisterType((*ForbiddenLAs_Item)(nil), "streaming_protobufs.ForbiddenLAs_Item")
        proto.RegisterType((*ForbiddenLACs)(nil), "streaming_protobufs.ForbiddenLACs")
        proto.RegisterType((*ForbiddenInterRATs)(nil), "streaming_protobufs.ForbiddenInterRATs")
        proto.RegisterType((*HandoverRestrictionList_ExtIEs)(nil), "streaming_protobufs.HandoverRestrictionList_ExtIEs")
        proto.RegisterType((*NRrestrictioninEPSasSecondaryRAT)(nil), "streaming_protobufs.NRrestrictioninEPSasSecondaryRAT")
        proto.RegisterType((*CNTypeRestrictions)(nil), "streaming_protobufs.CNTypeRestrictions")
        proto.RegisterType((*CNTypeRestrictionsItem)(nil), "streaming_protobufs.CNTypeRestrictionsItem")
        proto.RegisterType((*NRrestrictionin5GS)(nil), "streaming_protobufs.NRrestrictionin5GS")
        proto.RegisterType((*NRUESecurityCapabilities)(nil), "streaming_protobufs.NRUESecurityCapabilities")
        proto.RegisterType((*UEAggregateMaximumBitRate)(nil), "streaming_protobufs.UEAggregateMaximumBitRate")
        proto.RegisterType((*UEAggregate_MaximumBitrate_ExtIEs)(nil), "streaming_protobufs.UEAggregate_MaximumBitrate_ExtIEs")
        proto.RegisterType((*DL_Forwarding)(nil), "streaming_protobufs.DL_Forwarding")
        proto.RegisterType((*DuplicationActivation)(nil), "streaming_protobufs.DuplicationActivation")
        proto.RegisterType((*MeNBResourceCoordinationInformation)(nil), "streaming_protobufs.MeNBResourceCoordinationInformation")
        proto.RegisterType((*MeNBResourceCoordinationInformationExtIEs)(nil), "streaming_protobufs.MeNBResourceCoordinationInformationExtIEs")
        proto.RegisterType((*MeNBCoordinationAssistanceInformation)(nil), "streaming_protobufs.MeNBCoordinationAssistanceInformation")
        proto.RegisterType((*COUNTvalue)(nil), "streaming_protobufs.COUNTvalue")
        proto.RegisterType((*COUNTValueExtended)(nil), "streaming_protobufs.COUNTValueExtended")
        proto.RegisterType((*COUNTvaluePDCP_SNlength18)(nil), "streaming_protobufs.COUNTvaluePDCP_SNlength18")
        proto.RegisterType((*ExpectedUEBehaviour)(nil), "streaming_protobufs.ExpectedUEBehaviour")
        proto.RegisterType((*ExpectedUEActivityBehaviour)(nil), "streaming_protobufs.ExpectedUEActivityBehaviour")
        proto.RegisterType((*ExpectedUEActivityBehaviour_ExtIEs)(nil), "streaming_protobufs.ExpectedUEActivityBehaviour_ExtIEs")
        proto.RegisterType((*ExpectedHOInterval)(nil), "streaming_protobufs.ExpectedHOInterval")
        proto.RegisterType((*SourceOfUEActivityBehaviourInformation)(nil), "streaming_protobufs.SourceOfUEActivityBehaviourInformation")
        proto.RegisterType((*SGNB_Addition_Trigger_Ind)(nil), "streaming_protobufs.SGNB_Addition_Trigger_Ind")
}

func init() { proto.RegisterFile("x2ap_common_types.proto", fileDescriptor_e082a304e8406c6c) }

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