vendor/github.com/opencord/voltha-protos/v5/go/core_adapter/core_adapter.pb.go

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

package core_adapter

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	common "github.com/opencord/voltha-protos/v5/go/common"
	extension "github.com/opencord/voltha-protos/v5/go/extension"
	omci "github.com/opencord/voltha-protos/v5/go/omci"
	openflow_13 "github.com/opencord/voltha-protos/v5/go/openflow_13"
	voltha "github.com/opencord/voltha-protos/v5/go/voltha"
	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 AdapterRegistration struct {
	Adapter              *voltha.Adapter     `protobuf:"bytes,1,opt,name=adapter,proto3" json:"adapter,omitempty"`
	DTypes               *voltha.DeviceTypes `protobuf:"bytes,2,opt,name=dTypes,proto3" json:"dTypes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_AdapterRegistration proto.InternalMessageInfo

func (m *AdapterRegistration) GetAdapter() *voltha.Adapter {
	if m != nil {
		return m.Adapter
	}
	return nil
}

func (m *AdapterRegistration) GetDTypes() *voltha.DeviceTypes {
	if m != nil {
		return m.DTypes
	}
	return nil
}

type ChildDeviceFilter struct {
	ParentId             string   `protobuf:"bytes,1,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty"`
	SerialNumber         string   `protobuf:"bytes,2,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"`
	OnuId                uint32   `protobuf:"varint,3,opt,name=onu_id,json=onuId,proto3" json:"onu_id,omitempty"`
	ParentPortNo         uint32   `protobuf:"varint,4,opt,name=parent_port_no,json=parentPortNo,proto3" json:"parent_port_no,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ChildDeviceFilter proto.InternalMessageInfo

func (m *ChildDeviceFilter) GetParentId() string {
	if m != nil {
		return m.ParentId
	}
	return ""
}

func (m *ChildDeviceFilter) GetSerialNumber() string {
	if m != nil {
		return m.SerialNumber
	}
	return ""
}

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

func (m *ChildDeviceFilter) GetParentPortNo() uint32 {
	if m != nil {
		return m.ParentPortNo
	}
	return 0
}

type PortFilter struct {
	DeviceId             string               `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Port                 uint32               `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	PortType             voltha.Port_PortType `protobuf:"varint,3,opt,name=port_type,json=portType,proto3,enum=device.Port_PortType" json:"port_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_PortFilter proto.InternalMessageInfo

func (m *PortFilter) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

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

func (m *PortFilter) GetPortType() voltha.Port_PortType {
	if m != nil {
		return m.PortType
	}
	return voltha.Port_UNKNOWN
}

type DeviceDiscovery struct {
	ParentId             string   `protobuf:"bytes,1,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty"`
	ParentPortNo         uint32   `protobuf:"varint,2,opt,name=parent_port_no,json=parentPortNo,proto3" json:"parent_port_no,omitempty"`
	ChildDeviceType      string   `protobuf:"bytes,3,opt,name=child_device_type,json=childDeviceType,proto3" json:"child_device_type,omitempty"`
	ChannelId            uint32   `protobuf:"varint,4,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	VendorId             string   `protobuf:"bytes,5,opt,name=vendor_id,json=vendorId,proto3" json:"vendor_id,omitempty"`
	SerialNumber         string   `protobuf:"bytes,6,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"`
	OnuId                uint32   `protobuf:"varint,7,opt,name=onu_id,json=onuId,proto3" json:"onu_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DeviceDiscovery proto.InternalMessageInfo

func (m *DeviceDiscovery) GetParentId() string {
	if m != nil {
		return m.ParentId
	}
	return ""
}

func (m *DeviceDiscovery) GetParentPortNo() uint32 {
	if m != nil {
		return m.ParentPortNo
	}
	return 0
}

func (m *DeviceDiscovery) GetChildDeviceType() string {
	if m != nil {
		return m.ChildDeviceType
	}
	return ""
}

func (m *DeviceDiscovery) GetChannelId() uint32 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *DeviceDiscovery) GetVendorId() string {
	if m != nil {
		return m.VendorId
	}
	return ""
}

func (m *DeviceDiscovery) GetSerialNumber() string {
	if m != nil {
		return m.SerialNumber
	}
	return ""
}

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

type DeviceStateFilter struct {
	DeviceId             string                     `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	ParentDeviceId       string                     `protobuf:"bytes,2,opt,name=parent_device_id,json=parentDeviceId,proto3" json:"parent_device_id,omitempty"`
	OperStatus           common.OperStatus_Types    `protobuf:"varint,3,opt,name=oper_status,json=operStatus,proto3,enum=common.OperStatus_Types" json:"oper_status,omitempty"`
	ConnStatus           common.ConnectStatus_Types `protobuf:"varint,4,opt,name=conn_status,json=connStatus,proto3,enum=common.ConnectStatus_Types" json:"conn_status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

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

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

var xxx_messageInfo_DeviceStateFilter proto.InternalMessageInfo

func (m *DeviceStateFilter) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

func (m *DeviceStateFilter) GetParentDeviceId() string {
	if m != nil {
		return m.ParentDeviceId
	}
	return ""
}

func (m *DeviceStateFilter) GetOperStatus() common.OperStatus_Types {
	if m != nil {
		return m.OperStatus
	}
	return common.OperStatus_UNKNOWN
}

func (m *DeviceStateFilter) GetConnStatus() common.ConnectStatus_Types {
	if m != nil {
		return m.ConnStatus
	}
	return common.ConnectStatus_UNKNOWN
}

type PortState struct {
	DeviceId             string                  `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	PortType             voltha.Port_PortType    `protobuf:"varint,2,opt,name=port_type,json=portType,proto3,enum=device.Port_PortType" json:"port_type,omitempty"`
	PortNo               uint32                  `protobuf:"varint,3,opt,name=port_no,json=portNo,proto3" json:"port_no,omitempty"`
	OperStatus           common.OperStatus_Types `protobuf:"varint,4,opt,name=oper_status,json=operStatus,proto3,enum=common.OperStatus_Types" json:"oper_status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_PortState proto.InternalMessageInfo

func (m *PortState) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

func (m *PortState) GetPortType() voltha.Port_PortType {
	if m != nil {
		return m.PortType
	}
	return voltha.Port_UNKNOWN
}

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

func (m *PortState) GetOperStatus() common.OperStatus_Types {
	if m != nil {
		return m.OperStatus
	}
	return common.OperStatus_UNKNOWN
}

type PortStateFilter struct {
	DeviceId             string                  `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	PortTypeFilter       uint32                  `protobuf:"varint,2,opt,name=port_type_filter,json=portTypeFilter,proto3" json:"port_type_filter,omitempty"`
	OperStatus           common.OperStatus_Types `protobuf:"varint,4,opt,name=oper_status,json=operStatus,proto3,enum=common.OperStatus_Types" json:"oper_status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_PortStateFilter proto.InternalMessageInfo

func (m *PortStateFilter) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

func (m *PortStateFilter) GetPortTypeFilter() uint32 {
	if m != nil {
		return m.PortTypeFilter
	}
	return 0
}

func (m *PortStateFilter) GetOperStatus() common.OperStatus_Types {
	if m != nil {
		return m.OperStatus
	}
	return common.OperStatus_UNKNOWN
}

type PacketIn struct {
	DeviceId             string   `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Port                 uint32   `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	Packet               []byte   `protobuf:"bytes,3,opt,name=packet,proto3" json:"packet,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PacketIn proto.InternalMessageInfo

func (m *PacketIn) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

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

func (m *PacketIn) GetPacket() []byte {
	if m != nil {
		return m.Packet
	}
	return nil
}

type PacketOut struct {
	DeviceId             string                    `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	EgressPortNo         uint32                    `protobuf:"varint,2,opt,name=egress_port_no,json=egressPortNo,proto3" json:"egress_port_no,omitempty"`
	Packet               *openflow_13.OfpPacketOut `protobuf:"bytes,3,opt,name=packet,proto3" json:"packet,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

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

var xxx_messageInfo_PacketOut proto.InternalMessageInfo

func (m *PacketOut) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

func (m *PacketOut) GetEgressPortNo() uint32 {
	if m != nil {
		return m.EgressPortNo
	}
	return 0
}

func (m *PacketOut) GetPacket() *openflow_13.OfpPacketOut {
	if m != nil {
		return m.Packet
	}
	return nil
}

type DeviceReason struct {
	DeviceId             string   `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	Reason               string   `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DeviceReason proto.InternalMessageInfo

func (m *DeviceReason) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

func (m *DeviceReason) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

type BulkFlows struct {
	Device               *voltha.Device            `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Flows                *openflow_13.Flows        `protobuf:"bytes,2,opt,name=flows,proto3" json:"flows,omitempty"`
	Groups               *openflow_13.FlowGroups   `protobuf:"bytes,3,opt,name=groups,proto3" json:"groups,omitempty"`
	FlowMetadata         *openflow_13.FlowMetadata `protobuf:"bytes,4,opt,name=flow_metadata,json=flowMetadata,proto3" json:"flow_metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

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

var xxx_messageInfo_BulkFlows proto.InternalMessageInfo

func (m *BulkFlows) GetDevice() *voltha.Device {
	if m != nil {
		return m.Device
	}
	return nil
}

func (m *BulkFlows) GetFlows() *openflow_13.Flows {
	if m != nil {
		return m.Flows
	}
	return nil
}

func (m *BulkFlows) GetGroups() *openflow_13.FlowGroups {
	if m != nil {
		return m.Groups
	}
	return nil
}

func (m *BulkFlows) GetFlowMetadata() *openflow_13.FlowMetadata {
	if m != nil {
		return m.FlowMetadata
	}
	return nil
}

type IncrementalFlows struct {
	Device               *voltha.Device                `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Flows                *openflow_13.FlowChanges      `protobuf:"bytes,2,opt,name=flows,proto3" json:"flows,omitempty"`
	Groups               *openflow_13.FlowGroupChanges `protobuf:"bytes,3,opt,name=groups,proto3" json:"groups,omitempty"`
	FlowMetadata         *openflow_13.FlowMetadata     `protobuf:"bytes,4,opt,name=flow_metadata,json=flowMetadata,proto3" json:"flow_metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

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

var xxx_messageInfo_IncrementalFlows proto.InternalMessageInfo

func (m *IncrementalFlows) GetDevice() *voltha.Device {
	if m != nil {
		return m.Device
	}
	return nil
}

func (m *IncrementalFlows) GetFlows() *openflow_13.FlowChanges {
	if m != nil {
		return m.Flows
	}
	return nil
}

func (m *IncrementalFlows) GetGroups() *openflow_13.FlowGroupChanges {
	if m != nil {
		return m.Groups
	}
	return nil
}

func (m *IncrementalFlows) GetFlowMetadata() *openflow_13.FlowMetadata {
	if m != nil {
		return m.FlowMetadata
	}
	return nil
}

type PmConfigsInfo struct {
	DeviceId             string            `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	PmConfigs            *voltha.PmConfigs `protobuf:"bytes,2,opt,name=pm_configs,json=pmConfigs,proto3" json:"pm_configs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_PmConfigsInfo proto.InternalMessageInfo

func (m *PmConfigsInfo) GetDeviceId() string {
	if m != nil {
		return m.DeviceId
	}
	return ""
}

func (m *PmConfigsInfo) GetPmConfigs() *voltha.PmConfigs {
	if m != nil {
		return m.PmConfigs
	}
	return nil
}

type SwitchCapability struct {
	Desc                 *openflow_13.OfpDesc           `protobuf:"bytes,1,opt,name=desc,proto3" json:"desc,omitempty"`
	SwitchFeatures       *openflow_13.OfpSwitchFeatures `protobuf:"bytes,2,opt,name=switch_features,json=switchFeatures,proto3" json:"switch_features,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
	XXX_unrecognized     []byte                         `json:"-"`
	XXX_sizecache        int32                          `json:"-"`
}

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

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

var xxx_messageInfo_SwitchCapability proto.InternalMessageInfo

func (m *SwitchCapability) GetDesc() *openflow_13.OfpDesc {
	if m != nil {
		return m.Desc
	}
	return nil
}

func (m *SwitchCapability) GetSwitchFeatures() *openflow_13.OfpSwitchFeatures {
	if m != nil {
		return m.SwitchFeatures
	}
	return nil
}

type ImageDownloadMessage struct {
	Device               *voltha.Device        `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Image                *voltha.ImageDownload `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_ImageDownloadMessage proto.InternalMessageInfo

func (m *ImageDownloadMessage) GetDevice() *voltha.Device {
	if m != nil {
		return m.Device
	}
	return nil
}

func (m *ImageDownloadMessage) GetImage() *voltha.ImageDownload {
	if m != nil {
		return m.Image
	}
	return nil
}

type OMCITest struct {
	Device               *voltha.Device        `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Request              *omci.OmciTestRequest `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_OMCITest proto.InternalMessageInfo

func (m *OMCITest) GetDevice() *voltha.Device {
	if m != nil {
		return m.Device
	}
	return nil
}

func (m *OMCITest) GetRequest() *omci.OmciTestRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

type SimulateAlarmMessage struct {
	Device               *voltha.Device               `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Request              *voltha.SimulateAlarmRequest `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

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

var xxx_messageInfo_SimulateAlarmMessage proto.InternalMessageInfo

func (m *SimulateAlarmMessage) GetDevice() *voltha.Device {
	if m != nil {
		return m.Device
	}
	return nil
}

func (m *SimulateAlarmMessage) GetRequest() *voltha.SimulateAlarmRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

type GetExtValueMessage struct {
	ParentDevice         *voltha.Device           `protobuf:"bytes,1,opt,name=parent_device,json=parentDevice,proto3" json:"parent_device,omitempty"`
	ChildDevice          *voltha.Device           `protobuf:"bytes,2,opt,name=child_device,json=childDevice,proto3" json:"child_device,omitempty"`
	ValueType            extension.ValueType_Type `protobuf:"varint,3,opt,name=value_type,json=valueType,proto3,enum=extension.ValueType_Type" json:"value_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_GetExtValueMessage proto.InternalMessageInfo

func (m *GetExtValueMessage) GetParentDevice() *voltha.Device {
	if m != nil {
		return m.ParentDevice
	}
	return nil
}

func (m *GetExtValueMessage) GetChildDevice() *voltha.Device {
	if m != nil {
		return m.ChildDevice
	}
	return nil
}

func (m *GetExtValueMessage) GetValueType() extension.ValueType_Type {
	if m != nil {
		return m.ValueType
	}
	return extension.ValueType_EMPTY
}

type SetExtValueMessage struct {
	Device               *voltha.Device      `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	Value                *extension.ValueSet `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_SetExtValueMessage proto.InternalMessageInfo

func (m *SetExtValueMessage) GetDevice() *voltha.Device {
	if m != nil {
		return m.Device
	}
	return nil
}

func (m *SetExtValueMessage) GetValue() *extension.ValueSet {
	if m != nil {
		return m.Value
	}
	return nil
}

func init() {
	proto.RegisterType((*AdapterRegistration)(nil), "core_adapter.AdapterRegistration")
	proto.RegisterType((*ChildDeviceFilter)(nil), "core_adapter.ChildDeviceFilter")
	proto.RegisterType((*PortFilter)(nil), "core_adapter.PortFilter")
	proto.RegisterType((*DeviceDiscovery)(nil), "core_adapter.DeviceDiscovery")
	proto.RegisterType((*DeviceStateFilter)(nil), "core_adapter.DeviceStateFilter")
	proto.RegisterType((*PortState)(nil), "core_adapter.PortState")
	proto.RegisterType((*PortStateFilter)(nil), "core_adapter.PortStateFilter")
	proto.RegisterType((*PacketIn)(nil), "core_adapter.PacketIn")
	proto.RegisterType((*PacketOut)(nil), "core_adapter.PacketOut")
	proto.RegisterType((*DeviceReason)(nil), "core_adapter.DeviceReason")
	proto.RegisterType((*BulkFlows)(nil), "core_adapter.BulkFlows")
	proto.RegisterType((*IncrementalFlows)(nil), "core_adapter.IncrementalFlows")
	proto.RegisterType((*PmConfigsInfo)(nil), "core_adapter.PmConfigsInfo")
	proto.RegisterType((*SwitchCapability)(nil), "core_adapter.SwitchCapability")
	proto.RegisterType((*ImageDownloadMessage)(nil), "core_adapter.ImageDownloadMessage")
	proto.RegisterType((*OMCITest)(nil), "core_adapter.OMCITest")
	proto.RegisterType((*SimulateAlarmMessage)(nil), "core_adapter.SimulateAlarmMessage")
	proto.RegisterType((*GetExtValueMessage)(nil), "core_adapter.GetExtValueMessage")
	proto.RegisterType((*SetExtValueMessage)(nil), "core_adapter.SetExtValueMessage")
}

func init() { proto.RegisterFile("voltha_protos/core_adapter.proto", fileDescriptor_b77436fd29d035f0) }

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