//
// Copyright 2019 AT&T Intellectual Property
// Copyright 2019 Nokia
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

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

package entities

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	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

// 9.2.17
type UlInterferenceOverloadIndication int32

const (
	UlInterferenceOverloadIndication_UNKNOWN_UL_INTERFERENCE_OVERLOAD_INDICATION UlInterferenceOverloadIndication = 0
	UlInterferenceOverloadIndication_HIGH_INTERFERENCE                           UlInterferenceOverloadIndication = 1
	UlInterferenceOverloadIndication_MEDIUM_INTERFERENCE                         UlInterferenceOverloadIndication = 2
	UlInterferenceOverloadIndication_LOW_INTERFERENCE                            UlInterferenceOverloadIndication = 3
)

var UlInterferenceOverloadIndication_name = map[int32]string{
	0: "UNKNOWN_UL_INTERFERENCE_OVERLOAD_INDICATION",
	1: "HIGH_INTERFERENCE",
	2: "MEDIUM_INTERFERENCE",
	3: "LOW_INTERFERENCE",
}

var UlInterferenceOverloadIndication_value = map[string]int32{
	"UNKNOWN_UL_INTERFERENCE_OVERLOAD_INDICATION": 0,
	"HIGH_INTERFERENCE":                           1,
	"MEDIUM_INTERFERENCE":                         2,
	"LOW_INTERFERENCE":                            3,
}

func (x UlInterferenceOverloadIndication) String() string {
	return proto.EnumName(UlInterferenceOverloadIndication_name, int32(x))
}

func (UlInterferenceOverloadIndication) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dbb5982ee58718b9, []int{0}
}

type RntpThreshold int32

const (
	RntpThreshold_UNKNOWN_RNTP_THRESHOLD RntpThreshold = 0
	RntpThreshold_NEG_INFINITY           RntpThreshold = 1
	RntpThreshold_NEG_11                 RntpThreshold = 2
	RntpThreshold_NEG_10                 RntpThreshold = 3
	RntpThreshold_NEG_9                  RntpThreshold = 4
	RntpThreshold_NEG_8                  RntpThreshold = 5
	RntpThreshold_NEG_7                  RntpThreshold = 6
	RntpThreshold_NEG_6                  RntpThreshold = 7
	RntpThreshold_NEG_5                  RntpThreshold = 8
	RntpThreshold_NEG_4                  RntpThreshold = 9
	RntpThreshold_NEG_3                  RntpThreshold = 10
	RntpThreshold_NEG_2                  RntpThreshold = 11
	RntpThreshold_NEG_1                  RntpThreshold = 12
	RntpThreshold_V0                     RntpThreshold = 13
	RntpThreshold_V1                     RntpThreshold = 14
	RntpThreshold_V2                     RntpThreshold = 15
	RntpThreshold_V3                     RntpThreshold = 16
)

var RntpThreshold_name = map[int32]string{
	0:  "UNKNOWN_RNTP_THRESHOLD",
	1:  "NEG_INFINITY",
	2:  "NEG_11",
	3:  "NEG_10",
	4:  "NEG_9",
	5:  "NEG_8",
	6:  "NEG_7",
	7:  "NEG_6",
	8:  "NEG_5",
	9:  "NEG_4",
	10: "NEG_3",
	11: "NEG_2",
	12: "NEG_1",
	13: "V0",
	14: "V1",
	15: "V2",
	16: "V3",
}

var RntpThreshold_value = map[string]int32{
	"UNKNOWN_RNTP_THRESHOLD": 0,
	"NEG_INFINITY":           1,
	"NEG_11":                 2,
	"NEG_10":                 3,
	"NEG_9":                  4,
	"NEG_8":                  5,
	"NEG_7":                  6,
	"NEG_6":                  7,
	"NEG_5":                  8,
	"NEG_4":                  9,
	"NEG_3":                  10,
	"NEG_2":                  11,
	"NEG_1":                  12,
	"V0":                     13,
	"V1":                     14,
	"V2":                     15,
	"V3":                     16,
}

func (x RntpThreshold) String() string {
	return proto.EnumName(RntpThreshold_name, int32(x))
}

func (RntpThreshold) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dbb5982ee58718b9, []int{1}
}

type NumberOfCellSpecificAntennaPorts int32

const (
	NumberOfCellSpecificAntennaPorts_UNKNOWN_NUMBER_OF_CELL_SPECIFIC_ANTENNA_PORTS NumberOfCellSpecificAntennaPorts = 0
	NumberOfCellSpecificAntennaPorts_V1_ANT_PRT                                    NumberOfCellSpecificAntennaPorts = 1
	NumberOfCellSpecificAntennaPorts_V2_ANT_PRT                                    NumberOfCellSpecificAntennaPorts = 2
	NumberOfCellSpecificAntennaPorts_V4_ANT_PRT                                    NumberOfCellSpecificAntennaPorts = 4
)

var NumberOfCellSpecificAntennaPorts_name = map[int32]string{
	0: "UNKNOWN_NUMBER_OF_CELL_SPECIFIC_ANTENNA_PORTS",
	1: "V1_ANT_PRT",
	2: "V2_ANT_PRT",
	4: "V4_ANT_PRT",
}

var NumberOfCellSpecificAntennaPorts_value = map[string]int32{
	"UNKNOWN_NUMBER_OF_CELL_SPECIFIC_ANTENNA_PORTS": 0,
	"V1_ANT_PRT": 1,
	"V2_ANT_PRT": 2,
	"V4_ANT_PRT": 4,
}

func (x NumberOfCellSpecificAntennaPorts) String() string {
	return proto.EnumName(NumberOfCellSpecificAntennaPorts_name, int32(x))
}

func (NumberOfCellSpecificAntennaPorts) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dbb5982ee58718b9, []int{2}
}

type AbsInformationMode int32

const (
	AbsInformationMode_UNKNOWN_ABS_INFORMATION_MODE AbsInformationMode = 0
	AbsInformationMode_ABS_INFO_FDD                 AbsInformationMode = 1
	AbsInformationMode_ABS_INFO_TDD                 AbsInformationMode = 2
	AbsInformationMode_ABS_INACTIVE                 AbsInformationMode = 3
)

var AbsInformationMode_name = map[int32]string{
	0: "UNKNOWN_ABS_INFORMATION_MODE",
	1: "ABS_INFO_FDD",
	2: "ABS_INFO_TDD",
	3: "ABS_INACTIVE",
}

var AbsInformationMode_value = map[string]int32{
	"UNKNOWN_ABS_INFORMATION_MODE": 0,
	"ABS_INFO_FDD":                 1,
	"ABS_INFO_TDD":                 2,
	"ABS_INACTIVE":                 3,
}

func (x AbsInformationMode) String() string {
	return proto.EnumName(AbsInformationMode_name, int32(x))
}

func (AbsInformationMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dbb5982ee58718b9, []int{3}
}

// 9.2.55
type InvokeIndication int32

const (
	InvokeIndication_UNKNOWN_INVOKE_INDICATION InvokeIndication = 0
	InvokeIndication_ABS_INFORMATION           InvokeIndication = 1
	InvokeIndication_START_NAICS_INFORMATION   InvokeIndication = 2
	InvokeIndication_STOP_NAICS_INFORMATION    InvokeIndication = 3
)

var InvokeIndication_name = map[int32]string{
	0: "UNKNOWN_INVOKE_INDICATION",
	1: "ABS_INFORMATION",
	2: "START_NAICS_INFORMATION",
	3: "STOP_NAICS_INFORMATION",
}

var InvokeIndication_value = map[string]int32{
	"UNKNOWN_INVOKE_INDICATION": 0,
	"ABS_INFORMATION":           1,
	"START_NAICS_INFORMATION":   2,
	"STOP_NAICS_INFORMATION":    3,
}

func (x InvokeIndication) String() string {
	return proto.EnumName(InvokeIndication_name, int32(x))
}

func (InvokeIndication) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dbb5982ee58718b9, []int{4}
}

type NaicsState int32

const (
	NaicsState_UNKNOWN_NAICS_STATE NaicsState = 0
	NaicsState_NAICS_ACTIVE        NaicsState = 1
	NaicsState_NAICS_INACTIVE      NaicsState = 2
)

var NaicsState_name = map[int32]string{
	0: "UNKNOWN_NAICS_STATE",
	1: "NAICS_ACTIVE",
	2: "NAICS_INACTIVE",
}

var NaicsState_value = map[string]int32{
	"UNKNOWN_NAICS_STATE": 0,
	"NAICS_ACTIVE":        1,
	"NAICS_INACTIVE":      2,
}

func (x NaicsState) String() string {
	return proto.EnumName(NaicsState_name, int32(x))
}

func (NaicsState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dbb5982ee58718b9, []int{5}
}

type PA int32

const (
	PA_UNKNOWN_PA      PA = 0
	PA_DB_NEG_6        PA = 1
	PA_DB_NEG_4_DOT_77 PA = 2
	PA_DB_NEG_3        PA = 3
	PA_DB_NEG_1_DOT_77 PA = 4
	PA_DB_0            PA = 5
	PA_DB_1            PA = 6
	PA_DB_2            PA = 7
	PA_DB_3            PA = 8
)

var PA_name = map[int32]string{
	0: "UNKNOWN_PA",
	1: "DB_NEG_6",
	2: "DB_NEG_4_DOT_77",
	3: "DB_NEG_3",
	4: "DB_NEG_1_DOT_77",
	5: "DB_0",
	6: "DB_1",
	7: "DB_2",
	8: "DB_3",
}

var PA_value = map[string]int32{
	"UNKNOWN_PA":      0,
	"DB_NEG_6":        1,
	"DB_NEG_4_DOT_77": 2,
	"DB_NEG_3":        3,
	"DB_NEG_1_DOT_77": 4,
	"DB_0":            5,
	"DB_1":            6,
	"DB_2":            7,
	"DB_3":            8,
}

func (x PA) String() string {
	return proto.EnumName(PA_name, int32(x))
}

func (PA) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dbb5982ee58718b9, []int{6}
}

// 9.1.2.1
type RanLoadInformation struct {
	LoadTimestamp        uint64                 `protobuf:"varint,1,opt,name=load_timestamp,json=loadTimestamp,proto3" json:"load_timestamp,omitempty"`
	CellLoadInfos        []*CellLoadInformation `protobuf:"bytes,2,rep,name=cell_load_infos,json=cellLoadInfos,proto3" json:"cell_load_infos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

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

var xxx_messageInfo_RanLoadInformation proto.InternalMessageInfo

func (m *RanLoadInformation) GetLoadTimestamp() uint64 {
	if m != nil {
		return m.LoadTimestamp
	}
	return 0
}

func (m *RanLoadInformation) GetCellLoadInfos() []*CellLoadInformation {
	if m != nil {
		return m.CellLoadInfos
	}
	return nil
}

type CellLoadInformation struct {
	CellId                             string                              `protobuf:"bytes,1,opt,name=cell_id,json=cellId,proto3" json:"cell_id,omitempty"`
	UlInterferenceOverloadIndications  []UlInterferenceOverloadIndication  `protobuf:"varint,2,rep,packed,name=ul_interference_overload_indications,json=ulInterferenceOverloadIndications,proto3,enum=entities.UlInterferenceOverloadIndication" json:"ul_interference_overload_indications,omitempty"`
	UlHighInterferenceInfos            []*UlHighInterferenceInformation    `protobuf:"bytes,3,rep,name=ul_high_interference_infos,json=ulHighInterferenceInfos,proto3" json:"ul_high_interference_infos,omitempty"`
	RelativeNarrowbandTxPower          *RelativeNarrowbandTxPower          `protobuf:"bytes,4,opt,name=relative_narrowband_tx_power,json=relativeNarrowbandTxPower,proto3" json:"relative_narrowband_tx_power,omitempty"`
	AbsInformation                     *AbsInformation                     `protobuf:"bytes,5,opt,name=abs_information,json=absInformation,proto3" json:"abs_information,omitempty"`
	InvokeIndication                   InvokeIndication                    `protobuf:"varint,6,opt,name=invoke_indication,json=invokeIndication,proto3,enum=entities.InvokeIndication" json:"invoke_indication,omitempty"`
	IntendedUlDlConfiguration          SubframeAssignment                  `protobuf:"varint,7,opt,name=intended_ul_dl_configuration,json=intendedUlDlConfiguration,proto3,enum=entities.SubframeAssignment" json:"intended_ul_dl_configuration,omitempty"`
	ExtendedUlInterferenceOverloadInfo *ExtendedUlInterferenceOverloadInfo `protobuf:"bytes,8,opt,name=extended_ul_interference_overload_info,json=extendedUlInterferenceOverloadInfo,proto3" json:"extended_ul_interference_overload_info,omitempty"`
	CompInformation                    *CompInformation                    `protobuf:"bytes,9,opt,name=comp_information,json=compInformation,proto3" json:"comp_information,omitempty"`
	DynamicDlTransmissionInformation   *DynamicDlTransmissionInformation   `protobuf:"bytes,10,opt,name=dynamic_dl_transmission_information,json=dynamicDlTransmissionInformation,proto3" json:"dynamic_dl_transmission_information,omitempty"`
	XXX_NoUnkeyedLiteral               struct{}                            `json:"-"`
	XXX_unrecognized                   []byte                              `json:"-"`
	XXX_sizecache                      int32                               `json:"-"`
}

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

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

var xxx_messageInfo_CellLoadInformation proto.InternalMessageInfo

func (m *CellLoadInformation) GetCellId() string {
	if m != nil {
		return m.CellId
	}
	return ""
}

func (m *CellLoadInformation) GetUlInterferenceOverloadIndications() []UlInterferenceOverloadIndication {
	if m != nil {
		return m.UlInterferenceOverloadIndications
	}
	return nil
}

func (m *CellLoadInformation) GetUlHighInterferenceInfos() []*UlHighInterferenceInformation {
	if m != nil {
		return m.UlHighInterferenceInfos
	}
	return nil
}

func (m *CellLoadInformation) GetRelativeNarrowbandTxPower() *RelativeNarrowbandTxPower {
	if m != nil {
		return m.RelativeNarrowbandTxPower
	}
	return nil
}

func (m *CellLoadInformation) GetAbsInformation() *AbsInformation {
	if m != nil {
		return m.AbsInformation
	}
	return nil
}

func (m *CellLoadInformation) GetInvokeIndication() InvokeIndication {
	if m != nil {
		return m.InvokeIndication
	}
	return InvokeIndication_UNKNOWN_INVOKE_INDICATION
}

func (m *CellLoadInformation) GetIntendedUlDlConfiguration() SubframeAssignment {
	if m != nil {
		return m.IntendedUlDlConfiguration
	}
	return SubframeAssignment_UNKNOWN_SUBFRAME_ASSIGNMENT
}

func (m *CellLoadInformation) GetExtendedUlInterferenceOverloadInfo() *ExtendedUlInterferenceOverloadInfo {
	if m != nil {
		return m.ExtendedUlInterferenceOverloadInfo
	}
	return nil
}

func (m *CellLoadInformation) GetCompInformation() *CompInformation {
	if m != nil {
		return m.CompInformation
	}
	return nil
}

func (m *CellLoadInformation) GetDynamicDlTransmissionInformation() *DynamicDlTransmissionInformation {
	if m != nil {
		return m.DynamicDlTransmissionInformation
	}
	return nil
}

// 9.2.18
type UlHighInterferenceInformation struct {
	TargetCellId                 string   `protobuf:"bytes,1,opt,name=target_cell_id,json=targetCellId,proto3" json:"target_cell_id,omitempty"`
	UlHighInterferenceIndication string   `protobuf:"bytes,2,opt,name=ul_high_interference_indication,json=ulHighInterferenceIndication,proto3" json:"ul_high_interference_indication,omitempty"`
	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
	XXX_unrecognized             []byte   `json:"-"`
	XXX_sizecache                int32    `json:"-"`
}

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

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

var xxx_messageInfo_UlHighInterferenceInformation proto.InternalMessageInfo

func (m *UlHighInterferenceInformation) GetTargetCellId() string {
	if m != nil {
		return m.TargetCellId
	}
	return ""
}

func (m *UlHighInterferenceInformation) GetUlHighInterferenceIndication() string {
	if m != nil {
		return m.UlHighInterferenceIndication
	}
	return ""
}

// 9.2.19
type RelativeNarrowbandTxPower struct {
	RntpPerPrb                       string                           `protobuf:"bytes,1,opt,name=rntp_per_prb,json=rntpPerPrb,proto3" json:"rntp_per_prb,omitempty"`
	RntpThreshold                    RntpThreshold                    `protobuf:"varint,2,opt,name=rntp_threshold,json=rntpThreshold,proto3,enum=entities.RntpThreshold" json:"rntp_threshold,omitempty"`
	NumberOfCellSpecificAntennaPorts NumberOfCellSpecificAntennaPorts `protobuf:"varint,3,opt,name=number_of_cell_specific_antenna_ports,json=numberOfCellSpecificAntennaPorts,proto3,enum=entities.NumberOfCellSpecificAntennaPorts" json:"number_of_cell_specific_antenna_ports,omitempty"`
	PB                               uint32                           `protobuf:"varint,4,opt,name=p_b,json=pB,proto3" json:"p_b,omitempty"`
	PdcchInterferenceImpact          uint32                           `protobuf:"varint,5,opt,name=pdcch_interference_impact,json=pdcchInterferenceImpact,proto3" json:"pdcch_interference_impact,omitempty"`
	EnhancedRntp                     *EnhancedRntp                    `protobuf:"bytes,6,opt,name=enhanced_rntp,json=enhancedRntp,proto3" json:"enhanced_rntp,omitempty"`
	XXX_NoUnkeyedLiteral             struct{}                         `json:"-"`
	XXX_unrecognized                 []byte                           `json:"-"`
	XXX_sizecache                    int32                            `json:"-"`
}

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

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

var xxx_messageInfo_RelativeNarrowbandTxPower proto.InternalMessageInfo

func (m *RelativeNarrowbandTxPower) GetRntpPerPrb() string {
	if m != nil {
		return m.RntpPerPrb
	}
	return ""
}

func (m *RelativeNarrowbandTxPower) GetRntpThreshold() RntpThreshold {
	if m != nil {
		return m.RntpThreshold
	}
	return RntpThreshold_UNKNOWN_RNTP_THRESHOLD
}

func (m *RelativeNarrowbandTxPower) GetNumberOfCellSpecificAntennaPorts() NumberOfCellSpecificAntennaPorts {
	if m != nil {
		return m.NumberOfCellSpecificAntennaPorts
	}
	return NumberOfCellSpecificAntennaPorts_UNKNOWN_NUMBER_OF_CELL_SPECIFIC_ANTENNA_PORTS
}

func (m *RelativeNarrowbandTxPower) GetPB() uint32 {
	if m != nil {
		return m.PB
	}
	return 0
}

func (m *RelativeNarrowbandTxPower) GetPdcchInterferenceImpact() uint32 {
	if m != nil {
		return m.PdcchInterferenceImpact
	}
	return 0
}

func (m *RelativeNarrowbandTxPower) GetEnhancedRntp() *EnhancedRntp {
	if m != nil {
		return m.EnhancedRntp
	}
	return nil
}

type EnhancedRntp struct {
	EnhancedRntpBitmap     string        `protobuf:"bytes,1,opt,name=enhanced_rntp_bitmap,json=enhancedRntpBitmap,proto3" json:"enhanced_rntp_bitmap,omitempty"`
	RntpHighPowerThreshold RntpThreshold `protobuf:"varint,2,opt,name=rntp_high_power_threshold,json=rntpHighPowerThreshold,proto3,enum=entities.RntpThreshold" json:"rntp_high_power_threshold,omitempty"`
	EnhancedRntpStartTime  *StartTime    `protobuf:"bytes,3,opt,name=enhanced_rntp_start_time,json=enhancedRntpStartTime,proto3" json:"enhanced_rntp_start_time,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}      `json:"-"`
	XXX_unrecognized       []byte        `json:"-"`
	XXX_sizecache          int32         `json:"-"`
}

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

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

var xxx_messageInfo_EnhancedRntp proto.InternalMessageInfo

func (m *EnhancedRntp) GetEnhancedRntpBitmap() string {
	if m != nil {
		return m.EnhancedRntpBitmap
	}
	return ""
}

func (m *EnhancedRntp) GetRntpHighPowerThreshold() RntpThreshold {
	if m != nil {
		return m.RntpHighPowerThreshold
	}
	return RntpThreshold_UNKNOWN_RNTP_THRESHOLD
}

func (m *EnhancedRntp) GetEnhancedRntpStartTime() *StartTime {
	if m != nil {
		return m.EnhancedRntpStartTime
	}
	return nil
}

type StartTime struct {
	StartSfn             int32    `protobuf:"varint,1,opt,name=start_sfn,json=startSfn,proto3" json:"start_sfn,omitempty"`
	StartSubframeNumber  int32    `protobuf:"varint,2,opt,name=start_subframe_number,json=startSubframeNumber,proto3" json:"start_subframe_number,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_StartTime proto.InternalMessageInfo

func (m *StartTime) GetStartSfn() int32 {
	if m != nil {
		return m.StartSfn
	}
	return 0
}

func (m *StartTime) GetStartSubframeNumber() int32 {
	if m != nil {
		return m.StartSubframeNumber
	}
	return 0
}

// 9.2.54
type AbsInformation struct {
	Mode                             AbsInformationMode               `protobuf:"varint,1,opt,name=mode,proto3,enum=entities.AbsInformationMode" json:"mode,omitempty"`
	AbsPatternInfo                   string                           `protobuf:"bytes,2,opt,name=abs_pattern_info,json=absPatternInfo,proto3" json:"abs_pattern_info,omitempty"`
	NumberOfCellSpecificAntennaPorts NumberOfCellSpecificAntennaPorts `protobuf:"varint,3,opt,name=number_of_cell_specific_antenna_ports,json=numberOfCellSpecificAntennaPorts,proto3,enum=entities.NumberOfCellSpecificAntennaPorts" json:"number_of_cell_specific_antenna_ports,omitempty"`
	MeasurementSubset                string                           `protobuf:"bytes,4,opt,name=measurement_subset,json=measurementSubset,proto3" json:"measurement_subset,omitempty"`
	XXX_NoUnkeyedLiteral             struct{}                         `json:"-"`
	XXX_unrecognized                 []byte                           `json:"-"`
	XXX_sizecache                    int32                            `json:"-"`
}

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

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

var xxx_messageInfo_AbsInformation proto.InternalMessageInfo

func (m *AbsInformation) GetMode() AbsInformationMode {
	if m != nil {
		return m.Mode
	}
	return AbsInformationMode_UNKNOWN_ABS_INFORMATION_MODE
}

func (m *AbsInformation) GetAbsPatternInfo() string {
	if m != nil {
		return m.AbsPatternInfo
	}
	return ""
}

func (m *AbsInformation) GetNumberOfCellSpecificAntennaPorts() NumberOfCellSpecificAntennaPorts {
	if m != nil {
		return m.NumberOfCellSpecificAntennaPorts
	}
	return NumberOfCellSpecificAntennaPorts_UNKNOWN_NUMBER_OF_CELL_SPECIFIC_ANTENNA_PORTS
}

func (m *AbsInformation) GetMeasurementSubset() string {
	if m != nil {
		return m.MeasurementSubset
	}
	return ""
}

// 9.2.67
type ExtendedUlInterferenceOverloadInfo struct {
	AssociatedSubframes                       string                             `protobuf:"bytes,1,opt,name=associated_subframes,json=associatedSubframes,proto3" json:"associated_subframes,omitempty"`
	ExtendedUlInterferenceOverloadIndications []UlInterferenceOverloadIndication `protobuf:"varint,2,rep,packed,name=extended_ul_interference_overload_indications,json=extendedUlInterferenceOverloadIndications,proto3,enum=entities.UlInterferenceOverloadIndication" json:"extended_ul_interference_overload_indications,omitempty"`
	XXX_NoUnkeyedLiteral                      struct{}                           `json:"-"`
	XXX_unrecognized                          []byte                             `json:"-"`
	XXX_sizecache                             int32                              `json:"-"`
}

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

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

var xxx_messageInfo_ExtendedUlInterferenceOverloadInfo proto.InternalMessageInfo

func (m *ExtendedUlInterferenceOverloadInfo) GetAssociatedSubframes() string {
	if m != nil {
		return m.AssociatedSubframes
	}
	return ""
}

func (m *ExtendedUlInterferenceOverloadInfo) GetExtendedUlInterferenceOverloadIndications() []UlInterferenceOverloadIndication {
	if m != nil {
		return m.ExtendedUlInterferenceOverloadIndications
	}
	return nil
}

// 9.2.74
type CompInformation struct {
	CompInformationItems     []*CompInformationItem `protobuf:"bytes,1,rep,name=comp_information_items,json=compInformationItems,proto3" json:"comp_information_items,omitempty"`
	CompInformationStartTime *StartTime             `protobuf:"bytes,2,opt,name=comp_information_start_time,json=compInformationStartTime,proto3" json:"comp_information_start_time,omitempty"`
	XXX_NoUnkeyedLiteral     struct{}               `json:"-"`
	XXX_unrecognized         []byte                 `json:"-"`
	XXX_sizecache            int32                  `json:"-"`
}

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

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

var xxx_messageInfo_CompInformation proto.InternalMessageInfo

func (m *CompInformation) GetCompInformationItems() []*CompInformationItem {
	if m != nil {
		return m.CompInformationItems
	}
	return nil
}

func (m *CompInformation) GetCompInformationStartTime() *StartTime {
	if m != nil {
		return m.CompInformationStartTime
	}
	return nil
}

type CompInformationItem struct {
	CompHypothesisSets   []*CompHypothesisSet `protobuf:"bytes,1,rep,name=comp_hypothesis_sets,json=compHypothesisSets,proto3" json:"comp_hypothesis_sets,omitempty"`
	BenefitMetric        int32                `protobuf:"varint,2,opt,name=benefit_metric,json=benefitMetric,proto3" json:"benefit_metric,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_CompInformationItem proto.InternalMessageInfo

func (m *CompInformationItem) GetCompHypothesisSets() []*CompHypothesisSet {
	if m != nil {
		return m.CompHypothesisSets
	}
	return nil
}

func (m *CompInformationItem) GetBenefitMetric() int32 {
	if m != nil {
		return m.BenefitMetric
	}
	return 0
}

type CompHypothesisSet struct {
	CellId               string   `protobuf:"bytes,1,opt,name=cell_id,json=cellId,proto3" json:"cell_id,omitempty"`
	CompHypothesis       string   `protobuf:"bytes,2,opt,name=comp_hypothesis,json=compHypothesis,proto3" json:"comp_hypothesis,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CompHypothesisSet proto.InternalMessageInfo

func (m *CompHypothesisSet) GetCellId() string {
	if m != nil {
		return m.CellId
	}
	return ""
}

func (m *CompHypothesisSet) GetCompHypothesis() string {
	if m != nil {
		return m.CompHypothesis
	}
	return ""
}

// 9.2.77
type DynamicDlTransmissionInformation struct {
	State                NaicsState `protobuf:"varint,1,opt,name=state,proto3,enum=entities.NaicsState" json:"state,omitempty"`
	TransmissionModes    string     `protobuf:"bytes,2,opt,name=transmission_modes,json=transmissionModes,proto3" json:"transmission_modes,omitempty"`
	PB                   uint32     `protobuf:"varint,3,opt,name=p_b,json=pB,proto3" json:"p_b,omitempty"`
	PAList               []PA       `protobuf:"varint,4,rep,packed,name=p_a_list,json=pAList,proto3,enum=entities.PA" json:"p_a_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_DynamicDlTransmissionInformation proto.InternalMessageInfo

func (m *DynamicDlTransmissionInformation) GetState() NaicsState {
	if m != nil {
		return m.State
	}
	return NaicsState_UNKNOWN_NAICS_STATE
}

func (m *DynamicDlTransmissionInformation) GetTransmissionModes() string {
	if m != nil {
		return m.TransmissionModes
	}
	return ""
}

func (m *DynamicDlTransmissionInformation) GetPB() uint32 {
	if m != nil {
		return m.PB
	}
	return 0
}

func (m *DynamicDlTransmissionInformation) GetPAList() []PA {
	if m != nil {
		return m.PAList
	}
	return nil
}

func init() {
	proto.RegisterEnum("entities.UlInterferenceOverloadIndication", UlInterferenceOverloadIndication_name, UlInterferenceOverloadIndication_value)
	proto.RegisterEnum("entities.RntpThreshold", RntpThreshold_name, RntpThreshold_value)
	proto.RegisterEnum("entities.NumberOfCellSpecificAntennaPorts", NumberOfCellSpecificAntennaPorts_name, NumberOfCellSpecificAntennaPorts_value)
	proto.RegisterEnum("entities.AbsInformationMode", AbsInformationMode_name, AbsInformationMode_value)
	proto.RegisterEnum("entities.InvokeIndication", InvokeIndication_name, InvokeIndication_value)
	proto.RegisterEnum("entities.NaicsState", NaicsState_name, NaicsState_value)
	proto.RegisterEnum("entities.PA", PA_name, PA_value)
	proto.RegisterType((*RanLoadInformation)(nil), "entities.RanLoadInformation")
	proto.RegisterType((*CellLoadInformation)(nil), "entities.CellLoadInformation")
	proto.RegisterType((*UlHighInterferenceInformation)(nil), "entities.UlHighInterferenceInformation")
	proto.RegisterType((*RelativeNarrowbandTxPower)(nil), "entities.RelativeNarrowbandTxPower")
	proto.RegisterType((*EnhancedRntp)(nil), "entities.EnhancedRntp")
	proto.RegisterType((*StartTime)(nil), "entities.StartTime")
	proto.RegisterType((*AbsInformation)(nil), "entities.AbsInformation")
	proto.RegisterType((*ExtendedUlInterferenceOverloadInfo)(nil), "entities.ExtendedUlInterferenceOverloadInfo")
	proto.RegisterType((*CompInformation)(nil), "entities.CompInformation")
	proto.RegisterType((*CompInformationItem)(nil), "entities.CompInformationItem")
	proto.RegisterType((*CompHypothesisSet)(nil), "entities.CompHypothesisSet")
	proto.RegisterType((*DynamicDlTransmissionInformation)(nil), "entities.DynamicDlTransmissionInformation")
}

func init() { proto.RegisterFile("ran_load_information.proto", fileDescriptor_dbb5982ee58718b9) }

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