go/tech_profile/tech_profile.pb.go

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

package tech_profile

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	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 Direction int32

const (
	Direction_UPSTREAM      Direction = 0
	Direction_DOWNSTREAM    Direction = 1
	Direction_BIDIRECTIONAL Direction = 2
)

var Direction_name = map[int32]string{
	0: "UPSTREAM",
	1: "DOWNSTREAM",
	2: "BIDIRECTIONAL",
}

var Direction_value = map[string]int32{
	"UPSTREAM":      0,
	"DOWNSTREAM":    1,
	"BIDIRECTIONAL": 2,
}

func (x Direction) String() string {
	return proto.EnumName(Direction_name, int32(x))
}

func (Direction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d019a68bffe14cae, []int{0}
}

type SchedulingPolicy int32

const (
	SchedulingPolicy_WRR            SchedulingPolicy = 0
	SchedulingPolicy_StrictPriority SchedulingPolicy = 1
	SchedulingPolicy_Hybrid         SchedulingPolicy = 2
)

var SchedulingPolicy_name = map[int32]string{
	0: "WRR",
	1: "StrictPriority",
	2: "Hybrid",
}

var SchedulingPolicy_value = map[string]int32{
	"WRR":            0,
	"StrictPriority": 1,
	"Hybrid":         2,
}

func (x SchedulingPolicy) String() string {
	return proto.EnumName(SchedulingPolicy_name, int32(x))
}

func (SchedulingPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d019a68bffe14cae, []int{1}
}

type AdditionalBW int32

const (
	AdditionalBW_AdditionalBW_None       AdditionalBW = 0
	AdditionalBW_AdditionalBW_NA         AdditionalBW = 1
	AdditionalBW_AdditionalBW_BestEffort AdditionalBW = 2
	AdditionalBW_AdditionalBW_Auto       AdditionalBW = 3
)

var AdditionalBW_name = map[int32]string{
	0: "AdditionalBW_None",
	1: "AdditionalBW_NA",
	2: "AdditionalBW_BestEffort",
	3: "AdditionalBW_Auto",
}

var AdditionalBW_value = map[string]int32{
	"AdditionalBW_None":       0,
	"AdditionalBW_NA":         1,
	"AdditionalBW_BestEffort": 2,
	"AdditionalBW_Auto":       3,
}

func (x AdditionalBW) String() string {
	return proto.EnumName(AdditionalBW_name, int32(x))
}

func (AdditionalBW) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d019a68bffe14cae, []int{2}
}

type DiscardPolicy int32

const (
	DiscardPolicy_TailDrop  DiscardPolicy = 0
	DiscardPolicy_WTailDrop DiscardPolicy = 1
	DiscardPolicy_Red       DiscardPolicy = 2
	DiscardPolicy_WRed      DiscardPolicy = 3
)

var DiscardPolicy_name = map[int32]string{
	0: "TailDrop",
	1: "WTailDrop",
	2: "Red",
	3: "WRed",
}

var DiscardPolicy_value = map[string]int32{
	"TailDrop":  0,
	"WTailDrop": 1,
	"Red":       2,
	"WRed":      3,
}

func (x DiscardPolicy) String() string {
	return proto.EnumName(DiscardPolicy_name, int32(x))
}

func (DiscardPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d019a68bffe14cae, []int{3}
}

type InferredAdditionBWIndication int32

const (
	InferredAdditionBWIndication_InferredAdditionBWIndication_None       InferredAdditionBWIndication = 0
	InferredAdditionBWIndication_InferredAdditionBWIndication_Assured    InferredAdditionBWIndication = 1
	InferredAdditionBWIndication_InferredAdditionBWIndication_BestEffort InferredAdditionBWIndication = 2
)

var InferredAdditionBWIndication_name = map[int32]string{
	0: "InferredAdditionBWIndication_None",
	1: "InferredAdditionBWIndication_Assured",
	2: "InferredAdditionBWIndication_BestEffort",
}

var InferredAdditionBWIndication_value = map[string]int32{
	"InferredAdditionBWIndication_None":       0,
	"InferredAdditionBWIndication_Assured":    1,
	"InferredAdditionBWIndication_BestEffort": 2,
}

func (x InferredAdditionBWIndication) String() string {
	return proto.EnumName(InferredAdditionBWIndication_name, int32(x))
}

func (InferredAdditionBWIndication) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d019a68bffe14cae, []int{4}
}

type SchedulerConfig struct {
	Direction            Direction        `protobuf:"varint,1,opt,name=direction,proto3,enum=tech_profile.Direction" json:"direction,omitempty"`
	AdditionalBw         AdditionalBW     `protobuf:"varint,2,opt,name=additional_bw,json=additionalBw,proto3,enum=tech_profile.AdditionalBW" json:"additional_bw,omitempty"`
	Priority             uint32           `protobuf:"fixed32,3,opt,name=priority,proto3" json:"priority,omitempty"`
	Weight               uint32           `protobuf:"fixed32,4,opt,name=weight,proto3" json:"weight,omitempty"`
	SchedPolicy          SchedulingPolicy `protobuf:"varint,5,opt,name=sched_policy,json=schedPolicy,proto3,enum=tech_profile.SchedulingPolicy" json:"sched_policy,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerConfig proto.InternalMessageInfo

func (m *SchedulerConfig) GetDirection() Direction {
	if m != nil {
		return m.Direction
	}
	return Direction_UPSTREAM
}

func (m *SchedulerConfig) GetAdditionalBw() AdditionalBW {
	if m != nil {
		return m.AdditionalBw
	}
	return AdditionalBW_AdditionalBW_None
}

func (m *SchedulerConfig) GetPriority() uint32 {
	if m != nil {
		return m.Priority
	}
	return 0
}

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

func (m *SchedulerConfig) GetSchedPolicy() SchedulingPolicy {
	if m != nil {
		return m.SchedPolicy
	}
	return SchedulingPolicy_WRR
}

type TrafficShapingInfo struct {
	Cir                  uint32                       `protobuf:"fixed32,1,opt,name=cir,proto3" json:"cir,omitempty"`
	Cbs                  uint32                       `protobuf:"fixed32,2,opt,name=cbs,proto3" json:"cbs,omitempty"`
	Pir                  uint32                       `protobuf:"fixed32,3,opt,name=pir,proto3" json:"pir,omitempty"`
	Pbs                  uint32                       `protobuf:"fixed32,4,opt,name=pbs,proto3" json:"pbs,omitempty"`
	Gir                  uint32                       `protobuf:"fixed32,5,opt,name=gir,proto3" json:"gir,omitempty"`
	AddBwInd             InferredAdditionBWIndication `protobuf:"varint,6,opt,name=add_bw_ind,json=addBwInd,proto3,enum=tech_profile.InferredAdditionBWIndication" json:"add_bw_ind,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

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

var xxx_messageInfo_TrafficShapingInfo proto.InternalMessageInfo

func (m *TrafficShapingInfo) GetCir() uint32 {
	if m != nil {
		return m.Cir
	}
	return 0
}

func (m *TrafficShapingInfo) GetCbs() uint32 {
	if m != nil {
		return m.Cbs
	}
	return 0
}

func (m *TrafficShapingInfo) GetPir() uint32 {
	if m != nil {
		return m.Pir
	}
	return 0
}

func (m *TrafficShapingInfo) GetPbs() uint32 {
	if m != nil {
		return m.Pbs
	}
	return 0
}

func (m *TrafficShapingInfo) GetGir() uint32 {
	if m != nil {
		return m.Gir
	}
	return 0
}

func (m *TrafficShapingInfo) GetAddBwInd() InferredAdditionBWIndication {
	if m != nil {
		return m.AddBwInd
	}
	return InferredAdditionBWIndication_InferredAdditionBWIndication_None
}

type TrafficScheduler struct {
	Direction            Direction           `protobuf:"varint,1,opt,name=direction,proto3,enum=tech_profile.Direction" json:"direction,omitempty"`
	AllocId              uint32              `protobuf:"fixed32,2,opt,name=alloc_id,json=allocId,proto3" json:"alloc_id,omitempty"`
	Scheduler            *SchedulerConfig    `protobuf:"bytes,3,opt,name=scheduler,proto3" json:"scheduler,omitempty"`
	TrafficShapingInfo   *TrafficShapingInfo `protobuf:"bytes,4,opt,name=traffic_shaping_info,json=trafficShapingInfo,proto3" json:"traffic_shaping_info,omitempty"`
	ParentSchedId        uint32              `protobuf:"fixed32,5,opt,name=parent_sched_id,json=parentSchedId,proto3" json:"parent_sched_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_TrafficScheduler proto.InternalMessageInfo

func (m *TrafficScheduler) GetDirection() Direction {
	if m != nil {
		return m.Direction
	}
	return Direction_UPSTREAM
}

func (m *TrafficScheduler) GetAllocId() uint32 {
	if m != nil {
		return m.AllocId
	}
	return 0
}

func (m *TrafficScheduler) GetScheduler() *SchedulerConfig {
	if m != nil {
		return m.Scheduler
	}
	return nil
}

func (m *TrafficScheduler) GetTrafficShapingInfo() *TrafficShapingInfo {
	if m != nil {
		return m.TrafficShapingInfo
	}
	return nil
}

func (m *TrafficScheduler) GetParentSchedId() uint32 {
	if m != nil {
		return m.ParentSchedId
	}
	return 0
}

type TrafficSchedulers struct {
	IntfId               uint32              `protobuf:"fixed32,1,opt,name=intf_id,json=intfId,proto3" json:"intf_id,omitempty"`
	OnuId                uint32              `protobuf:"fixed32,2,opt,name=onu_id,json=onuId,proto3" json:"onu_id,omitempty"`
	UniId                uint32              `protobuf:"fixed32,4,opt,name=uni_id,json=uniId,proto3" json:"uni_id,omitempty"`
	PortNo               uint32              `protobuf:"fixed32,5,opt,name=port_no,json=portNo,proto3" json:"port_no,omitempty"`
	TrafficScheds        []*TrafficScheduler `protobuf:"bytes,3,rep,name=traffic_scheds,json=trafficScheds,proto3" json:"traffic_scheds,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_TrafficSchedulers proto.InternalMessageInfo

func (m *TrafficSchedulers) GetIntfId() uint32 {
	if m != nil {
		return m.IntfId
	}
	return 0
}

func (m *TrafficSchedulers) GetOnuId() uint32 {
	if m != nil {
		return m.OnuId
	}
	return 0
}

func (m *TrafficSchedulers) GetUniId() uint32 {
	if m != nil {
		return m.UniId
	}
	return 0
}

func (m *TrafficSchedulers) GetPortNo() uint32 {
	if m != nil {
		return m.PortNo
	}
	return 0
}

func (m *TrafficSchedulers) GetTrafficScheds() []*TrafficScheduler {
	if m != nil {
		return m.TrafficScheds
	}
	return nil
}

type TailDropDiscardConfig struct {
	QueueSize            uint32   `protobuf:"fixed32,1,opt,name=queue_size,json=queueSize,proto3" json:"queue_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TailDropDiscardConfig proto.InternalMessageInfo

func (m *TailDropDiscardConfig) GetQueueSize() uint32 {
	if m != nil {
		return m.QueueSize
	}
	return 0
}

type RedDiscardConfig struct {
	MinThreshold         uint32   `protobuf:"fixed32,1,opt,name=min_threshold,json=minThreshold,proto3" json:"min_threshold,omitempty"`
	MaxThreshold         uint32   `protobuf:"fixed32,2,opt,name=max_threshold,json=maxThreshold,proto3" json:"max_threshold,omitempty"`
	MaxProbability       uint32   `protobuf:"fixed32,3,opt,name=max_probability,json=maxProbability,proto3" json:"max_probability,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RedDiscardConfig proto.InternalMessageInfo

func (m *RedDiscardConfig) GetMinThreshold() uint32 {
	if m != nil {
		return m.MinThreshold
	}
	return 0
}

func (m *RedDiscardConfig) GetMaxThreshold() uint32 {
	if m != nil {
		return m.MaxThreshold
	}
	return 0
}

func (m *RedDiscardConfig) GetMaxProbability() uint32 {
	if m != nil {
		return m.MaxProbability
	}
	return 0
}

type WRedDiscardConfig struct {
	Green                *RedDiscardConfig `protobuf:"bytes,1,opt,name=green,proto3" json:"green,omitempty"`
	Yellow               *RedDiscardConfig `protobuf:"bytes,2,opt,name=yellow,proto3" json:"yellow,omitempty"`
	Red                  *RedDiscardConfig `protobuf:"bytes,3,opt,name=red,proto3" json:"red,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_WRedDiscardConfig proto.InternalMessageInfo

func (m *WRedDiscardConfig) GetGreen() *RedDiscardConfig {
	if m != nil {
		return m.Green
	}
	return nil
}

func (m *WRedDiscardConfig) GetYellow() *RedDiscardConfig {
	if m != nil {
		return m.Yellow
	}
	return nil
}

func (m *WRedDiscardConfig) GetRed() *RedDiscardConfig {
	if m != nil {
		return m.Red
	}
	return nil
}

type DiscardConfig struct {
	DiscardPolicy DiscardPolicy `protobuf:"varint,1,opt,name=discard_policy,json=discardPolicy,proto3,enum=tech_profile.DiscardPolicy" json:"discard_policy,omitempty"`
	// Types that are valid to be assigned to DiscardConfig:
	//	*DiscardConfig_TailDropDiscardConfig
	//	*DiscardConfig_RedDiscardConfig
	//	*DiscardConfig_WredDiscardConfig
	DiscardConfig        isDiscardConfig_DiscardConfig `protobuf_oneof:"discard_config"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

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

var xxx_messageInfo_DiscardConfig proto.InternalMessageInfo

func (m *DiscardConfig) GetDiscardPolicy() DiscardPolicy {
	if m != nil {
		return m.DiscardPolicy
	}
	return DiscardPolicy_TailDrop
}

type isDiscardConfig_DiscardConfig interface {
	isDiscardConfig_DiscardConfig()
}

type DiscardConfig_TailDropDiscardConfig struct {
	TailDropDiscardConfig *TailDropDiscardConfig `protobuf:"bytes,2,opt,name=tail_drop_discard_config,json=tailDropDiscardConfig,proto3,oneof"`
}

type DiscardConfig_RedDiscardConfig struct {
	RedDiscardConfig *RedDiscardConfig `protobuf:"bytes,3,opt,name=red_discard_config,json=redDiscardConfig,proto3,oneof"`
}

type DiscardConfig_WredDiscardConfig struct {
	WredDiscardConfig *WRedDiscardConfig `protobuf:"bytes,4,opt,name=wred_discard_config,json=wredDiscardConfig,proto3,oneof"`
}

func (*DiscardConfig_TailDropDiscardConfig) isDiscardConfig_DiscardConfig() {}

func (*DiscardConfig_RedDiscardConfig) isDiscardConfig_DiscardConfig() {}

func (*DiscardConfig_WredDiscardConfig) isDiscardConfig_DiscardConfig() {}

func (m *DiscardConfig) GetDiscardConfig() isDiscardConfig_DiscardConfig {
	if m != nil {
		return m.DiscardConfig
	}
	return nil
}

func (m *DiscardConfig) GetTailDropDiscardConfig() *TailDropDiscardConfig {
	if x, ok := m.GetDiscardConfig().(*DiscardConfig_TailDropDiscardConfig); ok {
		return x.TailDropDiscardConfig
	}
	return nil
}

func (m *DiscardConfig) GetRedDiscardConfig() *RedDiscardConfig {
	if x, ok := m.GetDiscardConfig().(*DiscardConfig_RedDiscardConfig); ok {
		return x.RedDiscardConfig
	}
	return nil
}

func (m *DiscardConfig) GetWredDiscardConfig() *WRedDiscardConfig {
	if x, ok := m.GetDiscardConfig().(*DiscardConfig_WredDiscardConfig); ok {
		return x.WredDiscardConfig
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*DiscardConfig) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*DiscardConfig_TailDropDiscardConfig)(nil),
		(*DiscardConfig_RedDiscardConfig)(nil),
		(*DiscardConfig_WredDiscardConfig)(nil),
	}
}

type TrafficQueue struct {
	Direction            Direction           `protobuf:"varint,1,opt,name=direction,proto3,enum=tech_profile.Direction" json:"direction,omitempty"`
	GemportId            uint32              `protobuf:"fixed32,2,opt,name=gemport_id,json=gemportId,proto3" json:"gemport_id,omitempty"`
	PbitMap              string              `protobuf:"bytes,3,opt,name=pbit_map,json=pbitMap,proto3" json:"pbit_map,omitempty"`
	AesEncryption        bool                `protobuf:"varint,4,opt,name=aes_encryption,json=aesEncryption,proto3" json:"aes_encryption,omitempty"`
	SchedPolicy          SchedulingPolicy    `protobuf:"varint,5,opt,name=sched_policy,json=schedPolicy,proto3,enum=tech_profile.SchedulingPolicy" json:"sched_policy,omitempty"`
	Priority             uint32              `protobuf:"fixed32,6,opt,name=priority,proto3" json:"priority,omitempty"`
	Weight               uint32              `protobuf:"fixed32,7,opt,name=weight,proto3" json:"weight,omitempty"`
	DiscardPolicy        DiscardPolicy       `protobuf:"varint,8,opt,name=discard_policy,json=discardPolicy,proto3,enum=tech_profile.DiscardPolicy" json:"discard_policy,omitempty"`
	DiscardConfig        *DiscardConfig      `protobuf:"bytes,9,opt,name=discard_config,json=discardConfig,proto3" json:"discard_config,omitempty"`
	ShapingInfo          *TrafficShapingInfo `protobuf:"bytes,10,opt,name=shaping_info,json=shapingInfo,proto3" json:"shaping_info,omitempty"`
	SchedulerId          uint32              `protobuf:"fixed32,11,opt,name=scheduler_id,json=schedulerId,proto3" json:"scheduler_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_TrafficQueue proto.InternalMessageInfo

func (m *TrafficQueue) GetDirection() Direction {
	if m != nil {
		return m.Direction
	}
	return Direction_UPSTREAM
}

func (m *TrafficQueue) GetGemportId() uint32 {
	if m != nil {
		return m.GemportId
	}
	return 0
}

func (m *TrafficQueue) GetPbitMap() string {
	if m != nil {
		return m.PbitMap
	}
	return ""
}

func (m *TrafficQueue) GetAesEncryption() bool {
	if m != nil {
		return m.AesEncryption
	}
	return false
}

func (m *TrafficQueue) GetSchedPolicy() SchedulingPolicy {
	if m != nil {
		return m.SchedPolicy
	}
	return SchedulingPolicy_WRR
}

func (m *TrafficQueue) GetPriority() uint32 {
	if m != nil {
		return m.Priority
	}
	return 0
}

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

func (m *TrafficQueue) GetDiscardPolicy() DiscardPolicy {
	if m != nil {
		return m.DiscardPolicy
	}
	return DiscardPolicy_TailDrop
}

func (m *TrafficQueue) GetDiscardConfig() *DiscardConfig {
	if m != nil {
		return m.DiscardConfig
	}
	return nil
}

func (m *TrafficQueue) GetShapingInfo() *TrafficShapingInfo {
	if m != nil {
		return m.ShapingInfo
	}
	return nil
}

func (m *TrafficQueue) GetSchedulerId() uint32 {
	if m != nil {
		return m.SchedulerId
	}
	return 0
}

type TrafficQueues struct {
	IntfId               uint32          `protobuf:"fixed32,1,opt,name=intf_id,json=intfId,proto3" json:"intf_id,omitempty"`
	OnuId                uint32          `protobuf:"fixed32,2,opt,name=onu_id,json=onuId,proto3" json:"onu_id,omitempty"`
	UniId                uint32          `protobuf:"fixed32,4,opt,name=uni_id,json=uniId,proto3" json:"uni_id,omitempty"`
	PortNo               uint32          `protobuf:"fixed32,5,opt,name=port_no,json=portNo,proto3" json:"port_no,omitempty"`
	TrafficQueues        []*TrafficQueue `protobuf:"bytes,6,rep,name=traffic_queues,json=trafficQueues,proto3" json:"traffic_queues,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_TrafficQueues proto.InternalMessageInfo

func (m *TrafficQueues) GetIntfId() uint32 {
	if m != nil {
		return m.IntfId
	}
	return 0
}

func (m *TrafficQueues) GetOnuId() uint32 {
	if m != nil {
		return m.OnuId
	}
	return 0
}

func (m *TrafficQueues) GetUniId() uint32 {
	if m != nil {
		return m.UniId
	}
	return 0
}

func (m *TrafficQueues) GetPortNo() uint32 {
	if m != nil {
		return m.PortNo
	}
	return 0
}

func (m *TrafficQueues) GetTrafficQueues() []*TrafficQueue {
	if m != nil {
		return m.TrafficQueues
	}
	return nil
}

func init() {
	proto.RegisterEnum("tech_profile.Direction", Direction_name, Direction_value)
	proto.RegisterEnum("tech_profile.SchedulingPolicy", SchedulingPolicy_name, SchedulingPolicy_value)
	proto.RegisterEnum("tech_profile.AdditionalBW", AdditionalBW_name, AdditionalBW_value)
	proto.RegisterEnum("tech_profile.DiscardPolicy", DiscardPolicy_name, DiscardPolicy_value)
	proto.RegisterEnum("tech_profile.InferredAdditionBWIndication", InferredAdditionBWIndication_name, InferredAdditionBWIndication_value)
	proto.RegisterType((*SchedulerConfig)(nil), "tech_profile.SchedulerConfig")
	proto.RegisterType((*TrafficShapingInfo)(nil), "tech_profile.TrafficShapingInfo")
	proto.RegisterType((*TrafficScheduler)(nil), "tech_profile.TrafficScheduler")
	proto.RegisterType((*TrafficSchedulers)(nil), "tech_profile.TrafficSchedulers")
	proto.RegisterType((*TailDropDiscardConfig)(nil), "tech_profile.TailDropDiscardConfig")
	proto.RegisterType((*RedDiscardConfig)(nil), "tech_profile.RedDiscardConfig")
	proto.RegisterType((*WRedDiscardConfig)(nil), "tech_profile.WRedDiscardConfig")
	proto.RegisterType((*DiscardConfig)(nil), "tech_profile.DiscardConfig")
	proto.RegisterType((*TrafficQueue)(nil), "tech_profile.TrafficQueue")
	proto.RegisterType((*TrafficQueues)(nil), "tech_profile.TrafficQueues")
}

func init() { proto.RegisterFile("voltha_protos/tech_profile.proto", fileDescriptor_d019a68bffe14cae) }

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