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

package proto

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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 Device struct {
	Id            string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	DevId         string `protobuf:"bytes,2,opt,name=devId,proto3" json:"devId,omitempty"`
	DevType       string `protobuf:"bytes,3,opt,name=devType,proto3" json:"devType,omitempty"`
	DevMode       string `protobuf:"bytes,4,opt,name=devMode,proto3" json:"devMode,omitempty"`
	DevName       string `protobuf:"bytes,5,opt,name=devName,proto3" json:"devName,omitempty"`
	MachineCode   string `protobuf:"bytes,6,opt,name=machineCode,proto3" json:"machineCode,omitempty"`
	ActivateCode  string `protobuf:"bytes,7,opt,name=activateCode,proto3" json:"activateCode,omitempty"`
	ProductId     string `protobuf:"bytes,8,opt,name=productId,proto3" json:"productId,omitempty"`
	UserId        string `protobuf:"bytes,9,opt,name=userId,proto3" json:"userId,omitempty"`
	Address       string `protobuf:"bytes,10,opt,name=address,proto3" json:"address,omitempty"`
	DevIp         string `protobuf:"bytes,11,opt,name=devIp,proto3" json:"devIp,omitempty"`
	DevCpu        string `protobuf:"bytes,12,opt,name=devCpu,proto3" json:"devCpu,omitempty"`
	DevGpu        string `protobuf:"bytes,13,opt,name=devGpu,proto3" json:"devGpu,omitempty"`
	Mem           int32  `protobuf:"varint,14,opt,name=mem,proto3" json:"mem,omitempty"`
	Disk          string `protobuf:"bytes,15,opt,name=disk,proto3" json:"disk,omitempty"`
	ChannelCount  int32  `protobuf:"varint,16,opt,name=channelCount,proto3" json:"channelCount,omitempty"`
	MasterVersion string `protobuf:"bytes,17,opt,name=masterVersion,proto3" json:"masterVersion,omitempty"`
	WebVersion    string `protobuf:"bytes,18,opt,name=webVersion,proto3" json:"webVersion,omitempty"`
	ServerPort    string `protobuf:"bytes,19,opt,name=serverPort,proto3" json:"serverPort,omitempty"`
	SubMask       string `protobuf:"bytes,20,opt,name=subMask,proto3" json:"subMask,omitempty"`
	Gateway       string `protobuf:"bytes,21,opt,name=gateway,proto3" json:"gateway,omitempty"`
	Dns           string `protobuf:"bytes,22,opt,name=dns,proto3" json:"dns,omitempty"`
	Runtime       string `protobuf:"bytes,23,opt,name=runtime,proto3" json:"runtime,omitempty"`
	InstallTime   string `protobuf:"bytes,24,opt,name=installTime,proto3" json:"installTime,omitempty"`
	FirstUseTime  string `protobuf:"bytes,25,opt,name=firstUseTime,proto3" json:"firstUseTime,omitempty"`
	ClusterId     string `protobuf:"bytes,26,opt,name=clusterId,proto3" json:"clusterId,omitempty"`
	ClusterName   string `protobuf:"bytes,27,opt,name=clusterName,proto3" json:"clusterName,omitempty"`
	Status        int32  `protobuf:"varint,28,opt,name=status,proto3" json:"status,omitempty"`
	CreateTime    string `protobuf:"bytes,29,opt,name=createTime,proto3" json:"createTime,omitempty"`
	UpdateTime    string `protobuf:"bytes,30,opt,name=updateTime,proto3" json:"updateTime,omitempty"`
}

func (m *Device) Reset()         { *m = Device{} }
func (m *Device) String() string { return proto.CompactTextString(m) }
func (*Device) ProtoMessage()    {}
func (*Device) Descriptor() ([]byte, []int) {
	return fileDescriptor_870276a56ac00da5, []int{0}
}
func (m *Device) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Device) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Device.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Device) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Device.Merge(m, src)
}
func (m *Device) XXX_Size() int {
	return m.Size()
}
func (m *Device) XXX_DiscardUnknown() {
	xxx_messageInfo_Device.DiscardUnknown(m)
}

var xxx_messageInfo_Device proto.InternalMessageInfo

func (m *Device) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Device) GetDevId() string {
	if m != nil {
		return m.DevId
	}
	return ""
}

func (m *Device) GetDevType() string {
	if m != nil {
		return m.DevType
	}
	return ""
}

func (m *Device) GetDevMode() string {
	if m != nil {
		return m.DevMode
	}
	return ""
}

func (m *Device) GetDevName() string {
	if m != nil {
		return m.DevName
	}
	return ""
}

func (m *Device) GetMachineCode() string {
	if m != nil {
		return m.MachineCode
	}
	return ""
}

func (m *Device) GetActivateCode() string {
	if m != nil {
		return m.ActivateCode
	}
	return ""
}

func (m *Device) GetProductId() string {
	if m != nil {
		return m.ProductId
	}
	return ""
}

func (m *Device) GetUserId() string {
	if m != nil {
		return m.UserId
	}
	return ""
}

func (m *Device) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *Device) GetDevIp() string {
	if m != nil {
		return m.DevIp
	}
	return ""
}

func (m *Device) GetDevCpu() string {
	if m != nil {
		return m.DevCpu
	}
	return ""
}

func (m *Device) GetDevGpu() string {
	if m != nil {
		return m.DevGpu
	}
	return ""
}

func (m *Device) GetMem() int32 {
	if m != nil {
		return m.Mem
	}
	return 0
}

func (m *Device) GetDisk() string {
	if m != nil {
		return m.Disk
	}
	return ""
}

func (m *Device) GetChannelCount() int32 {
	if m != nil {
		return m.ChannelCount
	}
	return 0
}

func (m *Device) GetMasterVersion() string {
	if m != nil {
		return m.MasterVersion
	}
	return ""
}

func (m *Device) GetWebVersion() string {
	if m != nil {
		return m.WebVersion
	}
	return ""
}

func (m *Device) GetServerPort() string {
	if m != nil {
		return m.ServerPort
	}
	return ""
}

func (m *Device) GetSubMask() string {
	if m != nil {
		return m.SubMask
	}
	return ""
}

func (m *Device) GetGateway() string {
	if m != nil {
		return m.Gateway
	}
	return ""
}

func (m *Device) GetDns() string {
	if m != nil {
		return m.Dns
	}
	return ""
}

func (m *Device) GetRuntime() string {
	if m != nil {
		return m.Runtime
	}
	return ""
}

func (m *Device) GetInstallTime() string {
	if m != nil {
		return m.InstallTime
	}
	return ""
}

func (m *Device) GetFirstUseTime() string {
	if m != nil {
		return m.FirstUseTime
	}
	return ""
}

func (m *Device) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *Device) GetClusterName() string {
	if m != nil {
		return m.ClusterName
	}
	return ""
}

func (m *Device) GetStatus() int32 {
	if m != nil {
		return m.Status
	}
	return 0
}

func (m *Device) GetCreateTime() string {
	if m != nil {
		return m.CreateTime
	}
	return ""
}

func (m *Device) GetUpdateTime() string {
	if m != nil {
		return m.UpdateTime
	}
	return ""
}

func init() {
	proto.RegisterType((*Device)(nil), "proto.Device")
}

func init() { proto.RegisterFile("device.proto", fileDescriptor_870276a56ac00da5) }

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

func (m *Device) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Device) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.DevId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.DevId)))
		i += copy(dAtA[i:], m.DevId)
	}
	if len(m.DevType) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.DevType)))
		i += copy(dAtA[i:], m.DevType)
	}
	if len(m.DevMode) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.DevMode)))
		i += copy(dAtA[i:], m.DevMode)
	}
	if len(m.DevName) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.DevName)))
		i += copy(dAtA[i:], m.DevName)
	}
	if len(m.MachineCode) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.MachineCode)))
		i += copy(dAtA[i:], m.MachineCode)
	}
	if len(m.ActivateCode) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.ActivateCode)))
		i += copy(dAtA[i:], m.ActivateCode)
	}
	if len(m.ProductId) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.ProductId)))
		i += copy(dAtA[i:], m.ProductId)
	}
	if len(m.UserId) > 0 {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.UserId)))
		i += copy(dAtA[i:], m.UserId)
	}
	if len(m.Address) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.Address)))
		i += copy(dAtA[i:], m.Address)
	}
	if len(m.DevIp) > 0 {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.DevIp)))
		i += copy(dAtA[i:], m.DevIp)
	}
	if len(m.DevCpu) > 0 {
		dAtA[i] = 0x62
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.DevCpu)))
		i += copy(dAtA[i:], m.DevCpu)
	}
	if len(m.DevGpu) > 0 {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.DevGpu)))
		i += copy(dAtA[i:], m.DevGpu)
	}
	if m.Mem != 0 {
		dAtA[i] = 0x70
		i++
		i = encodeVarintDevice(dAtA, i, uint64(m.Mem))
	}
	if len(m.Disk) > 0 {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.Disk)))
		i += copy(dAtA[i:], m.Disk)
	}
	if m.ChannelCount != 0 {
		dAtA[i] = 0x80
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(m.ChannelCount))
	}
	if len(m.MasterVersion) > 0 {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.MasterVersion)))
		i += copy(dAtA[i:], m.MasterVersion)
	}
	if len(m.WebVersion) > 0 {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.WebVersion)))
		i += copy(dAtA[i:], m.WebVersion)
	}
	if len(m.ServerPort) > 0 {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.ServerPort)))
		i += copy(dAtA[i:], m.ServerPort)
	}
	if len(m.SubMask) > 0 {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.SubMask)))
		i += copy(dAtA[i:], m.SubMask)
	}
	if len(m.Gateway) > 0 {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.Gateway)))
		i += copy(dAtA[i:], m.Gateway)
	}
	if len(m.Dns) > 0 {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.Dns)))
		i += copy(dAtA[i:], m.Dns)
	}
	if len(m.Runtime) > 0 {
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.Runtime)))
		i += copy(dAtA[i:], m.Runtime)
	}
	if len(m.InstallTime) > 0 {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.InstallTime)))
		i += copy(dAtA[i:], m.InstallTime)
	}
	if len(m.FirstUseTime) > 0 {
		dAtA[i] = 0xca
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.FirstUseTime)))
		i += copy(dAtA[i:], m.FirstUseTime)
	}
	if len(m.ClusterId) > 0 {
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.ClusterId)))
		i += copy(dAtA[i:], m.ClusterId)
	}
	if len(m.ClusterName) > 0 {
		dAtA[i] = 0xda
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.ClusterName)))
		i += copy(dAtA[i:], m.ClusterName)
	}
	if m.Status != 0 {
		dAtA[i] = 0xe0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(m.Status))
	}
	if len(m.CreateTime) > 0 {
		dAtA[i] = 0xea
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.CreateTime)))
		i += copy(dAtA[i:], m.CreateTime)
	}
	if len(m.UpdateTime) > 0 {
		dAtA[i] = 0xf2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintDevice(dAtA, i, uint64(len(m.UpdateTime)))
		i += copy(dAtA[i:], m.UpdateTime)
	}
	return i, nil
}

func encodeVarintDevice(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Device) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.DevId)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.DevType)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.DevMode)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.DevName)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.MachineCode)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.ActivateCode)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.ProductId)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.UserId)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.DevIp)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.DevCpu)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	l = len(m.DevGpu)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	if m.Mem != 0 {
		n += 1 + sovDevice(uint64(m.Mem))
	}
	l = len(m.Disk)
	if l > 0 {
		n += 1 + l + sovDevice(uint64(l))
	}
	if m.ChannelCount != 0 {
		n += 2 + sovDevice(uint64(m.ChannelCount))
	}
	l = len(m.MasterVersion)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.WebVersion)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.ServerPort)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.SubMask)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.Gateway)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.Dns)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.Runtime)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.InstallTime)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.FirstUseTime)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.ClusterId)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.ClusterName)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	if m.Status != 0 {
		n += 2 + sovDevice(uint64(m.Status))
	}
	l = len(m.CreateTime)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	l = len(m.UpdateTime)
	if l > 0 {
		n += 2 + l + sovDevice(uint64(l))
	}
	return n
}

func sovDevice(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDevice(x uint64) (n int) {
	return sovDevice(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Device) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDevice
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Device: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Device: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevMode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevMode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MachineCode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MachineCode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActivateCode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActivateCode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProductId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProductId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UserId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevCpu", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevCpu = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevGpu", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevGpu = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mem", wireType)
			}
			m.Mem = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mem |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Disk", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Disk = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelCount", wireType)
			}
			m.ChannelCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelCount |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MasterVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MasterVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WebVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WebVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerPort", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerPort = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubMask", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubMask = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gateway", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Gateway = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dns", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dns = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Runtime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Runtime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstallTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InstallTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstUseTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FirstUseTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 28:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreateTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDevice
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDevice
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpdateTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDevice(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDevice
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDevice
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipDevice(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowDevice
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowDevice
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthDevice
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthDevice
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowDevice
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipDevice(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthDevice
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthDevice = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDevice   = fmt.Errorf("proto: integer overflow")
)