// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: dinetrpc.proto

package dinetrpc

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

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

type ClassMethod int32

const (
	ClassMethod_UnknownUnknown       ClassMethod = 0
	ClassMethod_DeviceInfo           ClassMethod = 9
	ClassMethod_DevicePing           ClassMethod = 10
	ClassMethod_DeviceUserData       ClassMethod = 11
	ClassMethod_DeviceData           ClassMethod = 12
	ClassMethod_DeviceErrors         ClassMethod = 13
	ClassMethod_SensorInfo           ClassMethod = 20
	ClassMethod_SensorData           ClassMethod = 21
	ClassMethod_ConfigInfo           ClassMethod = 31
	ClassMethod_ConfigGet            ClassMethod = 32
	ClassMethod_ConfigSet            ClassMethod = 33
	ClassMethod_ConfigReset          ClassMethod = 34
	ClassMethod_ActionInfo           ClassMethod = 41
	ClassMethod_ActionGet            ClassMethod = 42
	ClassMethod_ActionSet            ClassMethod = 43
	ClassMethod_ConnectionInfo       ClassMethod = 51
	ClassMethod_ConnectionConnect    ClassMethod = 52
	ClassMethod_ConnectionDisconnect ClassMethod = 53
)

var ClassMethod_name = map[int32]string{
	0:  "UnknownUnknown",
	9:  "DeviceInfo",
	10: "DevicePing",
	11: "DeviceUserData",
	12: "DeviceData",
	13: "DeviceErrors",
	20: "SensorInfo",
	21: "SensorData",
	31: "ConfigInfo",
	32: "ConfigGet",
	33: "ConfigSet",
	34: "ConfigReset",
	41: "ActionInfo",
	42: "ActionGet",
	43: "ActionSet",
	51: "ConnectionInfo",
	52: "ConnectionConnect",
	53: "ConnectionDisconnect",
}
var ClassMethod_value = map[string]int32{
	"UnknownUnknown":       0,
	"DeviceInfo":           9,
	"DevicePing":           10,
	"DeviceUserData":       11,
	"DeviceData":           12,
	"DeviceErrors":         13,
	"SensorInfo":           20,
	"SensorData":           21,
	"ConfigInfo":           31,
	"ConfigGet":            32,
	"ConfigSet":            33,
	"ConfigReset":          34,
	"ActionInfo":           41,
	"ActionGet":            42,
	"ActionSet":            43,
	"ConnectionInfo":       51,
	"ConnectionConnect":    52,
	"ConnectionDisconnect": 53,
}

func (x ClassMethod) String() string {
	return proto.EnumName(ClassMethod_name, int32(x))
}
func (ClassMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{0}
}

type MsgType int32

const (
	MsgType_Unknown MsgType = 0
	MsgType_Request MsgType = 1
	MsgType_Reply   MsgType = 2
	MsgType_Publish MsgType = 3
)

var MsgType_name = map[int32]string{
	0: "Unknown",
	1: "Request",
	2: "Reply",
	3: "Publish",
}
var MsgType_value = map[string]int32{
	"Unknown": 0,
	"Request": 1,
	"Reply":   2,
	"Publish": 3,
}

func (x MsgType) String() string {
	return proto.EnumName(MsgType_name, int32(x))
}
func (MsgType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{1}
}

type HeaderMsg struct {
	DinetRPC             uint32      `protobuf:"varint,1,opt,name=dinetRPC,proto3" json:"dinetrpc" msgpack:"dinetrpc"`
	Time                 uint64      `protobuf:"varint,2,opt,name=time,proto3" json:"time" msgpack:"time"`
	DeviceUID            string      `protobuf:"bytes,3,opt,name=deviceUID,proto3" json:"device:uid,omitempty" msgpack:"device:uid"`
	UserID               uint32      `protobuf:"varint,4,opt,name=userID,proto3" json:"user:id,omitempty" msgpack:"user:id"`
	ProjectID            uint32      `protobuf:"varint,5,opt,name=projectID,proto3" json:"project:id,omitempty" msgpack:"project:id"`
	Req                  string      `protobuf:"bytes,10,opt,name=req,proto3" json:"req" msgpack:"req"`
	Rep                  string      `protobuf:"bytes,11,opt,name=rep,proto3" json:"rep" msgpack:"rep"`
	Pub                  string      `protobuf:"bytes,12,opt,name=pub,proto3" json:"pub" msgpack:"pub"`
	Id                   uint32      `protobuf:"varint,13,opt,name=id,proto3" json:"id" msgpack:"id"`
	ClassMethod          ClassMethod `protobuf:"varint,14,opt,name=classMethod,proto3,enum=dinetrpc.ClassMethod" json:"classMethod,omitempty"`
	Type                 MsgType     `protobuf:"varint,15,opt,name=type,proto3,enum=dinetrpc.MsgType" json:"type,omitempty"`
	Error                *Error      `protobuf:"bytes,16,opt,name=error" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *HeaderMsg) Reset()         { *m = HeaderMsg{} }
func (m *HeaderMsg) String() string { return proto.CompactTextString(m) }
func (*HeaderMsg) ProtoMessage()    {}
func (*HeaderMsg) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{0}
}
func (m *HeaderMsg) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HeaderMsg.Unmarshal(m, b)
}
func (m *HeaderMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HeaderMsg.Marshal(b, m, deterministic)
}
func (dst *HeaderMsg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeaderMsg.Merge(dst, src)
}
func (m *HeaderMsg) XXX_Size() int {
	return xxx_messageInfo_HeaderMsg.Size(m)
}
func (m *HeaderMsg) XXX_DiscardUnknown() {
	xxx_messageInfo_HeaderMsg.DiscardUnknown(m)
}

var xxx_messageInfo_HeaderMsg proto.InternalMessageInfo

func (m *HeaderMsg) GetDinetRPC() uint32 {
	if m != nil {
		return m.DinetRPC
	}
	return 0
}

func (m *HeaderMsg) GetTime() uint64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *HeaderMsg) GetDeviceUID() string {
	if m != nil {
		return m.DeviceUID
	}
	return ""
}

func (m *HeaderMsg) GetUserID() uint32 {
	if m != nil {
		return m.UserID
	}
	return 0
}

func (m *HeaderMsg) GetProjectID() uint32 {
	if m != nil {
		return m.ProjectID
	}
	return 0
}

func (m *HeaderMsg) GetReq() string {
	if m != nil {
		return m.Req
	}
	return ""
}

func (m *HeaderMsg) GetRep() string {
	if m != nil {
		return m.Rep
	}
	return ""
}

func (m *HeaderMsg) GetPub() string {
	if m != nil {
		return m.Pub
	}
	return ""
}

func (m *HeaderMsg) GetId() uint32 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *HeaderMsg) GetClassMethod() ClassMethod {
	if m != nil {
		return m.ClassMethod
	}
	return ClassMethod_UnknownUnknown
}

func (m *HeaderMsg) GetType() MsgType {
	if m != nil {
		return m.Type
	}
	return MsgType_Unknown
}

func (m *HeaderMsg) GetError() *Error {
	if m != nil {
		return m.Error
	}
	return nil
}

type Value struct {
	// Types that are valid to be assigned to Value:
	//	*Value_Bool
	//	*Value_Number
	//	*Value_String_
	//	*Value_GPS
	Value                isValue_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Value) Reset()         { *m = Value{} }
func (m *Value) String() string { return proto.CompactTextString(m) }
func (*Value) ProtoMessage()    {}
func (*Value) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{1}
}
func (m *Value) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Value.Unmarshal(m, b)
}
func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Value.Marshal(b, m, deterministic)
}
func (dst *Value) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Value.Merge(dst, src)
}
func (m *Value) XXX_Size() int {
	return xxx_messageInfo_Value.Size(m)
}
func (m *Value) XXX_DiscardUnknown() {
	xxx_messageInfo_Value.DiscardUnknown(m)
}

var xxx_messageInfo_Value proto.InternalMessageInfo

type isValue_Value interface {
	isValue_Value()
}

type Value_Bool struct {
	Bool bool `protobuf:"varint,1,opt,name=Bool,proto3,oneof"`
}
type Value_Number struct {
	Number float64 `protobuf:"fixed64,2,opt,name=Number,proto3,oneof"`
}
type Value_String_ struct {
	String_ string `protobuf:"bytes,3,opt,name=String,proto3,oneof"`
}
type Value_GPS struct {
	GPS *GPSValue `protobuf:"bytes,4,opt,name=GPS,oneof"`
}

func (*Value_Bool) isValue_Value()    {}
func (*Value_Number) isValue_Value()  {}
func (*Value_String_) isValue_Value() {}
func (*Value_GPS) isValue_Value()     {}

func (m *Value) GetValue() isValue_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Value) GetBool() bool {
	if x, ok := m.GetValue().(*Value_Bool); ok {
		return x.Bool
	}
	return false
}

func (m *Value) GetNumber() float64 {
	if x, ok := m.GetValue().(*Value_Number); ok {
		return x.Number
	}
	return 0
}

func (m *Value) GetString_() string {
	if x, ok := m.GetValue().(*Value_String_); ok {
		return x.String_
	}
	return ""
}

func (m *Value) GetGPS() *GPSValue {
	if x, ok := m.GetValue().(*Value_GPS); ok {
		return x.GPS
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Value) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{
		(*Value_Bool)(nil),
		(*Value_Number)(nil),
		(*Value_String_)(nil),
		(*Value_GPS)(nil),
	}
}

func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Value)
	// value
	switch x := m.Value.(type) {
	case *Value_Bool:
		t := uint64(0)
		if x.Bool {
			t = 1
		}
		_ = b.EncodeVarint(1<<3 | proto.WireVarint)
		_ = b.EncodeVarint(t)
	case *Value_Number:
		_ = b.EncodeVarint(2<<3 | proto.WireFixed64)
		_ = b.EncodeFixed64(math.Float64bits(x.Number))
	case *Value_String_:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		_ = b.EncodeStringBytes(x.String_)
	case *Value_GPS:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.GPS); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Value.Value has unexpected type %T", x)
	}
	return nil
}

func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Value)
	switch tag {
	case 1: // value.Bool
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &Value_Bool{x != 0}
		return true, err
	case 2: // value.Number
		if wire != proto.WireFixed64 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed64()
		m.Value = &Value_Number{math.Float64frombits(x)}
		return true, err
	case 3: // value.String
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Value = &Value_String_{x}
		return true, err
	case 4: // value.GPS
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(GPSValue)
		err := b.DecodeMessage(msg)
		m.Value = &Value_GPS{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Value_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Value)
	// value
	switch x := m.Value.(type) {
	case *Value_Bool:
		n += 1 // tag and wire
		n += 1
	case *Value_Number:
		n += 1 // tag and wire
		n += 8
	case *Value_String_:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.String_)))
		n += len(x.String_)
	case *Value_GPS:
		s := proto.Size(x.GPS)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type GPSValue struct {
	Latitude             float32  `protobuf:"fixed32,1,opt,name=latitude,proto3" json:"latitude,omitempty"`
	Longitude            float32  `protobuf:"fixed32,2,opt,name=longitude,proto3" json:"longitude,omitempty"`
	Hdop                 float32  `protobuf:"fixed32,3,opt,name=hdop,proto3" json:"hdop,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GPSValue) Reset()         { *m = GPSValue{} }
func (m *GPSValue) String() string { return proto.CompactTextString(m) }
func (*GPSValue) ProtoMessage()    {}
func (*GPSValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{2}
}
func (m *GPSValue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GPSValue.Unmarshal(m, b)
}
func (m *GPSValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GPSValue.Marshal(b, m, deterministic)
}
func (dst *GPSValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GPSValue.Merge(dst, src)
}
func (m *GPSValue) XXX_Size() int {
	return xxx_messageInfo_GPSValue.Size(m)
}
func (m *GPSValue) XXX_DiscardUnknown() {
	xxx_messageInfo_GPSValue.DiscardUnknown(m)
}

var xxx_messageInfo_GPSValue proto.InternalMessageInfo

func (m *GPSValue) GetLatitude() float32 {
	if m != nil {
		return m.Latitude
	}
	return 0
}

func (m *GPSValue) GetLongitude() float32 {
	if m != nil {
		return m.Longitude
	}
	return 0
}

func (m *GPSValue) GetHdop() float32 {
	if m != nil {
		return m.Hdop
	}
	return 0
}

type Msg struct {
	*HeaderMsg `protobuf:"bytes,1,opt,name=Header,embedded=Header" json:""`
	// Types that are valid to be assigned to Result:
	//	*Msg_DeviceInfoResult
	//	*Msg_DeviceDataResult
	//	*Msg_SensorInfoResult
	//	*Msg_SensorDataResult
	//	*Msg_ConfigInfoResult
	//	*Msg_ActionInfoResult
	//	*Msg_ConnectionInfoResult
	Result               isMsg_Result `protobuf_oneof:"Result"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *Msg) Reset()         { *m = Msg{} }
func (m *Msg) String() string { return proto.CompactTextString(m) }
func (*Msg) ProtoMessage()    {}
func (*Msg) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{3}
}
func (m *Msg) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Msg.Unmarshal(m, b)
}
func (m *Msg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Msg.Marshal(b, m, deterministic)
}
func (dst *Msg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Msg.Merge(dst, src)
}
func (m *Msg) XXX_Size() int {
	return xxx_messageInfo_Msg.Size(m)
}
func (m *Msg) XXX_DiscardUnknown() {
	xxx_messageInfo_Msg.DiscardUnknown(m)
}

var xxx_messageInfo_Msg proto.InternalMessageInfo

type isMsg_Result interface {
	isMsg_Result()
}

type Msg_DeviceInfoResult struct {
	DeviceInfoResult *DeviceInfoResult `protobuf:"bytes,10,opt,name=deviceInfoResult,oneof"`
}
type Msg_DeviceDataResult struct {
	DeviceDataResult *DeviceDataResult `protobuf:"bytes,11,opt,name=deviceDataResult,oneof"`
}
type Msg_SensorInfoResult struct {
	SensorInfoResult *SensorInfoResult `protobuf:"bytes,20,opt,name=sensorInfoResult,oneof"`
}
type Msg_SensorDataResult struct {
	SensorDataResult *SensorDataResult `protobuf:"bytes,21,opt,name=sensorDataResult,oneof"`
}
type Msg_ConfigInfoResult struct {
	ConfigInfoResult *ConfigInfoResult `protobuf:"bytes,31,opt,name=configInfoResult,oneof"`
}
type Msg_ActionInfoResult struct {
	ActionInfoResult *ActionInfoResult `protobuf:"bytes,41,opt,name=actionInfoResult,oneof"`
}
type Msg_ConnectionInfoResult struct {
	ConnectionInfoResult *ConnectionInfoResult `protobuf:"bytes,51,opt,name=connectionInfoResult,oneof"`
}

func (*Msg_DeviceInfoResult) isMsg_Result()     {}
func (*Msg_DeviceDataResult) isMsg_Result()     {}
func (*Msg_SensorInfoResult) isMsg_Result()     {}
func (*Msg_SensorDataResult) isMsg_Result()     {}
func (*Msg_ConfigInfoResult) isMsg_Result()     {}
func (*Msg_ActionInfoResult) isMsg_Result()     {}
func (*Msg_ConnectionInfoResult) isMsg_Result() {}

func (m *Msg) GetResult() isMsg_Result {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *Msg) GetDeviceInfoResult() *DeviceInfoResult {
	if x, ok := m.GetResult().(*Msg_DeviceInfoResult); ok {
		return x.DeviceInfoResult
	}
	return nil
}

func (m *Msg) GetDeviceDataResult() *DeviceDataResult {
	if x, ok := m.GetResult().(*Msg_DeviceDataResult); ok {
		return x.DeviceDataResult
	}
	return nil
}

func (m *Msg) GetSensorInfoResult() *SensorInfoResult {
	if x, ok := m.GetResult().(*Msg_SensorInfoResult); ok {
		return x.SensorInfoResult
	}
	return nil
}

func (m *Msg) GetSensorDataResult() *SensorDataResult {
	if x, ok := m.GetResult().(*Msg_SensorDataResult); ok {
		return x.SensorDataResult
	}
	return nil
}

func (m *Msg) GetConfigInfoResult() *ConfigInfoResult {
	if x, ok := m.GetResult().(*Msg_ConfigInfoResult); ok {
		return x.ConfigInfoResult
	}
	return nil
}

func (m *Msg) GetActionInfoResult() *ActionInfoResult {
	if x, ok := m.GetResult().(*Msg_ActionInfoResult); ok {
		return x.ActionInfoResult
	}
	return nil
}

func (m *Msg) GetConnectionInfoResult() *ConnectionInfoResult {
	if x, ok := m.GetResult().(*Msg_ConnectionInfoResult); ok {
		return x.ConnectionInfoResult
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Msg) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Msg_OneofMarshaler, _Msg_OneofUnmarshaler, _Msg_OneofSizer, []interface{}{
		(*Msg_DeviceInfoResult)(nil),
		(*Msg_DeviceDataResult)(nil),
		(*Msg_SensorInfoResult)(nil),
		(*Msg_SensorDataResult)(nil),
		(*Msg_ConfigInfoResult)(nil),
		(*Msg_ActionInfoResult)(nil),
		(*Msg_ConnectionInfoResult)(nil),
	}
}

func _Msg_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Msg)
	// Result
	switch x := m.Result.(type) {
	case *Msg_DeviceInfoResult:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DeviceInfoResult); err != nil {
			return err
		}
	case *Msg_DeviceDataResult:
		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DeviceDataResult); err != nil {
			return err
		}
	case *Msg_SensorInfoResult:
		_ = b.EncodeVarint(20<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.SensorInfoResult); err != nil {
			return err
		}
	case *Msg_SensorDataResult:
		_ = b.EncodeVarint(21<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.SensorDataResult); err != nil {
			return err
		}
	case *Msg_ConfigInfoResult:
		_ = b.EncodeVarint(31<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ConfigInfoResult); err != nil {
			return err
		}
	case *Msg_ActionInfoResult:
		_ = b.EncodeVarint(41<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ActionInfoResult); err != nil {
			return err
		}
	case *Msg_ConnectionInfoResult:
		_ = b.EncodeVarint(51<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ConnectionInfoResult); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Msg.Result has unexpected type %T", x)
	}
	return nil
}

func _Msg_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Msg)
	switch tag {
	case 10: // Result.deviceInfoResult
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DeviceInfoResult)
		err := b.DecodeMessage(msg)
		m.Result = &Msg_DeviceInfoResult{msg}
		return true, err
	case 11: // Result.deviceDataResult
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DeviceDataResult)
		err := b.DecodeMessage(msg)
		m.Result = &Msg_DeviceDataResult{msg}
		return true, err
	case 20: // Result.sensorInfoResult
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SensorInfoResult)
		err := b.DecodeMessage(msg)
		m.Result = &Msg_SensorInfoResult{msg}
		return true, err
	case 21: // Result.sensorDataResult
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SensorDataResult)
		err := b.DecodeMessage(msg)
		m.Result = &Msg_SensorDataResult{msg}
		return true, err
	case 31: // Result.configInfoResult
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ConfigInfoResult)
		err := b.DecodeMessage(msg)
		m.Result = &Msg_ConfigInfoResult{msg}
		return true, err
	case 41: // Result.actionInfoResult
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ActionInfoResult)
		err := b.DecodeMessage(msg)
		m.Result = &Msg_ActionInfoResult{msg}
		return true, err
	case 51: // Result.connectionInfoResult
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ConnectionInfoResult)
		err := b.DecodeMessage(msg)
		m.Result = &Msg_ConnectionInfoResult{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Msg_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Msg)
	// Result
	switch x := m.Result.(type) {
	case *Msg_DeviceInfoResult:
		s := proto.Size(x.DeviceInfoResult)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Msg_DeviceDataResult:
		s := proto.Size(x.DeviceDataResult)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Msg_SensorInfoResult:
		s := proto.Size(x.SensorInfoResult)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Msg_SensorDataResult:
		s := proto.Size(x.SensorDataResult)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Msg_ConfigInfoResult:
		s := proto.Size(x.ConfigInfoResult)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Msg_ActionInfoResult:
		s := proto.Size(x.ActionInfoResult)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Msg_ConnectionInfoResult:
		s := proto.Size(x.ConnectionInfoResult)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type ResultValueItem struct {
	Uid                  uint32   `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty"`
	Value                *Value   `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	Time                 uint64   `protobuf:"varint,3,opt,name=time,proto3" json:"time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ResultValueItem) Reset()         { *m = ResultValueItem{} }
func (m *ResultValueItem) String() string { return proto.CompactTextString(m) }
func (*ResultValueItem) ProtoMessage()    {}
func (*ResultValueItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{4}
}
func (m *ResultValueItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ResultValueItem.Unmarshal(m, b)
}
func (m *ResultValueItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ResultValueItem.Marshal(b, m, deterministic)
}
func (dst *ResultValueItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResultValueItem.Merge(dst, src)
}
func (m *ResultValueItem) XXX_Size() int {
	return xxx_messageInfo_ResultValueItem.Size(m)
}
func (m *ResultValueItem) XXX_DiscardUnknown() {
	xxx_messageInfo_ResultValueItem.DiscardUnknown(m)
}

var xxx_messageInfo_ResultValueItem proto.InternalMessageInfo

func (m *ResultValueItem) GetUid() uint32 {
	if m != nil {
		return m.Uid
	}
	return 0
}

func (m *ResultValueItem) GetValue() *Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *ResultValueItem) GetTime() uint64 {
	if m != nil {
		return m.Time
	}
	return 0
}

type InfoResultItem struct {
	Uid                  uint32           `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty"`
	Label                string           `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
	Type                 string           `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	Enum                 map[string]int32 `protobuf:"bytes,4,rep,name=enum" json:"enum,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Default              *Value           `protobuf:"bytes,5,opt,name=default" json:"default,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *InfoResultItem) Reset()         { *m = InfoResultItem{} }
func (m *InfoResultItem) String() string { return proto.CompactTextString(m) }
func (*InfoResultItem) ProtoMessage()    {}
func (*InfoResultItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{5}
}
func (m *InfoResultItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InfoResultItem.Unmarshal(m, b)
}
func (m *InfoResultItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InfoResultItem.Marshal(b, m, deterministic)
}
func (dst *InfoResultItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InfoResultItem.Merge(dst, src)
}
func (m *InfoResultItem) XXX_Size() int {
	return xxx_messageInfo_InfoResultItem.Size(m)
}
func (m *InfoResultItem) XXX_DiscardUnknown() {
	xxx_messageInfo_InfoResultItem.DiscardUnknown(m)
}

var xxx_messageInfo_InfoResultItem proto.InternalMessageInfo

func (m *InfoResultItem) GetUid() uint32 {
	if m != nil {
		return m.Uid
	}
	return 0
}

func (m *InfoResultItem) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

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

func (m *InfoResultItem) GetEnum() map[string]int32 {
	if m != nil {
		return m.Enum
	}
	return nil
}

func (m *InfoResultItem) GetDefault() *Value {
	if m != nil {
		return m.Default
	}
	return nil
}

type SensorDataResult struct {
	Result               []*ResultValueItem `protobuf:"bytes,1,rep,name=result" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *SensorDataResult) Reset()         { *m = SensorDataResult{} }
func (m *SensorDataResult) String() string { return proto.CompactTextString(m) }
func (*SensorDataResult) ProtoMessage()    {}
func (*SensorDataResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{6}
}
func (m *SensorDataResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SensorDataResult.Unmarshal(m, b)
}
func (m *SensorDataResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SensorDataResult.Marshal(b, m, deterministic)
}
func (dst *SensorDataResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SensorDataResult.Merge(dst, src)
}
func (m *SensorDataResult) XXX_Size() int {
	return xxx_messageInfo_SensorDataResult.Size(m)
}
func (m *SensorDataResult) XXX_DiscardUnknown() {
	xxx_messageInfo_SensorDataResult.DiscardUnknown(m)
}

var xxx_messageInfo_SensorDataResult proto.InternalMessageInfo

func (m *SensorDataResult) GetResult() []*ResultValueItem {
	if m != nil {
		return m.Result
	}
	return nil
}

type SensorInfoResult struct {
	Result               []*InfoResultItem `protobuf:"bytes,1,rep,name=result" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *SensorInfoResult) Reset()         { *m = SensorInfoResult{} }
func (m *SensorInfoResult) String() string { return proto.CompactTextString(m) }
func (*SensorInfoResult) ProtoMessage()    {}
func (*SensorInfoResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{7}
}
func (m *SensorInfoResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SensorInfoResult.Unmarshal(m, b)
}
func (m *SensorInfoResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SensorInfoResult.Marshal(b, m, deterministic)
}
func (dst *SensorInfoResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SensorInfoResult.Merge(dst, src)
}
func (m *SensorInfoResult) XXX_Size() int {
	return xxx_messageInfo_SensorInfoResult.Size(m)
}
func (m *SensorInfoResult) XXX_DiscardUnknown() {
	xxx_messageInfo_SensorInfoResult.DiscardUnknown(m)
}

var xxx_messageInfo_SensorInfoResult proto.InternalMessageInfo

func (m *SensorInfoResult) GetResult() []*InfoResultItem {
	if m != nil {
		return m.Result
	}
	return nil
}

type ConfigInfoResult struct {
	Result               []*InfoResultItem `protobuf:"bytes,1,rep,name=result" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ConfigInfoResult) Reset()         { *m = ConfigInfoResult{} }
func (m *ConfigInfoResult) String() string { return proto.CompactTextString(m) }
func (*ConfigInfoResult) ProtoMessage()    {}
func (*ConfigInfoResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{8}
}
func (m *ConfigInfoResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConfigInfoResult.Unmarshal(m, b)
}
func (m *ConfigInfoResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConfigInfoResult.Marshal(b, m, deterministic)
}
func (dst *ConfigInfoResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigInfoResult.Merge(dst, src)
}
func (m *ConfigInfoResult) XXX_Size() int {
	return xxx_messageInfo_ConfigInfoResult.Size(m)
}
func (m *ConfigInfoResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigInfoResult.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigInfoResult proto.InternalMessageInfo

func (m *ConfigInfoResult) GetResult() []*InfoResultItem {
	if m != nil {
		return m.Result
	}
	return nil
}

type ActionInfoResult struct {
	Result               []*InfoResultItem `protobuf:"bytes,1,rep,name=result" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ActionInfoResult) Reset()         { *m = ActionInfoResult{} }
func (m *ActionInfoResult) String() string { return proto.CompactTextString(m) }
func (*ActionInfoResult) ProtoMessage()    {}
func (*ActionInfoResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{9}
}
func (m *ActionInfoResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ActionInfoResult.Unmarshal(m, b)
}
func (m *ActionInfoResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ActionInfoResult.Marshal(b, m, deterministic)
}
func (dst *ActionInfoResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ActionInfoResult.Merge(dst, src)
}
func (m *ActionInfoResult) XXX_Size() int {
	return xxx_messageInfo_ActionInfoResult.Size(m)
}
func (m *ActionInfoResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ActionInfoResult.DiscardUnknown(m)
}

var xxx_messageInfo_ActionInfoResult proto.InternalMessageInfo

func (m *ActionInfoResult) GetResult() []*InfoResultItem {
	if m != nil {
		return m.Result
	}
	return nil
}

type ConnectionInfoResult struct {
	Result               []*ConnectionInfoItem `protobuf:"bytes,1,rep,name=result" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *ConnectionInfoResult) Reset()         { *m = ConnectionInfoResult{} }
func (m *ConnectionInfoResult) String() string { return proto.CompactTextString(m) }
func (*ConnectionInfoResult) ProtoMessage()    {}
func (*ConnectionInfoResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{10}
}
func (m *ConnectionInfoResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectionInfoResult.Unmarshal(m, b)
}
func (m *ConnectionInfoResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectionInfoResult.Marshal(b, m, deterministic)
}
func (dst *ConnectionInfoResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectionInfoResult.Merge(dst, src)
}
func (m *ConnectionInfoResult) XXX_Size() int {
	return xxx_messageInfo_ConnectionInfoResult.Size(m)
}
func (m *ConnectionInfoResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectionInfoResult.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectionInfoResult proto.InternalMessageInfo

func (m *ConnectionInfoResult) GetResult() []*ConnectionInfoItem {
	if m != nil {
		return m.Result
	}
	return nil
}

type ConnectionInfoItem struct {
	Timeout   uint32   `protobuf:"varint,1,opt,name=timeout,proto3" json:"timeout,omitempty"`
	Gateways  []string `protobuf:"bytes,2,rep,name=gateways" json:"gateways,omitempty"`
	Transport string   `protobuf:"bytes,3,opt,name=transport,proto3" json:"transport,omitempty"`
	// Types that are valid to be assigned to TransportObj:
	//	*ConnectionInfoItem_Can
	//	*ConnectionInfoItem_Legacy
	//	*ConnectionInfoItem_Cellular
	//	*ConnectionInfoItem_Lora
	TransportObj         isConnectionInfoItem_TransportObj `protobuf_oneof:"transportObj"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

func (m *ConnectionInfoItem) Reset()         { *m = ConnectionInfoItem{} }
func (m *ConnectionInfoItem) String() string { return proto.CompactTextString(m) }
func (*ConnectionInfoItem) ProtoMessage()    {}
func (*ConnectionInfoItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{11}
}
func (m *ConnectionInfoItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectionInfoItem.Unmarshal(m, b)
}
func (m *ConnectionInfoItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectionInfoItem.Marshal(b, m, deterministic)
}
func (dst *ConnectionInfoItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectionInfoItem.Merge(dst, src)
}
func (m *ConnectionInfoItem) XXX_Size() int {
	return xxx_messageInfo_ConnectionInfoItem.Size(m)
}
func (m *ConnectionInfoItem) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectionInfoItem.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectionInfoItem proto.InternalMessageInfo

type isConnectionInfoItem_TransportObj interface {
	isConnectionInfoItem_TransportObj()
}

type ConnectionInfoItem_Can struct {
	Can *ConnectionInfoTransportCAN `protobuf:"bytes,10,opt,name=can,oneof"`
}
type ConnectionInfoItem_Legacy struct {
	Legacy *ConnectionInfoTransportLegacy `protobuf:"bytes,11,opt,name=legacy,oneof"`
}
type ConnectionInfoItem_Cellular struct {
	Cellular *ConnectionInfoTransportCellular `protobuf:"bytes,12,opt,name=cellular,oneof"`
}
type ConnectionInfoItem_Lora struct {
	Lora *ConnectionInfoTransportLoRa `protobuf:"bytes,13,opt,name=lora,oneof"`
}

func (*ConnectionInfoItem_Can) isConnectionInfoItem_TransportObj()      {}
func (*ConnectionInfoItem_Legacy) isConnectionInfoItem_TransportObj()   {}
func (*ConnectionInfoItem_Cellular) isConnectionInfoItem_TransportObj() {}
func (*ConnectionInfoItem_Lora) isConnectionInfoItem_TransportObj()     {}

func (m *ConnectionInfoItem) GetTransportObj() isConnectionInfoItem_TransportObj {
	if m != nil {
		return m.TransportObj
	}
	return nil
}

func (m *ConnectionInfoItem) GetTimeout() uint32 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

func (m *ConnectionInfoItem) GetGateways() []string {
	if m != nil {
		return m.Gateways
	}
	return nil
}

func (m *ConnectionInfoItem) GetTransport() string {
	if m != nil {
		return m.Transport
	}
	return ""
}

func (m *ConnectionInfoItem) GetCan() *ConnectionInfoTransportCAN {
	if x, ok := m.GetTransportObj().(*ConnectionInfoItem_Can); ok {
		return x.Can
	}
	return nil
}

func (m *ConnectionInfoItem) GetLegacy() *ConnectionInfoTransportLegacy {
	if x, ok := m.GetTransportObj().(*ConnectionInfoItem_Legacy); ok {
		return x.Legacy
	}
	return nil
}

func (m *ConnectionInfoItem) GetCellular() *ConnectionInfoTransportCellular {
	if x, ok := m.GetTransportObj().(*ConnectionInfoItem_Cellular); ok {
		return x.Cellular
	}
	return nil
}

func (m *ConnectionInfoItem) GetLora() *ConnectionInfoTransportLoRa {
	if x, ok := m.GetTransportObj().(*ConnectionInfoItem_Lora); ok {
		return x.Lora
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ConnectionInfoItem) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ConnectionInfoItem_OneofMarshaler, _ConnectionInfoItem_OneofUnmarshaler, _ConnectionInfoItem_OneofSizer, []interface{}{
		(*ConnectionInfoItem_Can)(nil),
		(*ConnectionInfoItem_Legacy)(nil),
		(*ConnectionInfoItem_Cellular)(nil),
		(*ConnectionInfoItem_Lora)(nil),
	}
}

func _ConnectionInfoItem_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ConnectionInfoItem)
	// transportObj
	switch x := m.TransportObj.(type) {
	case *ConnectionInfoItem_Can:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Can); err != nil {
			return err
		}
	case *ConnectionInfoItem_Legacy:
		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Legacy); err != nil {
			return err
		}
	case *ConnectionInfoItem_Cellular:
		_ = b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Cellular); err != nil {
			return err
		}
	case *ConnectionInfoItem_Lora:
		_ = b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Lora); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ConnectionInfoItem.TransportObj has unexpected type %T", x)
	}
	return nil
}

func _ConnectionInfoItem_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ConnectionInfoItem)
	switch tag {
	case 10: // transportObj.can
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ConnectionInfoTransportCAN)
		err := b.DecodeMessage(msg)
		m.TransportObj = &ConnectionInfoItem_Can{msg}
		return true, err
	case 11: // transportObj.legacy
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ConnectionInfoTransportLegacy)
		err := b.DecodeMessage(msg)
		m.TransportObj = &ConnectionInfoItem_Legacy{msg}
		return true, err
	case 12: // transportObj.cellular
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ConnectionInfoTransportCellular)
		err := b.DecodeMessage(msg)
		m.TransportObj = &ConnectionInfoItem_Cellular{msg}
		return true, err
	case 13: // transportObj.lora
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ConnectionInfoTransportLoRa)
		err := b.DecodeMessage(msg)
		m.TransportObj = &ConnectionInfoItem_Lora{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ConnectionInfoItem_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ConnectionInfoItem)
	// transportObj
	switch x := m.TransportObj.(type) {
	case *ConnectionInfoItem_Can:
		s := proto.Size(x.Can)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ConnectionInfoItem_Legacy:
		s := proto.Size(x.Legacy)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ConnectionInfoItem_Cellular:
		s := proto.Size(x.Cellular)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ConnectionInfoItem_Lora:
		s := proto.Size(x.Lora)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type ConnectionInfoTransportCAN struct {
	Nodeid               uint32   `protobuf:"varint,1,opt,name=nodeid,proto3" json:"nodeid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConnectionInfoTransportCAN) Reset()         { *m = ConnectionInfoTransportCAN{} }
func (m *ConnectionInfoTransportCAN) String() string { return proto.CompactTextString(m) }
func (*ConnectionInfoTransportCAN) ProtoMessage()    {}
func (*ConnectionInfoTransportCAN) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{12}
}
func (m *ConnectionInfoTransportCAN) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectionInfoTransportCAN.Unmarshal(m, b)
}
func (m *ConnectionInfoTransportCAN) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectionInfoTransportCAN.Marshal(b, m, deterministic)
}
func (dst *ConnectionInfoTransportCAN) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectionInfoTransportCAN.Merge(dst, src)
}
func (m *ConnectionInfoTransportCAN) XXX_Size() int {
	return xxx_messageInfo_ConnectionInfoTransportCAN.Size(m)
}
func (m *ConnectionInfoTransportCAN) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectionInfoTransportCAN.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectionInfoTransportCAN proto.InternalMessageInfo

func (m *ConnectionInfoTransportCAN) GetNodeid() uint32 {
	if m != nil {
		return m.Nodeid
	}
	return 0
}

type ConnectionInfoTransportLegacy struct {
	DatabaseId           uint32   `protobuf:"varint,1,opt,name=database_id,json=databaseId,proto3" json:"database_id,omitempty"`
	Imsi                 string   `protobuf:"bytes,2,opt,name=imsi,proto3" json:"imsi,omitempty"`
	Iccid                string   `protobuf:"bytes,3,opt,name=iccid,proto3" json:"iccid,omitempty"`
	Imei                 string   `protobuf:"bytes,4,opt,name=imei,proto3" json:"imei,omitempty"`
	GprsApn              string   `protobuf:"bytes,5,opt,name=gprs_apn,json=gprsApn,proto3" json:"gprs_apn,omitempty"`
	Endpoint             string   `protobuf:"bytes,6,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConnectionInfoTransportLegacy) Reset()         { *m = ConnectionInfoTransportLegacy{} }
func (m *ConnectionInfoTransportLegacy) String() string { return proto.CompactTextString(m) }
func (*ConnectionInfoTransportLegacy) ProtoMessage()    {}
func (*ConnectionInfoTransportLegacy) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{13}
}
func (m *ConnectionInfoTransportLegacy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectionInfoTransportLegacy.Unmarshal(m, b)
}
func (m *ConnectionInfoTransportLegacy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectionInfoTransportLegacy.Marshal(b, m, deterministic)
}
func (dst *ConnectionInfoTransportLegacy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectionInfoTransportLegacy.Merge(dst, src)
}
func (m *ConnectionInfoTransportLegacy) XXX_Size() int {
	return xxx_messageInfo_ConnectionInfoTransportLegacy.Size(m)
}
func (m *ConnectionInfoTransportLegacy) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectionInfoTransportLegacy.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectionInfoTransportLegacy proto.InternalMessageInfo

func (m *ConnectionInfoTransportLegacy) GetDatabaseId() uint32 {
	if m != nil {
		return m.DatabaseId
	}
	return 0
}

func (m *ConnectionInfoTransportLegacy) GetImsi() string {
	if m != nil {
		return m.Imsi
	}
	return ""
}

func (m *ConnectionInfoTransportLegacy) GetIccid() string {
	if m != nil {
		return m.Iccid
	}
	return ""
}

func (m *ConnectionInfoTransportLegacy) GetImei() string {
	if m != nil {
		return m.Imei
	}
	return ""
}

func (m *ConnectionInfoTransportLegacy) GetGprsApn() string {
	if m != nil {
		return m.GprsApn
	}
	return ""
}

func (m *ConnectionInfoTransportLegacy) GetEndpoint() string {
	if m != nil {
		return m.Endpoint
	}
	return ""
}

type ConnectionInfoTransportCellular struct {
	Operator             string   `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"`
	Imsi                 string   `protobuf:"bytes,2,opt,name=imsi,proto3" json:"imsi,omitempty"`
	Iccid                string   `protobuf:"bytes,3,opt,name=iccid,proto3" json:"iccid,omitempty"`
	Imei                 string   `protobuf:"bytes,4,opt,name=imei,proto3" json:"imei,omitempty"`
	GprsApn              string   `protobuf:"bytes,5,opt,name=gprs_apn,json=gprsApn,proto3" json:"gprs_apn,omitempty"`
	Endpoint             string   `protobuf:"bytes,6,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConnectionInfoTransportCellular) Reset()         { *m = ConnectionInfoTransportCellular{} }
func (m *ConnectionInfoTransportCellular) String() string { return proto.CompactTextString(m) }
func (*ConnectionInfoTransportCellular) ProtoMessage()    {}
func (*ConnectionInfoTransportCellular) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{14}
}
func (m *ConnectionInfoTransportCellular) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectionInfoTransportCellular.Unmarshal(m, b)
}
func (m *ConnectionInfoTransportCellular) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectionInfoTransportCellular.Marshal(b, m, deterministic)
}
func (dst *ConnectionInfoTransportCellular) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectionInfoTransportCellular.Merge(dst, src)
}
func (m *ConnectionInfoTransportCellular) XXX_Size() int {
	return xxx_messageInfo_ConnectionInfoTransportCellular.Size(m)
}
func (m *ConnectionInfoTransportCellular) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectionInfoTransportCellular.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectionInfoTransportCellular proto.InternalMessageInfo

func (m *ConnectionInfoTransportCellular) GetOperator() string {
	if m != nil {
		return m.Operator
	}
	return ""
}

func (m *ConnectionInfoTransportCellular) GetImsi() string {
	if m != nil {
		return m.Imsi
	}
	return ""
}

func (m *ConnectionInfoTransportCellular) GetIccid() string {
	if m != nil {
		return m.Iccid
	}
	return ""
}

func (m *ConnectionInfoTransportCellular) GetImei() string {
	if m != nil {
		return m.Imei
	}
	return ""
}

func (m *ConnectionInfoTransportCellular) GetGprsApn() string {
	if m != nil {
		return m.GprsApn
	}
	return ""
}

func (m *ConnectionInfoTransportCellular) GetEndpoint() string {
	if m != nil {
		return m.Endpoint
	}
	return ""
}

type ConnectionInfoTransportLoRa struct {
	DevEui               string   `protobuf:"bytes,1,opt,name=dev_eui,json=devEui,proto3" json:"dev_eui,omitempty"`
	Operator             string   `protobuf:"bytes,2,opt,name=operator,proto3" json:"operator,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConnectionInfoTransportLoRa) Reset()         { *m = ConnectionInfoTransportLoRa{} }
func (m *ConnectionInfoTransportLoRa) String() string { return proto.CompactTextString(m) }
func (*ConnectionInfoTransportLoRa) ProtoMessage()    {}
func (*ConnectionInfoTransportLoRa) Descriptor() ([]byte, []int) {
	return fileDescriptor_dinetrpc_8f826dd8d23efe6c, []int{15}
}
func (m *ConnectionInfoTransportLoRa) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectionInfoTransportLoRa.Unmarshal(m, b)
}
func (m *ConnectionInfoTransportLoRa) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectionInfoTransportLoRa.Marshal(b, m, deterministic)
}
func (dst *ConnectionInfoTransportLoRa) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectionInfoTransportLoRa.Merge(dst, src)
}
func (m *ConnectionInfoTransportLoRa) XXX_Size() int {
	return xxx_messageInfo_ConnectionInfoTransportLoRa.Size(m)
}
func (m *ConnectionInfoTransportLoRa) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectionInfoTransportLoRa.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectionInfoTransportLoRa proto.InternalMessageInfo

func (m *ConnectionInfoTransportLoRa) GetDevEui() string {
	if m != nil {
		return m.DevEui
	}
	return ""
}

func (m *ConnectionInfoTransportLoRa) GetOperator() string {
	if m != nil {
		return m.Operator
	}
	return ""
}

func init() {
	proto.RegisterType((*HeaderMsg)(nil), "dinetrpc.HeaderMsg")
	proto.RegisterType((*Value)(nil), "dinetrpc.Value")
	proto.RegisterType((*GPSValue)(nil), "dinetrpc.GPSValue")
	proto.RegisterType((*Msg)(nil), "dinetrpc.Msg")
	proto.RegisterType((*ResultValueItem)(nil), "dinetrpc.ResultValueItem")
	proto.RegisterType((*InfoResultItem)(nil), "dinetrpc.InfoResultItem")
	proto.RegisterMapType((map[string]int32)(nil), "dinetrpc.InfoResultItem.EnumEntry")
	proto.RegisterType((*SensorDataResult)(nil), "dinetrpc.SensorDataResult")
	proto.RegisterType((*SensorInfoResult)(nil), "dinetrpc.SensorInfoResult")
	proto.RegisterType((*ConfigInfoResult)(nil), "dinetrpc.ConfigInfoResult")
	proto.RegisterType((*ActionInfoResult)(nil), "dinetrpc.ActionInfoResult")
	proto.RegisterType((*ConnectionInfoResult)(nil), "dinetrpc.ConnectionInfoResult")
	proto.RegisterType((*ConnectionInfoItem)(nil), "dinetrpc.ConnectionInfoItem")
	proto.RegisterType((*ConnectionInfoTransportCAN)(nil), "dinetrpc.ConnectionInfoTransportCAN")
	proto.RegisterType((*ConnectionInfoTransportLegacy)(nil), "dinetrpc.ConnectionInfoTransportLegacy")
	proto.RegisterType((*ConnectionInfoTransportCellular)(nil), "dinetrpc.ConnectionInfoTransportCellular")
	proto.RegisterType((*ConnectionInfoTransportLoRa)(nil), "dinetrpc.ConnectionInfoTransportLoRa")
	proto.RegisterEnum("dinetrpc.ClassMethod", ClassMethod_name, ClassMethod_value)
	proto.RegisterEnum("dinetrpc.MsgType", MsgType_name, MsgType_value)
}

func init() { proto.RegisterFile("dinetrpc.proto", fileDescriptor_dinetrpc_8f826dd8d23efe6c) }

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