github.com/git-amp/amp-sdk-go@v0.7.5/amp/amp.pb.go

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

// package amp is an implementation-independent API for a pluggable client-server UI/UX system,
// featuring support and integration for files, media, and communication.

package amp

import (
	bytes "bytes"
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

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

type Const int32

const (
	Const_Defs Const = 0
	// TIDBinaryLen is the byte size of a Tx ID ("TID"), a hash with a leading big endian binary time index.
	//
	// This allows TIDs to be naturally sorted chronologically naturally.
	// This facilitates Tx storage and Tx syndication (time-ordered Tx playback).
	// Importantly, a TxID (32 bytes) is has a UTC16 prefix, allowing efficient LSM storage to scale to billions of Txs.
	//
	// Byte layout is designed so that TIDs are sortable by their embedded timestamp:
	//    0:6   - Standard UTC timestamp in unix seconds (big endian)
	//    6:8   - Timestamp fraction (big endian)
	//    8:32  - Signature/hash suffix.
	Const_TIDBinaryLen Const = 32
	// TIDStringLen is the ASCII-compatible string length of a (binary) TID encoded into its base32 form.
	// The encoding used is the geo-hash base32 alphabet, so that even ascii ordinal string comparisons will correctly sort encoded TIDs by time.
	Const_TIDStringLen Const = 52
	// DefaultServicePort  is the default TCP port used to expose amp.Host service.
	Const_DefaultServicePort Const = 5192
)

var Const_name = map[int32]string{
	0:    "Const_Defs",
	32:   "Const_TIDBinaryLen",
	52:   "Const_TIDStringLen",
	5192: "Const_DefaultServicePort",
}

var Const_value = map[string]int32{
	"Const_Defs":               0,
	"Const_TIDBinaryLen":       32,
	"Const_TIDStringLen":       52,
	"Const_DefaultServicePort": 5192,
}

func (Const) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{0}
}

type TxHeader int32

const (
	TxHeader_0 TxHeader = 0
	// TxHeader heads a MsgTx serialized data store
	//   Bytes 00:03 -- Reserved (3 bytes)
	//   Bytes 03:07 -- big endian total byte size, including header (4 bytes)
	//   Bytes 07:08 -- TxMsg op code (1 byte)
	TxHeader_Size     TxHeader = 8
	TxHeader_OpOfs    TxHeader = 7
	TxHeader_OpRecvTx TxHeader = 20
	TxHeader_OpEOS    TxHeader = 24
)

var TxHeader_name = map[int32]string{
	0:  "TxHeader_0",
	8:  "TxHeader_Size",
	7:  "TxHeader_OpOfs",
	20: "TxHeader_OpRecvTx",
	24: "TxHeader_OpEOS",
}

var TxHeader_value = map[string]int32{
	"TxHeader_0":        0,
	"TxHeader_Size":     8,
	"TxHeader_OpOfs":    7,
	"TxHeader_OpRecvTx": 20,
	"TxHeader_OpEOS":    24,
}

func (TxHeader) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{1}
}

// These are hard-wired symbol IDs are required to bootstrap a new connection.
// After bootstrapping, the client uses RegisterDefs to register its symbols.
type ConstSymbol int32

const (
	ConstSymbol_nil            ConstSymbol = 0
	ConstSymbol_Err            ConstSymbol = 10
	ConstSymbol_RegisterDefs   ConstSymbol = 11
	ConstSymbol_HandleURI      ConstSymbol = 12
	ConstSymbol_PinRequest     ConstSymbol = 13
	ConstSymbol_Login          ConstSymbol = 20
	ConstSymbol_LoginChallenge ConstSymbol = 21
	ConstSymbol_LoginResponse  ConstSymbol = 22
	// Minimum symbol ID that a client is allowed to issue
	// This value sets a ceiling for the above hard-wired symbol IDs.
	ConstSymbol_IssuerInitsAt ConstSymbol = 256
)

var ConstSymbol_name = map[int32]string{
	0:   "ConstSymbol_nil",
	10:  "ConstSymbol_Err",
	11:  "ConstSymbol_RegisterDefs",
	12:  "ConstSymbol_HandleURI",
	13:  "ConstSymbol_PinRequest",
	20:  "ConstSymbol_Login",
	21:  "ConstSymbol_LoginChallenge",
	22:  "ConstSymbol_LoginResponse",
	256: "ConstSymbol_IssuerInitsAt",
}

var ConstSymbol_value = map[string]int32{
	"ConstSymbol_nil":            0,
	"ConstSymbol_Err":            10,
	"ConstSymbol_RegisterDefs":   11,
	"ConstSymbol_HandleURI":      12,
	"ConstSymbol_PinRequest":     13,
	"ConstSymbol_Login":          20,
	"ConstSymbol_LoginChallenge": 21,
	"ConstSymbol_LoginResponse":  22,
	"ConstSymbol_IssuerInitsAt":  256,
}

func (ConstSymbol) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{2}
}

// ReqStatus allows a sender to express the status of a request.
type ReqStatus int32

const (
	// The request is in the process of being formed
	ReqStatus_NotStarted ReqStatus = 0
	// Denotes that the request is in progress.
	ReqStatus_Syncing ReqStatus = 1
	// Sent by the host to signal that this ReqID up to date and the client state is stable / synchronized.
	// This generally drives UI updates or other aggregate cell dependencies.
	ReqStatus_Synced ReqStatus = 2
	// From the client to host, this signals to close / cancel the op associated with ReqID.
	// From the host to client, this signals that the given request ID has been closed / discarded.
	ReqStatus_Closed ReqStatus = 3
)

var ReqStatus_name = map[int32]string{
	0: "ReqStatus_NotStarted",
	1: "ReqStatus_Syncing",
	2: "ReqStatus_Synced",
	3: "ReqStatus_Closed",
}

var ReqStatus_value = map[string]int32{
	"ReqStatus_NotStarted": 0,
	"ReqStatus_Syncing":    1,
	"ReqStatus_Synced":     2,
	"ReqStatus_Closed":     3,
}

func (ReqStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{3}
}

// CellTxOp specifies a cell transaction operation.
type CellTxOp int32

const (
	CellTxOp_MetaAttr   CellTxOp = 0
	CellTxOp_UpsertCell CellTxOp = 1
	CellTxOp_RemoveCell CellTxOp = 3
)

var CellTxOp_name = map[int32]string{
	0: "CellTxOp_MetaAttr",
	1: "CellTxOp_UpsertCell",
	3: "CellTxOp_RemoveCell",
}

var CellTxOp_value = map[string]int32{
	"CellTxOp_MetaAttr":   0,
	"CellTxOp_UpsertCell": 1,
	"CellTxOp_RemoveCell": 3,
}

func (CellTxOp) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{4}
}

type SeriesIndexType int32

const (
	SeriesIndexType_Literal SeriesIndexType = 0
	SeriesIndexType_Name    SeriesIndexType = 1
)

var SeriesIndexType_name = map[int32]string{
	0: "SeriesIndexType_Literal",
	1: "SeriesIndexType_Name",
}

var SeriesIndexType_value = map[string]int32{
	"SeriesIndexType_Literal": 0,
	"SeriesIndexType_Name":    1,
}

func (SeriesIndexType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{5}
}

type PinFlags int32

const (
	PinFlags_None PinFlags = 0
	// If set, all symbol / attr ID are native symbol IDs.
	// This is used for apps pinning cells and so are using native (not client) IDs.
	PinFlags_UseNativeSymbols PinFlags = 1
	// If set, PinnedCell.ServeState() causes this request (PinContext) to automatically close once state is pushed and synchronized.
	// Otherwise, the request remains open and the client will receive any state updates until closed.
	// This is useful when only a snapshot of the cell is needed.
	PinFlags_CloseOnSync PinFlags = 4
	// If set, a pinned cell will not send any state updates to the client.
	// This is useful when only writing to a cell and no state updates are needed.
	PinFlags_NoSync PinFlags = 8
)

var PinFlags_name = map[int32]string{
	0: "PinFlags_None",
	1: "PinFlags_UseNativeSymbols",
	4: "PinFlags_CloseOnSync",
	8: "PinFlags_NoSync",
}

var PinFlags_value = map[string]int32{
	"PinFlags_None":             0,
	"PinFlags_UseNativeSymbols": 1,
	"PinFlags_CloseOnSync":      4,
	"PinFlags_NoSync":           8,
}

func (PinFlags) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{6}
}

// CordType describes how to interpret coordinates contained in a Position.
type CordType int32

const (
	CordType_Unspecified     CordType = 0
	CordType_Ordered         CordType = 1
	CordType_Plane_Cartesian CordType = 5
	CordType_Plane_HexEvenR  CordType = 6
	CordType_Geoid_Sphere    CordType = 10
	CordType_Geoid_WGS84     CordType = 11
)

var CordType_name = map[int32]string{
	0:  "CordType_Unspecified",
	1:  "CordType_Ordered",
	5:  "CordType_Plane_Cartesian",
	6:  "CordType_Plane_HexEvenR",
	10: "CordType_Geoid_Sphere",
	11: "CordType_Geoid_WGS84",
}

var CordType_value = map[string]int32{
	"CordType_Unspecified":     0,
	"CordType_Ordered":         1,
	"CordType_Plane_Cartesian": 5,
	"CordType_Plane_HexEvenR":  6,
	"CordType_Geoid_Sphere":    10,
	"CordType_Geoid_WGS84":     11,
}

func (CordType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{7}
}

type QuadState int32

const (
	QuadState_LatentOff QuadState = 0
	QuadState_LatentOn  QuadState = 1
	QuadState_ActiveOff QuadState = 16
	QuadState_ActiveOn  QuadState = 17
)

var QuadState_name = map[int32]string{
	0:  "QuadState_LatentOff",
	1:  "QuadState_LatentOn",
	16: "QuadState_ActiveOff",
	17: "QuadState_ActiveOn",
}

var QuadState_value = map[string]int32{
	"QuadState_LatentOff": 0,
	"QuadState_LatentOn":  1,
	"QuadState_ActiveOff": 16,
	"QuadState_ActiveOn":  17,
}

func (QuadState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{8}
}

type UrlScheme int32

const (
	UrlScheme_Nil  UrlScheme = 0
	UrlScheme_Data UrlScheme = 1
	UrlScheme_Amp  UrlScheme = 2
	UrlScheme_File UrlScheme = 3
	UrlScheme_Http UrlScheme = 4
)

var UrlScheme_name = map[int32]string{
	0: "UrlScheme_Nil",
	1: "UrlScheme_Data",
	2: "UrlScheme_Amp",
	3: "UrlScheme_File",
	4: "UrlScheme_Http",
}

var UrlScheme_value = map[string]int32{
	"UrlScheme_Nil":  0,
	"UrlScheme_Data": 1,
	"UrlScheme_Amp":  2,
	"UrlScheme_File": 3,
	"UrlScheme_Http": 4,
}

func (UrlScheme) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{9}
}

// CryptoKitID identifies an encryption suite that implements ski.CryptoKit
type CryptoKitID int32

const (
	CryptoKit_Nil             CryptoKitID = 0
	CryptoKit_SecretBox_NaCl  CryptoKitID = 100
	CryptoKit_AsymMsg_NaCl    CryptoKitID = 101
	CryptoKit_Signing_NaCl    CryptoKitID = 102
	CryptoKit_Signing_ED25519 CryptoKitID = 202
)

var CryptoKitID_name = map[int32]string{
	0:   "CryptoKit_Nil",
	100: "CryptoKit_SecretBox_NaCl",
	101: "CryptoKit_AsymMsg_NaCl",
	102: "CryptoKit_Signing_NaCl",
	202: "CryptoKit_Signing_ED25519",
}

var CryptoKitID_value = map[string]int32{
	"CryptoKit_Nil":             0,
	"CryptoKit_SecretBox_NaCl":  100,
	"CryptoKit_AsymMsg_NaCl":    101,
	"CryptoKit_Signing_NaCl":    102,
	"CryptoKit_Signing_ED25519": 202,
}

func (CryptoKitID) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{10}
}

// ErrCode expresses status and error codes.
type ErrCode int32

const (
	ErrCode_NoErr                   ErrCode = 0
	ErrCode_UnnamedErr              ErrCode = 5000
	ErrCode_InternalErr             ErrCode = 5001
	ErrCode_UnsupportedOp           ErrCode = 5002
	ErrCode_Unimplemented           ErrCode = 5003
	ErrCode_Timeout                 ErrCode = 5004
	ErrCode_ShuttingDown            ErrCode = 5005
	ErrCode_NotConnected            ErrCode = 5006
	ErrCode_AuthFailed              ErrCode = 5007
	ErrCode_LoginFailed             ErrCode = 5008
	ErrCode_SessionExpired          ErrCode = 5009
	ErrCode_ReqNotFound             ErrCode = 5010
	ErrCode_InvalidReq              ErrCode = 5020
	ErrCode_InvalidURI              ErrCode = 5021
	ErrCode_BadValue                ErrCode = 5022
	ErrCode_NothingToCommit         ErrCode = 5030
	ErrCode_CommitFailed            ErrCode = 5031
	ErrCode_PlanetNotFound          ErrCode = 5032
	ErrCode_PlanetFailure           ErrCode = 5033
	ErrCode_AppNotFound             ErrCode = 5034
	ErrCode_DefNotFound             ErrCode = 5036
	ErrCode_MalformedTx             ErrCode = 5040
	ErrCode_TypeNotFound            ErrCode = 5050
	ErrCode_TypeNotRegistered       ErrCode = 5051
	ErrCode_BadSchema               ErrCode = 5052
	ErrCode_DataFailure             ErrCode = 5053
	ErrCode_ExportErr               ErrCode = 5054
	ErrCode_PinFailed               ErrCode = 5055
	ErrCode_PinContextClosed        ErrCode = 5056
	ErrCode_CellNotFound            ErrCode = 5058
	ErrCode_ProviderErr             ErrCode = 5059
	ErrCode_ViolatesAppendOnly      ErrCode = 5100
	ErrCode_InsufficientPermissions ErrCode = 5101
)

var ErrCode_name = map[int32]string{
	0:    "ErrCode_NoErr",
	5000: "ErrCode_UnnamedErr",
	5001: "ErrCode_InternalErr",
	5002: "ErrCode_UnsupportedOp",
	5003: "ErrCode_Unimplemented",
	5004: "ErrCode_Timeout",
	5005: "ErrCode_ShuttingDown",
	5006: "ErrCode_NotConnected",
	5007: "ErrCode_AuthFailed",
	5008: "ErrCode_LoginFailed",
	5009: "ErrCode_SessionExpired",
	5010: "ErrCode_ReqNotFound",
	5020: "ErrCode_InvalidReq",
	5021: "ErrCode_InvalidURI",
	5022: "ErrCode_BadValue",
	5030: "ErrCode_NothingToCommit",
	5031: "ErrCode_CommitFailed",
	5032: "ErrCode_PlanetNotFound",
	5033: "ErrCode_PlanetFailure",
	5034: "ErrCode_AppNotFound",
	5036: "ErrCode_DefNotFound",
	5040: "ErrCode_MalformedTx",
	5050: "ErrCode_TypeNotFound",
	5051: "ErrCode_TypeNotRegistered",
	5052: "ErrCode_BadSchema",
	5053: "ErrCode_DataFailure",
	5054: "ErrCode_ExportErr",
	5055: "ErrCode_PinFailed",
	5056: "ErrCode_PinContextClosed",
	5058: "ErrCode_CellNotFound",
	5059: "ErrCode_ProviderErr",
	5100: "ErrCode_ViolatesAppendOnly",
	5101: "ErrCode_InsufficientPermissions",
}

var ErrCode_value = map[string]int32{
	"ErrCode_NoErr":                   0,
	"ErrCode_UnnamedErr":              5000,
	"ErrCode_InternalErr":             5001,
	"ErrCode_UnsupportedOp":           5002,
	"ErrCode_Unimplemented":           5003,
	"ErrCode_Timeout":                 5004,
	"ErrCode_ShuttingDown":            5005,
	"ErrCode_NotConnected":            5006,
	"ErrCode_AuthFailed":              5007,
	"ErrCode_LoginFailed":             5008,
	"ErrCode_SessionExpired":          5009,
	"ErrCode_ReqNotFound":             5010,
	"ErrCode_InvalidReq":              5020,
	"ErrCode_InvalidURI":              5021,
	"ErrCode_BadValue":                5022,
	"ErrCode_NothingToCommit":         5030,
	"ErrCode_CommitFailed":            5031,
	"ErrCode_PlanetNotFound":          5032,
	"ErrCode_PlanetFailure":           5033,
	"ErrCode_AppNotFound":             5034,
	"ErrCode_DefNotFound":             5036,
	"ErrCode_MalformedTx":             5040,
	"ErrCode_TypeNotFound":            5050,
	"ErrCode_TypeNotRegistered":       5051,
	"ErrCode_BadSchema":               5052,
	"ErrCode_DataFailure":             5053,
	"ErrCode_ExportErr":               5054,
	"ErrCode_PinFailed":               5055,
	"ErrCode_PinContextClosed":        5056,
	"ErrCode_CellNotFound":            5058,
	"ErrCode_ProviderErr":             5059,
	"ErrCode_ViolatesAppendOnly":      5100,
	"ErrCode_InsufficientPermissions": 5101,
}

func (ErrCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{11}
}

type LogLevel int32

const (
	LogLevel_Error LogLevel = 0
	LogLevel_Warn  LogLevel = 2
	LogLevel_Info  LogLevel = 4
)

var LogLevel_name = map[int32]string{
	0: "LogLevel_Error",
	2: "LogLevel_Warn",
	4: "LogLevel_Info",
}

var LogLevel_value = map[string]int32{
	"LogLevel_Error": 0,
	"LogLevel_Warn":  2,
	"LogLevel_Info":  4,
}

func (LogLevel) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{12}
}

type TRS_VisualScaleMode int32

const (
	AutoScale  TRS_VisualScaleMode = 0
	FixedScale TRS_VisualScaleMode = 1
)

var TRS_VisualScaleMode_name = map[int32]string{
	0: "AutoScale",
	1: "FixedScale",
}

var TRS_VisualScaleMode_value = map[string]int32{
	"AutoScale":  0,
	"FixedScale": 1,
}

func (TRS_VisualScaleMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{19, 0}
}

// Msg is thw workhorse generic transport serialization sent between client and host.
type Msg struct {
	// ReqID names an originating request ID, issued by client using an atomic counter.
	//
	// For example, if a Msg is a reply to some request, ReqID identifies the originating request\.
	ReqID uint64 `protobuf:"varint,1,opt,name=ReqID,proto3" json:"ReqID,omitempty"`
	// Status communicates request status / completion.
	Status ReqStatus `protobuf:"varint,2,opt,name=Status,proto3,enum=amp.ReqStatus" json:"Status,omitempty"`
	// CellTxs is a Cell state update as well as session meta-messaging mechanism.
	CellTxs []*CellTxPb `protobuf:"bytes,5,rep,name=CellTxs,proto3" json:"CellTxs,omitempty"`
}

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

var xxx_messageInfo_Msg proto.InternalMessageInfo

func (m *Msg) GetReqID() uint64 {
	if m != nil {
		return m.ReqID
	}
	return 0
}

func (m *Msg) GetStatus() ReqStatus {
	if m != nil {
		return m.Status
	}
	return ReqStatus_NotStarted
}

func (m *Msg) GetCellTxs() []*CellTxPb {
	if m != nil {
		return m.CellTxs
	}
	return nil
}

// CellTxPb is a cell transaction, a unit of change (or meta message) for a cell.
type CellTxPb struct {
	Op CellTxOp `protobuf:"varint,1,opt,name=Op,proto3,enum=amp.CellTxOp" json:"Op,omitempty"`
	// Target CellID
	// If CellID_1 == 0, then this cell is ephemeral (vs persistent).
	CellID_0 uint64        `protobuf:"fixed64,3,opt,name=CellID_0,json=CellID0,proto3" json:"CellID_0,omitempty"`
	CellID_1 uint64        `protobuf:"fixed64,4,opt,name=CellID_1,json=CellID1,proto3" json:"CellID_1,omitempty"`
	Elems    []*AttrElemPb `protobuf:"bytes,8,rep,name=Elems,proto3" json:"Elems,omitempty"`
}

func (m *CellTxPb) Reset()      { *m = CellTxPb{} }
func (*CellTxPb) ProtoMessage() {}
func (*CellTxPb) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{1}
}
func (m *CellTxPb) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CellTxPb) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CellTxPb.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CellTxPb) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CellTxPb.Merge(m, src)
}
func (m *CellTxPb) XXX_Size() int {
	return m.Size()
}
func (m *CellTxPb) XXX_DiscardUnknown() {
	xxx_messageInfo_CellTxPb.DiscardUnknown(m)
}

var xxx_messageInfo_CellTxPb proto.InternalMessageInfo

func (m *CellTxPb) GetOp() CellTxOp {
	if m != nil {
		return m.Op
	}
	return CellTxOp_MetaAttr
}

func (m *CellTxPb) GetCellID_0() uint64 {
	if m != nil {
		return m.CellID_0
	}
	return 0
}

func (m *CellTxPb) GetCellID_1() uint64 {
	if m != nil {
		return m.CellID_1
	}
	return 0
}

func (m *CellTxPb) GetElems() []*AttrElemPb {
	if m != nil {
		return m.Elems
	}
	return nil
}

// Serialization helper for AttrElem
type AttrElemPb struct {
	// AttrID of the attr being updated (64 bits for future proofing)
	AttrID uint64 `protobuf:"varint,1,opt,name=AttrID,proto3" json:"AttrID,omitempty"`
	// Serialized value of the attr element -- IAW AttrID
	ValBuf []byte `protobuf:"bytes,2,opt,name=ValBuf,proto3" json:"ValBuf,omitempty"`
	// Series index (if applicable)
	SI int64 `protobuf:"varint,3,opt,name=SI,proto3" json:"SI,omitempty"`
}

func (m *AttrElemPb) Reset()      { *m = AttrElemPb{} }
func (*AttrElemPb) ProtoMessage() {}
func (*AttrElemPb) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{2}
}
func (m *AttrElemPb) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AttrElemPb) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AttrElemPb.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AttrElemPb) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AttrElemPb.Merge(m, src)
}
func (m *AttrElemPb) XXX_Size() int {
	return m.Size()
}
func (m *AttrElemPb) XXX_DiscardUnknown() {
	xxx_messageInfo_AttrElemPb.DiscardUnknown(m)
}

var xxx_messageInfo_AttrElemPb proto.InternalMessageInfo

func (m *AttrElemPb) GetAttrID() uint64 {
	if m != nil {
		return m.AttrID
	}
	return 0
}

func (m *AttrElemPb) GetValBuf() []byte {
	if m != nil {
		return m.ValBuf
	}
	return nil
}

func (m *AttrElemPb) GetSI() int64 {
	if m != nil {
		return m.SI
	}
	return 0
}

type Login struct {
	// A byte string identifying user who is logging in (lot limited to UTF8)
	// This is typically a username or a persistent UID issued by the device OS when the app is (re)installed.
	UserUID string `protobuf:"bytes,1,opt,name=UserUID,proto3" json:"UserUID,omitempty"`
	// HostAddr is network address of the server known to the client (e.g. IP address, localhost, domain name, etc)
	// archost uses this to as the host name when serving URLs for the client to consume.
	HostAddr    string `protobuf:"bytes,2,opt,name=HostAddr,proto3" json:"HostAddr,omitempty"`
	DeviceLabel string `protobuf:"bytes,8,opt,name=DeviceLabel,proto3" json:"DeviceLabel,omitempty"`
	DeviceUID   string `protobuf:"bytes,9,opt,name=DeviceUID,proto3" json:"DeviceUID,omitempty"`
}

func (m *Login) Reset()      { *m = Login{} }
func (*Login) ProtoMessage() {}
func (*Login) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{3}
}
func (m *Login) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Login) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Login.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Login) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Login.Merge(m, src)
}
func (m *Login) XXX_Size() int {
	return m.Size()
}
func (m *Login) XXX_DiscardUnknown() {
	xxx_messageInfo_Login.DiscardUnknown(m)
}

var xxx_messageInfo_Login proto.InternalMessageInfo

func (m *Login) GetUserUID() string {
	if m != nil {
		return m.UserUID
	}
	return ""
}

func (m *Login) GetHostAddr() string {
	if m != nil {
		return m.HostAddr
	}
	return ""
}

func (m *Login) GetDeviceLabel() string {
	if m != nil {
		return m.DeviceLabel
	}
	return ""
}

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

// LoginChallenge is sent from host to client in response to a Login message
type LoginChallenge struct {
	Hash []byte `protobuf:"bytes,1,opt,name=Hash,proto3" json:"Hash,omitempty"`
}

func (m *LoginChallenge) Reset()      { *m = LoginChallenge{} }
func (*LoginChallenge) ProtoMessage() {}
func (*LoginChallenge) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{4}
}
func (m *LoginChallenge) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LoginChallenge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LoginChallenge.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LoginChallenge) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoginChallenge.Merge(m, src)
}
func (m *LoginChallenge) XXX_Size() int {
	return m.Size()
}
func (m *LoginChallenge) XXX_DiscardUnknown() {
	xxx_messageInfo_LoginChallenge.DiscardUnknown(m)
}

var xxx_messageInfo_LoginChallenge proto.InternalMessageInfo

func (m *LoginChallenge) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

// LoginChallenge is sent from client to host in response to a LoginChallenge message
type LoginResponse struct {
	HashResp []byte `protobuf:"bytes,1,opt,name=HashResp,proto3" json:"HashResp,omitempty"`
}

func (m *LoginResponse) Reset()      { *m = LoginResponse{} }
func (*LoginResponse) ProtoMessage() {}
func (*LoginResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{5}
}
func (m *LoginResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LoginResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LoginResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LoginResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoginResponse.Merge(m, src)
}
func (m *LoginResponse) XXX_Size() int {
	return m.Size()
}
func (m *LoginResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LoginResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LoginResponse proto.InternalMessageInfo

func (m *LoginResponse) GetHashResp() []byte {
	if m != nil {
		return m.HashResp
	}
	return nil
}

type Symbol struct {
	// A symbol ID is 32 bits and corresponds to a real-world const byte strings.
	// FUTURE: IDs are int64, where client symbols IDs are < 0 and native symbols are > 0.
	ID   uint32 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
	Name []byte `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
}

func (m *Symbol) Reset()      { *m = Symbol{} }
func (*Symbol) ProtoMessage() {}
func (*Symbol) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{6}
}
func (m *Symbol) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Symbol) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Symbol.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Symbol) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Symbol.Merge(m, src)
}
func (m *Symbol) XXX_Size() int {
	return m.Size()
}
func (m *Symbol) XXX_DiscardUnknown() {
	xxx_messageInfo_Symbol.DiscardUnknown(m)
}

var xxx_messageInfo_Symbol proto.InternalMessageInfo

func (m *Symbol) GetID() uint32 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *Symbol) GetName() []byte {
	if m != nil {
		return m.Name
	}
	return nil
}

// RegisterDefs is sent by a client to register its symbols and schemas during a session.
type RegisterDefs struct {
	Symbols   []*Symbol       `protobuf:"bytes,1,rep,name=Symbols,proto3" json:"Symbols,omitempty"`
	Attrs     []*AttrSpec     `protobuf:"bytes,2,rep,name=Attrs,proto3" json:"Attrs,omitempty"`
	Selectors []*ItemSelector `protobuf:"bytes,4,rep,name=Selectors,proto3" json:"Selectors,omitempty"`
}

func (m *RegisterDefs) Reset()      { *m = RegisterDefs{} }
func (*RegisterDefs) ProtoMessage() {}
func (*RegisterDefs) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{7}
}
func (m *RegisterDefs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterDefs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterDefs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterDefs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterDefs.Merge(m, src)
}
func (m *RegisterDefs) XXX_Size() int {
	return m.Size()
}
func (m *RegisterDefs) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterDefs.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterDefs proto.InternalMessageInfo

func (m *RegisterDefs) GetSymbols() []*Symbol {
	if m != nil {
		return m.Symbols
	}
	return nil
}

func (m *RegisterDefs) GetAttrs() []*AttrSpec {
	if m != nil {
		return m.Attrs
	}
	return nil
}

func (m *RegisterDefs) GetSelectors() []*ItemSelector {
	if m != nil {
		return m.Selectors
	}
	return nil
}

// AttrSpec fully describes a cell attribute, specifying a name, element type, and series element type.
type AttrSpec struct {
	// Composite expression / invocation of this AttrSpec in the form:
	//      "[{SeriesSpec}]{ElemType}:{AttrName}"
	//
	// This the value is used for Msg.AttrID -- it references an AttrSpec.
	// e.g. "AssetTag", "AssetTag:promo", "[UTC16]Position:past-promo-shoots",
	DefID uint32 `protobuf:"varint,1,opt,name=DefID,proto3" json:"DefID,omitempty"`
	// ElemType identifies this attr's element type and has a form like a subdomain:
	//    "({subTypeName}.)*<typeName>"
	//
	// A particular ElemType corresponds to a serializable data type (typically a protobuf or capnp message)
	// Valid chars are [A-Za-z0-9_-] in addition to '.' that separates identifiers..
	//
	// e.g.
	//    "AssetTag",
	//    "GreetingAttr.tutorial_06.hello-world.learn.arcspace.systems",
	ElemType uint32 `protobuf:"varint,3,opt,name=ElemType,proto3" json:"ElemType,omitempty"`
	// SeriesSpec specifies how to interpret an attr's SeriesIndex int64 value ("SI") and has the form:
	//    "{SeriesName}[.{SeriesIndexType}]"
	//
	// A SeriesSpec includes its underlying SeriesType as a suffix, telling the host to perform necessary handling.
	// If SeriesSpec is omitted, this attr is a scalar value (and SI is 0 assumed).
	//
	// UTC16 and Secs16 are 48.16 fixed signed fractional seconds (one second == 0x10000 ticks), naming a time duration or timestamp.
	// When naming an absolute timestamp, unix UTC is assumed (0x10000 corresponds to 00:00:01, Jan 1 1970 GMT)
	//
	// e.g. "", "UTC16", "Secs16", "Int64", "Locale.Name" -- FUTURE "GeoHash", "NodeID", "TID"
	SeriesSpec uint32 `protobuf:"varint,4,opt,name=SeriesSpec,proto3" json:"SeriesSpec,omitempty"`
	// SeriesIndexType tells the host how to handle and process attr series index values.
	// If SeriesSpec is omitted (SeriesSpec = 0), SI index values are considered literals (SeriesIndexType_Literal).
	SeriesIndexType SeriesIndexType `protobuf:"varint,5,opt,name=SeriesIndexType,proto3,enum=amp.SeriesIndexType" json:"SeriesIndexType,omitempty"`
	// AttrName differentiates an attribute from others having the same ElemType and SeriesSpec
	//   - Unnamed attrs are common and typically are used to denote a characterizing cell attribute.
	//   - By convention, attr names of series are plural, and reflects that the attr is intended to contain multiple entries (e.g. "[Locale.Name]Labels")
	//   - Valid chars consist of [A-Za-z0-9_-] ('.' is not allowed)
	//
	// e.g. "", "playable", "mini", "1440p"
	AttrName uint32 `protobuf:"varint,6,opt,name=AttrName,proto3" json:"AttrName,omitempty"`
}

func (m *AttrSpec) Reset()      { *m = AttrSpec{} }
func (*AttrSpec) ProtoMessage() {}
func (*AttrSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{8}
}
func (m *AttrSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AttrSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AttrSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AttrSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AttrSpec.Merge(m, src)
}
func (m *AttrSpec) XXX_Size() int {
	return m.Size()
}
func (m *AttrSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_AttrSpec.DiscardUnknown(m)
}

var xxx_messageInfo_AttrSpec proto.InternalMessageInfo

func (m *AttrSpec) GetDefID() uint32 {
	if m != nil {
		return m.DefID
	}
	return 0
}

func (m *AttrSpec) GetElemType() uint32 {
	if m != nil {
		return m.ElemType
	}
	return 0
}

func (m *AttrSpec) GetSeriesSpec() uint32 {
	if m != nil {
		return m.SeriesSpec
	}
	return 0
}

func (m *AttrSpec) GetSeriesIndexType() SeriesIndexType {
	if m != nil {
		return m.SeriesIndexType
	}
	return SeriesIndexType_Literal
}

func (m *AttrSpec) GetAttrName() uint32 {
	if m != nil {
		return m.AttrName
	}
	return 0
}

// ItemSelector selects / filters a srt of items (AttrSpec descriptors)
type ItemSelector struct {
	// Composite expression of this ItemSelector in the form:
	//      "(Include[0],Include[1],..)~(Exclude[0],Exclude[1],..)"
	//
	DefID uint32 `protobuf:"varint,1,opt,name=DefID,proto3" json:"DefID,omitempty"`
	// A set of descriptor IDs explicitly included
	Include []uint32 `protobuf:"varint,4,rep,packed,name=Include,proto3" json:"Include,omitempty"`
	// A set of descriptor IDs explicitly excluded
	Exclude []uint32 `protobuf:"varint,5,rep,packed,name=Exclude,proto3" json:"Exclude,omitempty"`
}

func (m *ItemSelector) Reset()      { *m = ItemSelector{} }
func (*ItemSelector) ProtoMessage() {}
func (*ItemSelector) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{9}
}
func (m *ItemSelector) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ItemSelector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ItemSelector.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ItemSelector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ItemSelector.Merge(m, src)
}
func (m *ItemSelector) XXX_Size() int {
	return m.Size()
}
func (m *ItemSelector) XXX_DiscardUnknown() {
	xxx_messageInfo_ItemSelector.DiscardUnknown(m)
}

var xxx_messageInfo_ItemSelector proto.InternalMessageInfo

func (m *ItemSelector) GetDefID() uint32 {
	if m != nil {
		return m.DefID
	}
	return 0
}

func (m *ItemSelector) GetInclude() []uint32 {
	if m != nil {
		return m.Include
	}
	return nil
}

func (m *ItemSelector) GetExclude() []uint32 {
	if m != nil {
		return m.Exclude
	}
	return nil
}

// HandleURI is used as a meta attribute to request a URI is handled, such as an oauth request (host to client) or an oauth response (client to host).
type HandleURI struct {
	URI string `protobuf:"bytes,1,opt,name=URI,proto3" json:"URI,omitempty"`
}

func (m *HandleURI) Reset()      { *m = HandleURI{} }
func (*HandleURI) ProtoMessage() {}
func (*HandleURI) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{10}
}
func (m *HandleURI) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HandleURI) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HandleURI.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HandleURI) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HandleURI.Merge(m, src)
}
func (m *HandleURI) XXX_Size() int {
	return m.Size()
}
func (m *HandleURI) XXX_DiscardUnknown() {
	xxx_messageInfo_HandleURI.DiscardUnknown(m)
}

var xxx_messageInfo_HandleURI proto.InternalMessageInfo

func (m *HandleURI) GetURI() string {
	if m != nil {
		return m.URI
	}
	return ""
}

// PinRequest is a client request to "pin" a cell, meaning selected attrs and child cells will be pushed to the client.
type PinRequest struct {
	// ParentReqID, if set, provides context for this request and is typically needed when pinning a cell by ID alone.
	// Not set if PinURL and/or PinCellID implies that no parent req exists.
	ParentReqID uint64 `protobuf:"varint,1,opt,name=ParentReqID,proto3" json:"ParentReqID,omitempty"`
	// URL specifying the cell to be pinned and whose child cells are to be pushed.
	// Typically: [[amp://]amp-app-uri/]cell-uri..
	PinURL string `protobuf:"bytes,2,opt,name=PinURL,proto3" json:"PinURL,omitempty"`
	// Pins a cell specified by its 16 byte ID and is typically a child cell of a pinned cell implied by ParentReqID.
	// These values are 0 if PinURL is nil or does not require a CellID.
	PinCellIDx0 uint64 `protobuf:"varint,3,opt,name=PinCellIDx0,proto3" json:"PinCellIDx0,omitempty"`
	PinCellIDx1 uint64 `protobuf:"varint,4,opt,name=PinCellIDx1,proto3" json:"PinCellIDx1,omitempty"`
	// If set, specifies an ItemSelector that filters which attrs of the pinned cell are pushed to the client.
	ParentAttrSelector uint32 `protobuf:"varint,5,opt,name=ParentAttrSelector,proto3" json:"ParentAttrSelector,omitempty"`
	// If set, specifies an ItemSelector that filters which child cells are pushed to the client.
	ChildCellSelector uint32 `protobuf:"varint,6,opt,name=ChildCellSelector,proto3" json:"ChildCellSelector,omitempty"`
	// Flags specifies options.
	Flags PinFlags `protobuf:"varint,7,opt,name=Flags,proto3,enum=amp.PinFlags" json:"Flags,omitempty"`
}

func (m *PinRequest) Reset()      { *m = PinRequest{} }
func (*PinRequest) ProtoMessage() {}
func (*PinRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{11}
}
func (m *PinRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PinRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PinRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PinRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PinRequest.Merge(m, src)
}
func (m *PinRequest) XXX_Size() int {
	return m.Size()
}
func (m *PinRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PinRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PinRequest proto.InternalMessageInfo

func (m *PinRequest) GetParentReqID() uint64 {
	if m != nil {
		return m.ParentReqID
	}
	return 0
}

func (m *PinRequest) GetPinURL() string {
	if m != nil {
		return m.PinURL
	}
	return ""
}

func (m *PinRequest) GetPinCellIDx0() uint64 {
	if m != nil {
		return m.PinCellIDx0
	}
	return 0
}

func (m *PinRequest) GetPinCellIDx1() uint64 {
	if m != nil {
		return m.PinCellIDx1
	}
	return 0
}

func (m *PinRequest) GetParentAttrSelector() uint32 {
	if m != nil {
		return m.ParentAttrSelector
	}
	return 0
}

func (m *PinRequest) GetChildCellSelector() uint32 {
	if m != nil {
		return m.ChildCellSelector
	}
	return 0
}

func (m *PinRequest) GetFlags() PinFlags {
	if m != nil {
		return m.Flags
	}
	return PinFlags_None
}

// Position describes a position in space and/or time using a given coordinate system.
type Position struct {
	CordType CordType `protobuf:"varint,1,opt,name=CordType,proto3,enum=amp.CordType" json:"CordType,omitempty"`
	U        float64  `protobuf:"fixed64,3,opt,name=U,proto3" json:"U,omitempty"`
	V        float64  `protobuf:"fixed64,4,opt,name=V,proto3" json:"V,omitempty"`
	W        float64  `protobuf:"fixed64,5,opt,name=W,proto3" json:"W,omitempty"`
	ROU      float32  `protobuf:"fixed32,6,opt,name=ROU,proto3" json:"ROU,omitempty"`
}

func (m *Position) Reset()      { *m = Position{} }
func (*Position) ProtoMessage() {}
func (*Position) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{12}
}
func (m *Position) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Position.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Position) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Position.Merge(m, src)
}
func (m *Position) XXX_Size() int {
	return m.Size()
}
func (m *Position) XXX_DiscardUnknown() {
	xxx_messageInfo_Position.DiscardUnknown(m)
}

var xxx_messageInfo_Position proto.InternalMessageInfo

func (m *Position) GetCordType() CordType {
	if m != nil {
		return m.CordType
	}
	return CordType_Unspecified
}

func (m *Position) GetU() float64 {
	if m != nil {
		return m.U
	}
	return 0
}

func (m *Position) GetV() float64 {
	if m != nil {
		return m.V
	}
	return 0
}

func (m *Position) GetW() float64 {
	if m != nil {
		return m.W
	}
	return 0
}

func (m *Position) GetROU() float32 {
	if m != nil {
		return m.ROU
	}
	return 0
}

type AssetTag struct {
	State       QuadState   `protobuf:"varint,3,opt,name=State,proto3,enum=amp.QuadState" json:"State,omitempty"`
	ContentType string      `protobuf:"bytes,5,opt,name=ContentType,proto3" json:"ContentType,omitempty"`
	URI         string      `protobuf:"bytes,7,opt,name=URI,proto3" json:"URI,omitempty"`
	UIDx0       uint64      `protobuf:"fixed64,16,opt,name=UIDx0,proto3" json:"UIDx0,omitempty"`
	UIDx1       uint64      `protobuf:"fixed64,17,opt,name=UIDx1,proto3" json:"UIDx1,omitempty"`
	UIDx2       uint64      `protobuf:"fixed64,18,opt,name=UIDx2,proto3" json:"UIDx2,omitempty"`
	Rx0         float32     `protobuf:"fixed32,20,opt,name=Rx0,proto3" json:"Rx0,omitempty"`
	Rx1         float32     `protobuf:"fixed32,21,opt,name=Rx1,proto3" json:"Rx1,omitempty"`
	Rx2         float32     `protobuf:"fixed32,22,opt,name=Rx2,proto3" json:"Rx2,omitempty"`
	PixelWidth  int32       `protobuf:"varint,28,opt,name=PixelWidth,proto3" json:"PixelWidth,omitempty"`
	PixelHeight int32       `protobuf:"varint,29,opt,name=PixelHeight,proto3" json:"PixelHeight,omitempty"`
	MeterScale  float32     `protobuf:"fixed32,30,opt,name=MeterScale,proto3" json:"MeterScale,omitempty"`
	SubTags     []*AssetTag `protobuf:"bytes,2,rep,name=SubTags,proto3" json:"SubTags,omitempty"`
}

func (m *AssetTag) Reset()      { *m = AssetTag{} }
func (*AssetTag) ProtoMessage() {}
func (*AssetTag) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{13}
}
func (m *AssetTag) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AssetTag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AssetTag.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AssetTag) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AssetTag.Merge(m, src)
}
func (m *AssetTag) XXX_Size() int {
	return m.Size()
}
func (m *AssetTag) XXX_DiscardUnknown() {
	xxx_messageInfo_AssetTag.DiscardUnknown(m)
}

var xxx_messageInfo_AssetTag proto.InternalMessageInfo

func (m *AssetTag) GetState() QuadState {
	if m != nil {
		return m.State
	}
	return QuadState_LatentOff
}

func (m *AssetTag) GetContentType() string {
	if m != nil {
		return m.ContentType
	}
	return ""
}

func (m *AssetTag) GetURI() string {
	if m != nil {
		return m.URI
	}
	return ""
}

func (m *AssetTag) GetUIDx0() uint64 {
	if m != nil {
		return m.UIDx0
	}
	return 0
}

func (m *AssetTag) GetUIDx1() uint64 {
	if m != nil {
		return m.UIDx1
	}
	return 0
}

func (m *AssetTag) GetUIDx2() uint64 {
	if m != nil {
		return m.UIDx2
	}
	return 0
}

func (m *AssetTag) GetRx0() float32 {
	if m != nil {
		return m.Rx0
	}
	return 0
}

func (m *AssetTag) GetRx1() float32 {
	if m != nil {
		return m.Rx1
	}
	return 0
}

func (m *AssetTag) GetRx2() float32 {
	if m != nil {
		return m.Rx2
	}
	return 0
}

func (m *AssetTag) GetPixelWidth() int32 {
	if m != nil {
		return m.PixelWidth
	}
	return 0
}

func (m *AssetTag) GetPixelHeight() int32 {
	if m != nil {
		return m.PixelHeight
	}
	return 0
}

func (m *AssetTag) GetMeterScale() float32 {
	if m != nil {
		return m.MeterScale
	}
	return 0
}

func (m *AssetTag) GetSubTags() []*AssetTag {
	if m != nil {
		return m.SubTags
	}
	return nil
}

type SheetInfo struct {
	// Sheet.Series.AVPlaylist
	// Sheet.Series.AttrTuple           -- expects series with ElemType: .AttrSet
	// Sheet.Series.Spreadsheet         -- expects series with Addr.desc: .xy, ElemType.  ??
	// Sheet.Series.Surface.Geo         -- expects series with Addr.desc: .wsg84
	// Sheet.Series.Surface.Grid.Ortho  -- expects series with Addr.desc: .xy
	// Sheet.Series.Surface.Grid.Hex    -- expects series with Addr.desc: .qr
	// Sheet.WebBrowser                 -- expects series whose elements are URLs
	AppSheetURI string `protobuf:"bytes,1,opt,name=AppSheetURI,proto3" json:"AppSheetURI,omitempty"`
	// Bound attr series (e.g. a spreadsheet's columns)
	BoundSeries []*AttrSpec `protobuf:"bytes,3,rep,name=BoundSeries,proto3" json:"BoundSeries,omitempty"`
}

func (m *SheetInfo) Reset()      { *m = SheetInfo{} }
func (*SheetInfo) ProtoMessage() {}
func (*SheetInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{14}
}
func (m *SheetInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SheetInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SheetInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SheetInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SheetInfo.Merge(m, src)
}
func (m *SheetInfo) XXX_Size() int {
	return m.Size()
}
func (m *SheetInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_SheetInfo.DiscardUnknown(m)
}

var xxx_messageInfo_SheetInfo proto.InternalMessageInfo

func (m *SheetInfo) GetAppSheetURI() string {
	if m != nil {
		return m.AppSheetURI
	}
	return ""
}

func (m *SheetInfo) GetBoundSeries() []*AttrSpec {
	if m != nil {
		return m.BoundSeries
	}
	return nil
}

type SheetGroup struct {
	SheetCatalog []*SheetInfo `protobuf:"bytes,1,rep,name=SheetCatalog,proto3" json:"SheetCatalog,omitempty"`
}

func (m *SheetGroup) Reset()      { *m = SheetGroup{} }
func (*SheetGroup) ProtoMessage() {}
func (*SheetGroup) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{15}
}
func (m *SheetGroup) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SheetGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SheetGroup.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SheetGroup) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SheetGroup.Merge(m, src)
}
func (m *SheetGroup) XXX_Size() int {
	return m.Size()
}
func (m *SheetGroup) XXX_DiscardUnknown() {
	xxx_messageInfo_SheetGroup.DiscardUnknown(m)
}

var xxx_messageInfo_SheetGroup proto.InternalMessageInfo

func (m *SheetGroup) GetSheetCatalog() []*SheetInfo {
	if m != nil {
		return m.SheetCatalog
	}
	return nil
}

type CryptoKey struct {
	CryptoKitID CryptoKitID `protobuf:"varint,1,opt,name=CryptoKitID,proto3,enum=amp.CryptoKitID" json:"CryptoKitID,omitempty"`
	KeyBytes    []byte      `protobuf:"bytes,4,opt,name=KeyBytes,proto3" json:"KeyBytes,omitempty"`
}

func (m *CryptoKey) Reset()      { *m = CryptoKey{} }
func (*CryptoKey) ProtoMessage() {}
func (*CryptoKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{16}
}
func (m *CryptoKey) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CryptoKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CryptoKey.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CryptoKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CryptoKey.Merge(m, src)
}
func (m *CryptoKey) XXX_Size() int {
	return m.Size()
}
func (m *CryptoKey) XXX_DiscardUnknown() {
	xxx_messageInfo_CryptoKey.DiscardUnknown(m)
}

var xxx_messageInfo_CryptoKey proto.InternalMessageInfo

func (m *CryptoKey) GetCryptoKitID() CryptoKitID {
	if m != nil {
		return m.CryptoKitID
	}
	return CryptoKit_Nil
}

func (m *CryptoKey) GetKeyBytes() []byte {
	if m != nil {
		return m.KeyBytes
	}
	return nil
}

// CellHeader is a standard attribute for a cell that is presented .
// An amp.App fills in what is appropriate and leaves the rest blank.
type CellHeader struct {
	Title    string `protobuf:"bytes,2,opt,name=Title,proto3" json:"Title,omitempty"`
	Subtitle string `protobuf:"bytes,3,opt,name=Subtitle,proto3" json:"Subtitle,omitempty"`
	About    string `protobuf:"bytes,4,opt,name=About,proto3" json:"About,omitempty"`
	// A Glyph is a representative image or 3D graphic similar to an icon in function.
	Glyphs   []*AssetTag `protobuf:"bytes,6,rep,name=Glyphs,proto3" json:"Glyphs,omitempty"`
	Created  int64       `protobuf:"varint,8,opt,name=Created,proto3" json:"Created,omitempty"`
	Modified int64       `protobuf:"varint,9,opt,name=Modified,proto3" json:"Modified,omitempty"`
	// If set, this (typically https:// or amp://) to reproduce this cell (with given archost session)
	CellURL string `protobuf:"bytes,20,opt,name=CellURL,proto3" json:"CellURL,omitempty"`
	// Extensible and persistent link, can be any URL -- typically passed to another application or shared with a another human.
	// E.g. if 'arc://...', this denotes a pinnable URI -- but could be any pinnable URL: ipfs://, https://, ...
	// But also UI button or settings URI.
	ExternalLink *AssetTag `protobuf:"bytes,22,opt,name=ExternalLink,proto3" json:"ExternalLink,omitempty"`
}

func (m *CellHeader) Reset()      { *m = CellHeader{} }
func (*CellHeader) ProtoMessage() {}
func (*CellHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{17}
}
func (m *CellHeader) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CellHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CellHeader.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CellHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CellHeader.Merge(m, src)
}
func (m *CellHeader) XXX_Size() int {
	return m.Size()
}
func (m *CellHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_CellHeader.DiscardUnknown(m)
}

var xxx_messageInfo_CellHeader proto.InternalMessageInfo

func (m *CellHeader) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *CellHeader) GetSubtitle() string {
	if m != nil {
		return m.Subtitle
	}
	return ""
}

func (m *CellHeader) GetAbout() string {
	if m != nil {
		return m.About
	}
	return ""
}

func (m *CellHeader) GetGlyphs() []*AssetTag {
	if m != nil {
		return m.Glyphs
	}
	return nil
}

func (m *CellHeader) GetCreated() int64 {
	if m != nil {
		return m.Created
	}
	return 0
}

func (m *CellHeader) GetModified() int64 {
	if m != nil {
		return m.Modified
	}
	return 0
}

func (m *CellHeader) GetCellURL() string {
	if m != nil {
		return m.CellURL
	}
	return ""
}

func (m *CellHeader) GetExternalLink() *AssetTag {
	if m != nil {
		return m.ExternalLink
	}
	return nil
}

// AuthToken is an oauth token -- see oauth2.Token
type AuthToken struct {
	AccessToken  string `protobuf:"bytes,1,opt,name=AccessToken,proto3" json:"AccessToken,omitempty"`
	TokenType    string `protobuf:"bytes,2,opt,name=TokenType,proto3" json:"TokenType,omitempty"`
	RefreshToken string `protobuf:"bytes,3,opt,name=RefreshToken,proto3" json:"RefreshToken,omitempty"`
	Expiry       int64  `protobuf:"varint,4,opt,name=Expiry,proto3" json:"Expiry,omitempty"`
}

func (m *AuthToken) Reset()      { *m = AuthToken{} }
func (*AuthToken) ProtoMessage() {}
func (*AuthToken) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{18}
}
func (m *AuthToken) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AuthToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AuthToken.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AuthToken) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AuthToken.Merge(m, src)
}
func (m *AuthToken) XXX_Size() int {
	return m.Size()
}
func (m *AuthToken) XXX_DiscardUnknown() {
	xxx_messageInfo_AuthToken.DiscardUnknown(m)
}

var xxx_messageInfo_AuthToken proto.InternalMessageInfo

func (m *AuthToken) GetAccessToken() string {
	if m != nil {
		return m.AccessToken
	}
	return ""
}

func (m *AuthToken) GetTokenType() string {
	if m != nil {
		return m.TokenType
	}
	return ""
}

func (m *AuthToken) GetRefreshToken() string {
	if m != nil {
		return m.RefreshToken
	}
	return ""
}

func (m *AuthToken) GetExpiry() int64 {
	if m != nil {
		return m.Expiry
	}
	return 0
}

type TRS struct {
	// X1, X2, and X3 are coordinates or values expressed in any unit.
	// A channel client can later declare how to interpret these coordinates so that a channel server and provide indexed services.
	// Shoutout to the 3 domains that reflect all theoretical completeness: alpha (finite), omega (unending), and the inaccessible cardinal(s).
	// Special thanks to Michael at Vsauce: https://www.youtube.com/watch?v=SrU9YDoXE88
	X1 float64 `protobuf:"fixed64,41,opt,name=X1,proto3" json:"X1,omitempty"`
	X2 float64 `protobuf:"fixed64,42,opt,name=X2,proto3" json:"X2,omitempty"`
	X3 float64 `protobuf:"fixed64,43,opt,name=X3,proto3" json:"X3,omitempty"`
	// Specifies how scale dynamically changes based on observer position.
	ScaleMode TRS_VisualScaleMode `protobuf:"varint,50,opt,name=ScaleMode,proto3,enum=amp.TRS_VisualScaleMode" json:"ScaleMode,omitempty"`
	// Scale1..3 express the scale of this placement.
	// If all three values are 0, they are all implicitly 1.
	// If Scale2 or Scale3 == 0, then it is implicitly Scale1.
	Scale1 float32 `protobuf:"fixed32,51,opt,name=Scale1,proto3" json:"Scale1,omitempty"`
	Scale2 float32 `protobuf:"fixed32,52,opt,name=Scale2,proto3" json:"Scale2,omitempty"`
	Scale3 float32 `protobuf:"fixed32,53,opt,name=Scale3,proto3" json:"Scale3,omitempty"`
	// Rotate1 - Rotate3 the orientation of this placement using Euler angles.
	Rotate1 float32 `protobuf:"fixed32,61,opt,name=Rotate1,proto3" json:"Rotate1,omitempty"`
	Rotate2 float32 `protobuf:"fixed32,62,opt,name=Rotate2,proto3" json:"Rotate2,omitempty"`
	Rotate3 float32 `protobuf:"fixed32,63,opt,name=Rotate3,proto3" json:"Rotate3,omitempty"`
}

func (m *TRS) Reset()      { *m = TRS{} }
func (*TRS) ProtoMessage() {}
func (*TRS) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{19}
}
func (m *TRS) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TRS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TRS.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TRS) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TRS.Merge(m, src)
}
func (m *TRS) XXX_Size() int {
	return m.Size()
}
func (m *TRS) XXX_DiscardUnknown() {
	xxx_messageInfo_TRS.DiscardUnknown(m)
}

var xxx_messageInfo_TRS proto.InternalMessageInfo

func (m *TRS) GetX1() float64 {
	if m != nil {
		return m.X1
	}
	return 0
}

func (m *TRS) GetX2() float64 {
	if m != nil {
		return m.X2
	}
	return 0
}

func (m *TRS) GetX3() float64 {
	if m != nil {
		return m.X3
	}
	return 0
}

func (m *TRS) GetScaleMode() TRS_VisualScaleMode {
	if m != nil {
		return m.ScaleMode
	}
	return AutoScale
}

func (m *TRS) GetScale1() float32 {
	if m != nil {
		return m.Scale1
	}
	return 0
}

func (m *TRS) GetScale2() float32 {
	if m != nil {
		return m.Scale2
	}
	return 0
}

func (m *TRS) GetScale3() float32 {
	if m != nil {
		return m.Scale3
	}
	return 0
}

func (m *TRS) GetRotate1() float32 {
	if m != nil {
		return m.Rotate1
	}
	return 0
}

func (m *TRS) GetRotate2() float32 {
	if m != nil {
		return m.Rotate2
	}
	return 0
}

func (m *TRS) GetRotate3() float32 {
	if m != nil {
		return m.Rotate3
	}
	return 0
}

type FeedParams struct {
	UpdateIntervalMin float32 `protobuf:"fixed32,2,opt,name=UpdateIntervalMin,proto3" json:"UpdateIntervalMin,omitempty"`
	UpdateIntervalMax float32 `protobuf:"fixed32,3,opt,name=UpdateIntervalMax,proto3" json:"UpdateIntervalMax,omitempty"`
}

func (m *FeedParams) Reset()      { *m = FeedParams{} }
func (*FeedParams) ProtoMessage() {}
func (*FeedParams) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{20}
}
func (m *FeedParams) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FeedParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FeedParams.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FeedParams) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FeedParams.Merge(m, src)
}
func (m *FeedParams) XXX_Size() int {
	return m.Size()
}
func (m *FeedParams) XXX_DiscardUnknown() {
	xxx_messageInfo_FeedParams.DiscardUnknown(m)
}

var xxx_messageInfo_FeedParams proto.InternalMessageInfo

func (m *FeedParams) GetUpdateIntervalMin() float32 {
	if m != nil {
		return m.UpdateIntervalMin
	}
	return 0
}

func (m *FeedParams) GetUpdateIntervalMax() float32 {
	if m != nil {
		return m.UpdateIntervalMax
	}
	return 0
}

type DataSegment struct {
	ByteOfs    uint64 `protobuf:"varint,5,opt,name=ByteOfs,proto3" json:"ByteOfs,omitempty"`
	ByteSz     uint64 `protobuf:"varint,6,opt,name=ByteSz,proto3" json:"ByteSz,omitempty"`
	InlineData []byte `protobuf:"bytes,7,opt,name=InlineData,proto3" json:"InlineData,omitempty"`
	StreamURI  string `protobuf:"bytes,9,opt,name=StreamURI,proto3" json:"StreamURI,omitempty"`
	BlobID     int64  `protobuf:"varint,10,opt,name=BlobID,proto3" json:"BlobID,omitempty"`
}

func (m *DataSegment) Reset()      { *m = DataSegment{} }
func (*DataSegment) ProtoMessage() {}
func (*DataSegment) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{21}
}
func (m *DataSegment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DataSegment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DataSegment.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DataSegment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DataSegment.Merge(m, src)
}
func (m *DataSegment) XXX_Size() int {
	return m.Size()
}
func (m *DataSegment) XXX_DiscardUnknown() {
	xxx_messageInfo_DataSegment.DiscardUnknown(m)
}

var xxx_messageInfo_DataSegment proto.InternalMessageInfo

func (m *DataSegment) GetByteOfs() uint64 {
	if m != nil {
		return m.ByteOfs
	}
	return 0
}

func (m *DataSegment) GetByteSz() uint64 {
	if m != nil {
		return m.ByteSz
	}
	return 0
}

func (m *DataSegment) GetInlineData() []byte {
	if m != nil {
		return m.InlineData
	}
	return nil
}

func (m *DataSegment) GetStreamURI() string {
	if m != nil {
		return m.StreamURI
	}
	return ""
}

func (m *DataSegment) GetBlobID() int64 {
	if m != nil {
		return m.BlobID
	}
	return 0
}

// Err is a general purpose error / warning / log message.
type Err struct {
	// Identifies the type of error.
	Code ErrCode `protobuf:"varint,1,opt,name=Code,proto3,enum=amp.ErrCode" json:"Code,omitempty"`
	// Severity level
	Level LogLevel `protobuf:"varint,2,opt,name=Level,proto3,enum=amp.LogLevel" json:"Level,omitempty"`
	// human-readable info
	Msg string `protobuf:"bytes,4,opt,name=Msg,proto3" json:"Msg,omitempty"`
}

func (m *Err) Reset()      { *m = Err{} }
func (*Err) ProtoMessage() {}
func (*Err) Descriptor() ([]byte, []int) {
	return fileDescriptor_7e479d288f92766f, []int{22}
}
func (m *Err) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Err) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Err.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Err) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Err.Merge(m, src)
}
func (m *Err) XXX_Size() int {
	return m.Size()
}
func (m *Err) XXX_DiscardUnknown() {
	xxx_messageInfo_Err.DiscardUnknown(m)
}

var xxx_messageInfo_Err proto.InternalMessageInfo

func (m *Err) GetCode() ErrCode {
	if m != nil {
		return m.Code
	}
	return ErrCode_NoErr
}

func (m *Err) GetLevel() LogLevel {
	if m != nil {
		return m.Level
	}
	return LogLevel_Error
}

func (m *Err) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func init() {
	proto.RegisterEnum("amp.Const", Const_name, Const_value)
	proto.RegisterEnum("amp.TxHeader", TxHeader_name, TxHeader_value)
	proto.RegisterEnum("amp.ConstSymbol", ConstSymbol_name, ConstSymbol_value)
	proto.RegisterEnum("amp.ReqStatus", ReqStatus_name, ReqStatus_value)
	proto.RegisterEnum("amp.CellTxOp", CellTxOp_name, CellTxOp_value)
	proto.RegisterEnum("amp.SeriesIndexType", SeriesIndexType_name, SeriesIndexType_value)
	proto.RegisterEnum("amp.PinFlags", PinFlags_name, PinFlags_value)
	proto.RegisterEnum("amp.CordType", CordType_name, CordType_value)
	proto.RegisterEnum("amp.QuadState", QuadState_name, QuadState_value)
	proto.RegisterEnum("amp.UrlScheme", UrlScheme_name, UrlScheme_value)
	proto.RegisterEnum("amp.CryptoKitID", CryptoKitID_name, CryptoKitID_value)
	proto.RegisterEnum("amp.ErrCode", ErrCode_name, ErrCode_value)
	proto.RegisterEnum("amp.LogLevel", LogLevel_name, LogLevel_value)
	proto.RegisterEnum("amp.TRS_VisualScaleMode", TRS_VisualScaleMode_name, TRS_VisualScaleMode_value)
	proto.RegisterType((*Msg)(nil), "amp.Msg")
	proto.RegisterType((*CellTxPb)(nil), "amp.CellTxPb")
	proto.RegisterType((*AttrElemPb)(nil), "amp.AttrElemPb")
	proto.RegisterType((*Login)(nil), "amp.Login")
	proto.RegisterType((*LoginChallenge)(nil), "amp.LoginChallenge")
	proto.RegisterType((*LoginResponse)(nil), "amp.LoginResponse")
	proto.RegisterType((*Symbol)(nil), "amp.Symbol")
	proto.RegisterType((*RegisterDefs)(nil), "amp.RegisterDefs")
	proto.RegisterType((*AttrSpec)(nil), "amp.AttrSpec")
	proto.RegisterType((*ItemSelector)(nil), "amp.ItemSelector")
	proto.RegisterType((*HandleURI)(nil), "amp.HandleURI")
	proto.RegisterType((*PinRequest)(nil), "amp.PinRequest")
	proto.RegisterType((*Position)(nil), "amp.Position")
	proto.RegisterType((*AssetTag)(nil), "amp.AssetTag")
	proto.RegisterType((*SheetInfo)(nil), "amp.SheetInfo")
	proto.RegisterType((*SheetGroup)(nil), "amp.SheetGroup")
	proto.RegisterType((*CryptoKey)(nil), "amp.CryptoKey")
	proto.RegisterType((*CellHeader)(nil), "amp.CellHeader")
	proto.RegisterType((*AuthToken)(nil), "amp.AuthToken")
	proto.RegisterType((*TRS)(nil), "amp.TRS")
	proto.RegisterType((*FeedParams)(nil), "amp.FeedParams")
	proto.RegisterType((*DataSegment)(nil), "amp.DataSegment")
	proto.RegisterType((*Err)(nil), "amp.Err")
}

func init() { proto.RegisterFile("amp/amp.proto", fileDescriptor_7e479d288f92766f) }

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

func (x Const) String() string {
	s, ok := Const_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x TxHeader) String() string {
	s, ok := TxHeader_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ConstSymbol) String() string {
	s, ok := ConstSymbol_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ReqStatus) String() string {
	s, ok := ReqStatus_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x CellTxOp) String() string {
	s, ok := CellTxOp_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x SeriesIndexType) String() string {
	s, ok := SeriesIndexType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x PinFlags) String() string {
	s, ok := PinFlags_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x CordType) String() string {
	s, ok := CordType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x QuadState) String() string {
	s, ok := QuadState_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x UrlScheme) String() string {
	s, ok := UrlScheme_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x CryptoKitID) String() string {
	s, ok := CryptoKitID_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ErrCode) String() string {
	s, ok := ErrCode_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x LogLevel) String() string {
	s, ok := LogLevel_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x TRS_VisualScaleMode) String() string {
	s, ok := TRS_VisualScaleMode_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Msg) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Msg)
	if !ok {
		that2, ok := that.(Msg)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ReqID != that1.ReqID {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if len(this.CellTxs) != len(that1.CellTxs) {
		return false
	}
	for i := range this.CellTxs {
		if !this.CellTxs[i].Equal(that1.CellTxs[i]) {
			return false
		}
	}
	return true
}
func (this *CellTxPb) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CellTxPb)
	if !ok {
		that2, ok := that.(CellTxPb)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Op != that1.Op {
		return false
	}
	if this.CellID_0 != that1.CellID_0 {
		return false
	}
	if this.CellID_1 != that1.CellID_1 {
		return false
	}
	if len(this.Elems) != len(that1.Elems) {
		return false
	}
	for i := range this.Elems {
		if !this.Elems[i].Equal(that1.Elems[i]) {
			return false
		}
	}
	return true
}
func (this *AttrElemPb) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AttrElemPb)
	if !ok {
		that2, ok := that.(AttrElemPb)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AttrID != that1.AttrID {
		return false
	}
	if !bytes.Equal(this.ValBuf, that1.ValBuf) {
		return false
	}
	if this.SI != that1.SI {
		return false
	}
	return true
}
func (this *Login) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Login)
	if !ok {
		that2, ok := that.(Login)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UserUID != that1.UserUID {
		return false
	}
	if this.HostAddr != that1.HostAddr {
		return false
	}
	if this.DeviceLabel != that1.DeviceLabel {
		return false
	}
	if this.DeviceUID != that1.DeviceUID {
		return false
	}
	return true
}
func (this *LoginChallenge) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LoginChallenge)
	if !ok {
		that2, ok := that.(LoginChallenge)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Hash, that1.Hash) {
		return false
	}
	return true
}
func (this *LoginResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LoginResponse)
	if !ok {
		that2, ok := that.(LoginResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.HashResp, that1.HashResp) {
		return false
	}
	return true
}
func (this *Symbol) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Symbol)
	if !ok {
		that2, ok := that.(Symbol)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !bytes.Equal(this.Name, that1.Name) {
		return false
	}
	return true
}
func (this *RegisterDefs) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterDefs)
	if !ok {
		that2, ok := that.(RegisterDefs)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Symbols) != len(that1.Symbols) {
		return false
	}
	for i := range this.Symbols {
		if !this.Symbols[i].Equal(that1.Symbols[i]) {
			return false
		}
	}
	if len(this.Attrs) != len(that1.Attrs) {
		return false
	}
	for i := range this.Attrs {
		if !this.Attrs[i].Equal(that1.Attrs[i]) {
			return false
		}
	}
	if len(this.Selectors) != len(that1.Selectors) {
		return false
	}
	for i := range this.Selectors {
		if !this.Selectors[i].Equal(that1.Selectors[i]) {
			return false
		}
	}
	return true
}
func (this *AttrSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AttrSpec)
	if !ok {
		that2, ok := that.(AttrSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DefID != that1.DefID {
		return false
	}
	if this.ElemType != that1.ElemType {
		return false
	}
	if this.SeriesSpec != that1.SeriesSpec {
		return false
	}
	if this.SeriesIndexType != that1.SeriesIndexType {
		return false
	}
	if this.AttrName != that1.AttrName {
		return false
	}
	return true
}
func (this *ItemSelector) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ItemSelector)
	if !ok {
		that2, ok := that.(ItemSelector)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DefID != that1.DefID {
		return false
	}
	if len(this.Include) != len(that1.Include) {
		return false
	}
	for i := range this.Include {
		if this.Include[i] != that1.Include[i] {
			return false
		}
	}
	if len(this.Exclude) != len(that1.Exclude) {
		return false
	}
	for i := range this.Exclude {
		if this.Exclude[i] != that1.Exclude[i] {
			return false
		}
	}
	return true
}
func (this *HandleURI) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HandleURI)
	if !ok {
		that2, ok := that.(HandleURI)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.URI != that1.URI {
		return false
	}
	return true
}
func (this *PinRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PinRequest)
	if !ok {
		that2, ok := that.(PinRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ParentReqID != that1.ParentReqID {
		return false
	}
	if this.PinURL != that1.PinURL {
		return false
	}
	if this.PinCellIDx0 != that1.PinCellIDx0 {
		return false
	}
	if this.PinCellIDx1 != that1.PinCellIDx1 {
		return false
	}
	if this.ParentAttrSelector != that1.ParentAttrSelector {
		return false
	}
	if this.ChildCellSelector != that1.ChildCellSelector {
		return false
	}
	if this.Flags != that1.Flags {
		return false
	}
	return true
}
func (this *Position) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Position)
	if !ok {
		that2, ok := that.(Position)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.CordType != that1.CordType {
		return false
	}
	if this.U != that1.U {
		return false
	}
	if this.V != that1.V {
		return false
	}
	if this.W != that1.W {
		return false
	}
	if this.ROU != that1.ROU {
		return false
	}
	return true
}
func (this *AssetTag) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AssetTag)
	if !ok {
		that2, ok := that.(AssetTag)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if this.ContentType != that1.ContentType {
		return false
	}
	if this.URI != that1.URI {
		return false
	}
	if this.UIDx0 != that1.UIDx0 {
		return false
	}
	if this.UIDx1 != that1.UIDx1 {
		return false
	}
	if this.UIDx2 != that1.UIDx2 {
		return false
	}
	if this.Rx0 != that1.Rx0 {
		return false
	}
	if this.Rx1 != that1.Rx1 {
		return false
	}
	if this.Rx2 != that1.Rx2 {
		return false
	}
	if this.PixelWidth != that1.PixelWidth {
		return false
	}
	if this.PixelHeight != that1.PixelHeight {
		return false
	}
	if this.MeterScale != that1.MeterScale {
		return false
	}
	if len(this.SubTags) != len(that1.SubTags) {
		return false
	}
	for i := range this.SubTags {
		if !this.SubTags[i].Equal(that1.SubTags[i]) {
			return false
		}
	}
	return true
}
func (this *SheetInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SheetInfo)
	if !ok {
		that2, ok := that.(SheetInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AppSheetURI != that1.AppSheetURI {
		return false
	}
	if len(this.BoundSeries) != len(that1.BoundSeries) {
		return false
	}
	for i := range this.BoundSeries {
		if !this.BoundSeries[i].Equal(that1.BoundSeries[i]) {
			return false
		}
	}
	return true
}
func (this *SheetGroup) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SheetGroup)
	if !ok {
		that2, ok := that.(SheetGroup)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.SheetCatalog) != len(that1.SheetCatalog) {
		return false
	}
	for i := range this.SheetCatalog {
		if !this.SheetCatalog[i].Equal(that1.SheetCatalog[i]) {
			return false
		}
	}
	return true
}
func (this *CryptoKey) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CryptoKey)
	if !ok {
		that2, ok := that.(CryptoKey)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.CryptoKitID != that1.CryptoKitID {
		return false
	}
	if !bytes.Equal(this.KeyBytes, that1.KeyBytes) {
		return false
	}
	return true
}
func (this *CellHeader) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CellHeader)
	if !ok {
		that2, ok := that.(CellHeader)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Title != that1.Title {
		return false
	}
	if this.Subtitle != that1.Subtitle {
		return false
	}
	if this.About != that1.About {
		return false
	}
	if len(this.Glyphs) != len(that1.Glyphs) {
		return false
	}
	for i := range this.Glyphs {
		if !this.Glyphs[i].Equal(that1.Glyphs[i]) {
			return false
		}
	}
	if this.Created != that1.Created {
		return false
	}
	if this.Modified != that1.Modified {
		return false
	}
	if this.CellURL != that1.CellURL {
		return false
	}
	if !this.ExternalLink.Equal(that1.ExternalLink) {
		return false
	}
	return true
}
func (this *AuthToken) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AuthToken)
	if !ok {
		that2, ok := that.(AuthToken)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AccessToken != that1.AccessToken {
		return false
	}
	if this.TokenType != that1.TokenType {
		return false
	}
	if this.RefreshToken != that1.RefreshToken {
		return false
	}
	if this.Expiry != that1.Expiry {
		return false
	}
	return true
}
func (this *TRS) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TRS)
	if !ok {
		that2, ok := that.(TRS)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.X1 != that1.X1 {
		return false
	}
	if this.X2 != that1.X2 {
		return false
	}
	if this.X3 != that1.X3 {
		return false
	}
	if this.ScaleMode != that1.ScaleMode {
		return false
	}
	if this.Scale1 != that1.Scale1 {
		return false
	}
	if this.Scale2 != that1.Scale2 {
		return false
	}
	if this.Scale3 != that1.Scale3 {
		return false
	}
	if this.Rotate1 != that1.Rotate1 {
		return false
	}
	if this.Rotate2 != that1.Rotate2 {
		return false
	}
	if this.Rotate3 != that1.Rotate3 {
		return false
	}
	return true
}
func (this *FeedParams) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*FeedParams)
	if !ok {
		that2, ok := that.(FeedParams)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UpdateIntervalMin != that1.UpdateIntervalMin {
		return false
	}
	if this.UpdateIntervalMax != that1.UpdateIntervalMax {
		return false
	}
	return true
}
func (this *DataSegment) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DataSegment)
	if !ok {
		that2, ok := that.(DataSegment)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ByteOfs != that1.ByteOfs {
		return false
	}
	if this.ByteSz != that1.ByteSz {
		return false
	}
	if !bytes.Equal(this.InlineData, that1.InlineData) {
		return false
	}
	if this.StreamURI != that1.StreamURI {
		return false
	}
	if this.BlobID != that1.BlobID {
		return false
	}
	return true
}
func (this *Err) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Err)
	if !ok {
		that2, ok := that.(Err)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Code != that1.Code {
		return false
	}
	if this.Level != that1.Level {
		return false
	}
	if this.Msg != that1.Msg {
		return false
	}
	return true
}
func (this *Msg) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&amp.Msg{")
	s = append(s, "ReqID: "+fmt.Sprintf("%#v", this.ReqID)+",\n")
	s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	if this.CellTxs != nil {
		s = append(s, "CellTxs: "+fmt.Sprintf("%#v", this.CellTxs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CellTxPb) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&amp.CellTxPb{")
	s = append(s, "Op: "+fmt.Sprintf("%#v", this.Op)+",\n")
	s = append(s, "CellID_0: "+fmt.Sprintf("%#v", this.CellID_0)+",\n")
	s = append(s, "CellID_1: "+fmt.Sprintf("%#v", this.CellID_1)+",\n")
	if this.Elems != nil {
		s = append(s, "Elems: "+fmt.Sprintf("%#v", this.Elems)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AttrElemPb) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&amp.AttrElemPb{")
	s = append(s, "AttrID: "+fmt.Sprintf("%#v", this.AttrID)+",\n")
	s = append(s, "ValBuf: "+fmt.Sprintf("%#v", this.ValBuf)+",\n")
	s = append(s, "SI: "+fmt.Sprintf("%#v", this.SI)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Login) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&amp.Login{")
	s = append(s, "UserUID: "+fmt.Sprintf("%#v", this.UserUID)+",\n")
	s = append(s, "HostAddr: "+fmt.Sprintf("%#v", this.HostAddr)+",\n")
	s = append(s, "DeviceLabel: "+fmt.Sprintf("%#v", this.DeviceLabel)+",\n")
	s = append(s, "DeviceUID: "+fmt.Sprintf("%#v", this.DeviceUID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LoginChallenge) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&amp.LoginChallenge{")
	s = append(s, "Hash: "+fmt.Sprintf("%#v", this.Hash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LoginResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&amp.LoginResponse{")
	s = append(s, "HashResp: "+fmt.Sprintf("%#v", this.HashResp)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Symbol) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&amp.Symbol{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RegisterDefs) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&amp.RegisterDefs{")
	if this.Symbols != nil {
		s = append(s, "Symbols: "+fmt.Sprintf("%#v", this.Symbols)+",\n")
	}
	if this.Attrs != nil {
		s = append(s, "Attrs: "+fmt.Sprintf("%#v", this.Attrs)+",\n")
	}
	if this.Selectors != nil {
		s = append(s, "Selectors: "+fmt.Sprintf("%#v", this.Selectors)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AttrSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&amp.AttrSpec{")
	s = append(s, "DefID: "+fmt.Sprintf("%#v", this.DefID)+",\n")
	s = append(s, "ElemType: "+fmt.Sprintf("%#v", this.ElemType)+",\n")
	s = append(s, "SeriesSpec: "+fmt.Sprintf("%#v", this.SeriesSpec)+",\n")
	s = append(s, "SeriesIndexType: "+fmt.Sprintf("%#v", this.SeriesIndexType)+",\n")
	s = append(s, "AttrName: "+fmt.Sprintf("%#v", this.AttrName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ItemSelector) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&amp.ItemSelector{")
	s = append(s, "DefID: "+fmt.Sprintf("%#v", this.DefID)+",\n")
	s = append(s, "Include: "+fmt.Sprintf("%#v", this.Include)+",\n")
	s = append(s, "Exclude: "+fmt.Sprintf("%#v", this.Exclude)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *HandleURI) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&amp.HandleURI{")
	s = append(s, "URI: "+fmt.Sprintf("%#v", this.URI)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PinRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&amp.PinRequest{")
	s = append(s, "ParentReqID: "+fmt.Sprintf("%#v", this.ParentReqID)+",\n")
	s = append(s, "PinURL: "+fmt.Sprintf("%#v", this.PinURL)+",\n")
	s = append(s, "PinCellIDx0: "+fmt.Sprintf("%#v", this.PinCellIDx0)+",\n")
	s = append(s, "PinCellIDx1: "+fmt.Sprintf("%#v", this.PinCellIDx1)+",\n")
	s = append(s, "ParentAttrSelector: "+fmt.Sprintf("%#v", this.ParentAttrSelector)+",\n")
	s = append(s, "ChildCellSelector: "+fmt.Sprintf("%#v", this.ChildCellSelector)+",\n")
	s = append(s, "Flags: "+fmt.Sprintf("%#v", this.Flags)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Position) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&amp.Position{")
	s = append(s, "CordType: "+fmt.Sprintf("%#v", this.CordType)+",\n")
	s = append(s, "U: "+fmt.Sprintf("%#v", this.U)+",\n")
	s = append(s, "V: "+fmt.Sprintf("%#v", this.V)+",\n")
	s = append(s, "W: "+fmt.Sprintf("%#v", this.W)+",\n")
	s = append(s, "ROU: "+fmt.Sprintf("%#v", this.ROU)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AssetTag) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 17)
	s = append(s, "&amp.AssetTag{")
	s = append(s, "State: "+fmt.Sprintf("%#v", this.State)+",\n")
	s = append(s, "ContentType: "+fmt.Sprintf("%#v", this.ContentType)+",\n")
	s = append(s, "URI: "+fmt.Sprintf("%#v", this.URI)+",\n")
	s = append(s, "UIDx0: "+fmt.Sprintf("%#v", this.UIDx0)+",\n")
	s = append(s, "UIDx1: "+fmt.Sprintf("%#v", this.UIDx1)+",\n")
	s = append(s, "UIDx2: "+fmt.Sprintf("%#v", this.UIDx2)+",\n")
	s = append(s, "Rx0: "+fmt.Sprintf("%#v", this.Rx0)+",\n")
	s = append(s, "Rx1: "+fmt.Sprintf("%#v", this.Rx1)+",\n")
	s = append(s, "Rx2: "+fmt.Sprintf("%#v", this.Rx2)+",\n")
	s = append(s, "PixelWidth: "+fmt.Sprintf("%#v", this.PixelWidth)+",\n")
	s = append(s, "PixelHeight: "+fmt.Sprintf("%#v", this.PixelHeight)+",\n")
	s = append(s, "MeterScale: "+fmt.Sprintf("%#v", this.MeterScale)+",\n")
	if this.SubTags != nil {
		s = append(s, "SubTags: "+fmt.Sprintf("%#v", this.SubTags)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SheetInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&amp.SheetInfo{")
	s = append(s, "AppSheetURI: "+fmt.Sprintf("%#v", this.AppSheetURI)+",\n")
	if this.BoundSeries != nil {
		s = append(s, "BoundSeries: "+fmt.Sprintf("%#v", this.BoundSeries)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SheetGroup) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&amp.SheetGroup{")
	if this.SheetCatalog != nil {
		s = append(s, "SheetCatalog: "+fmt.Sprintf("%#v", this.SheetCatalog)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CryptoKey) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&amp.CryptoKey{")
	s = append(s, "CryptoKitID: "+fmt.Sprintf("%#v", this.CryptoKitID)+",\n")
	s = append(s, "KeyBytes: "+fmt.Sprintf("%#v", this.KeyBytes)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CellHeader) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&amp.CellHeader{")
	s = append(s, "Title: "+fmt.Sprintf("%#v", this.Title)+",\n")
	s = append(s, "Subtitle: "+fmt.Sprintf("%#v", this.Subtitle)+",\n")
	s = append(s, "About: "+fmt.Sprintf("%#v", this.About)+",\n")
	if this.Glyphs != nil {
		s = append(s, "Glyphs: "+fmt.Sprintf("%#v", this.Glyphs)+",\n")
	}
	s = append(s, "Created: "+fmt.Sprintf("%#v", this.Created)+",\n")
	s = append(s, "Modified: "+fmt.Sprintf("%#v", this.Modified)+",\n")
	s = append(s, "CellURL: "+fmt.Sprintf("%#v", this.CellURL)+",\n")
	if this.ExternalLink != nil {
		s = append(s, "ExternalLink: "+fmt.Sprintf("%#v", this.ExternalLink)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AuthToken) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&amp.AuthToken{")
	s = append(s, "AccessToken: "+fmt.Sprintf("%#v", this.AccessToken)+",\n")
	s = append(s, "TokenType: "+fmt.Sprintf("%#v", this.TokenType)+",\n")
	s = append(s, "RefreshToken: "+fmt.Sprintf("%#v", this.RefreshToken)+",\n")
	s = append(s, "Expiry: "+fmt.Sprintf("%#v", this.Expiry)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TRS) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 14)
	s = append(s, "&amp.TRS{")
	s = append(s, "X1: "+fmt.Sprintf("%#v", this.X1)+",\n")
	s = append(s, "X2: "+fmt.Sprintf("%#v", this.X2)+",\n")
	s = append(s, "X3: "+fmt.Sprintf("%#v", this.X3)+",\n")
	s = append(s, "ScaleMode: "+fmt.Sprintf("%#v", this.ScaleMode)+",\n")
	s = append(s, "Scale1: "+fmt.Sprintf("%#v", this.Scale1)+",\n")
	s = append(s, "Scale2: "+fmt.Sprintf("%#v", this.Scale2)+",\n")
	s = append(s, "Scale3: "+fmt.Sprintf("%#v", this.Scale3)+",\n")
	s = append(s, "Rotate1: "+fmt.Sprintf("%#v", this.Rotate1)+",\n")
	s = append(s, "Rotate2: "+fmt.Sprintf("%#v", this.Rotate2)+",\n")
	s = append(s, "Rotate3: "+fmt.Sprintf("%#v", this.Rotate3)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *FeedParams) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&amp.FeedParams{")
	s = append(s, "UpdateIntervalMin: "+fmt.Sprintf("%#v", this.UpdateIntervalMin)+",\n")
	s = append(s, "UpdateIntervalMax: "+fmt.Sprintf("%#v", this.UpdateIntervalMax)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DataSegment) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&amp.DataSegment{")
	s = append(s, "ByteOfs: "+fmt.Sprintf("%#v", this.ByteOfs)+",\n")
	s = append(s, "ByteSz: "+fmt.Sprintf("%#v", this.ByteSz)+",\n")
	s = append(s, "InlineData: "+fmt.Sprintf("%#v", this.InlineData)+",\n")
	s = append(s, "StreamURI: "+fmt.Sprintf("%#v", this.StreamURI)+",\n")
	s = append(s, "BlobID: "+fmt.Sprintf("%#v", this.BlobID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Err) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&amp.Err{")
	s = append(s, "Code: "+fmt.Sprintf("%#v", this.Code)+",\n")
	s = append(s, "Level: "+fmt.Sprintf("%#v", this.Level)+",\n")
	s = append(s, "Msg: "+fmt.Sprintf("%#v", this.Msg)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringAmp(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Msg) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Msg) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Msg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CellTxs) > 0 {
		for iNdEx := len(m.CellTxs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CellTxs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAmp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Status != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if m.ReqID != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.ReqID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CellTxPb) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CellTxPb) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Elems) > 0 {
		for iNdEx := len(m.Elems) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Elems[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAmp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if m.CellID_1 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.CellID_1))
		i--
		dAtA[i] = 0x21
	}
	if m.CellID_0 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.CellID_0))
		i--
		dAtA[i] = 0x19
	}
	if m.Op != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.Op))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *AttrElemPb) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AttrElemPb) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SI != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.SI))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ValBuf) > 0 {
		i -= len(m.ValBuf)
		copy(dAtA[i:], m.ValBuf)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.ValBuf)))
		i--
		dAtA[i] = 0x12
	}
	if m.AttrID != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.AttrID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Login) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Login) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DeviceUID) > 0 {
		i -= len(m.DeviceUID)
		copy(dAtA[i:], m.DeviceUID)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.DeviceUID)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.DeviceLabel) > 0 {
		i -= len(m.DeviceLabel)
		copy(dAtA[i:], m.DeviceLabel)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.DeviceLabel)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.HostAddr) > 0 {
		i -= len(m.HostAddr)
		copy(dAtA[i:], m.HostAddr)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.HostAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.UserUID) > 0 {
		i -= len(m.UserUID)
		copy(dAtA[i:], m.UserUID)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.UserUID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *LoginChallenge) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LoginChallenge) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *LoginResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LoginResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.HashResp) > 0 {
		i -= len(m.HashResp)
		copy(dAtA[i:], m.HashResp)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.HashResp)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Symbol) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Symbol) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.ID != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *RegisterDefs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterDefs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Selectors) > 0 {
		for iNdEx := len(m.Selectors) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Selectors[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAmp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Attrs) > 0 {
		for iNdEx := len(m.Attrs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Attrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAmp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Symbols) > 0 {
		for iNdEx := len(m.Symbols) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Symbols[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAmp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *AttrSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AttrSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AttrName != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.AttrName))
		i--
		dAtA[i] = 0x30
	}
	if m.SeriesIndexType != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.SeriesIndexType))
		i--
		dAtA[i] = 0x28
	}
	if m.SeriesSpec != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.SeriesSpec))
		i--
		dAtA[i] = 0x20
	}
	if m.ElemType != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.ElemType))
		i--
		dAtA[i] = 0x18
	}
	if m.DefID != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.DefID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ItemSelector) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ItemSelector) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Exclude) > 0 {
		dAtA2 := make([]byte, len(m.Exclude)*10)
		var j1 int
		for _, num := range m.Exclude {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintAmp(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Include) > 0 {
		dAtA4 := make([]byte, len(m.Include)*10)
		var j3 int
		for _, num := range m.Include {
			for num >= 1<<7 {
				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j3++
			}
			dAtA4[j3] = uint8(num)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA4[:j3])
		i = encodeVarintAmp(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0x22
	}
	if m.DefID != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.DefID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *HandleURI) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HandleURI) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.URI) > 0 {
		i -= len(m.URI)
		copy(dAtA[i:], m.URI)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.URI)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PinRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PinRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Flags != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.Flags))
		i--
		dAtA[i] = 0x38
	}
	if m.ChildCellSelector != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.ChildCellSelector))
		i--
		dAtA[i] = 0x30
	}
	if m.ParentAttrSelector != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.ParentAttrSelector))
		i--
		dAtA[i] = 0x28
	}
	if m.PinCellIDx1 != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.PinCellIDx1))
		i--
		dAtA[i] = 0x20
	}
	if m.PinCellIDx0 != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.PinCellIDx0))
		i--
		dAtA[i] = 0x18
	}
	if len(m.PinURL) > 0 {
		i -= len(m.PinURL)
		copy(dAtA[i:], m.PinURL)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.PinURL)))
		i--
		dAtA[i] = 0x12
	}
	if m.ParentReqID != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.ParentReqID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Position) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Position) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ROU != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.ROU))))
		i--
		dAtA[i] = 0x35
	}
	if m.W != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.W))))
		i--
		dAtA[i] = 0x29
	}
	if m.V != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.V))))
		i--
		dAtA[i] = 0x21
	}
	if m.U != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.U))))
		i--
		dAtA[i] = 0x19
	}
	if m.CordType != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.CordType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *AssetTag) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AssetTag) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MeterScale != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.MeterScale))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf5
	}
	if m.PixelHeight != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.PixelHeight))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe8
	}
	if m.PixelWidth != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.PixelWidth))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe0
	}
	if m.Rx2 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rx2))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb5
	}
	if m.Rx1 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rx1))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xad
	}
	if m.Rx0 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rx0))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa5
	}
	if m.UIDx2 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.UIDx2))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x91
	}
	if m.UIDx1 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.UIDx1))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x89
	}
	if m.UIDx0 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.UIDx0))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x81
	}
	if len(m.URI) > 0 {
		i -= len(m.URI)
		copy(dAtA[i:], m.URI)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.URI)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.ContentType) > 0 {
		i -= len(m.ContentType)
		copy(dAtA[i:], m.ContentType)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.ContentType)))
		i--
		dAtA[i] = 0x2a
	}
	if m.State != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	if len(m.SubTags) > 0 {
		for iNdEx := len(m.SubTags) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SubTags[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAmp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SheetInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SheetInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BoundSeries) > 0 {
		for iNdEx := len(m.BoundSeries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BoundSeries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAmp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.AppSheetURI) > 0 {
		i -= len(m.AppSheetURI)
		copy(dAtA[i:], m.AppSheetURI)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.AppSheetURI)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SheetGroup) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SheetGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SheetCatalog) > 0 {
		for iNdEx := len(m.SheetCatalog) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SheetCatalog[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAmp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *CryptoKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CryptoKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.KeyBytes) > 0 {
		i -= len(m.KeyBytes)
		copy(dAtA[i:], m.KeyBytes)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.KeyBytes)))
		i--
		dAtA[i] = 0x22
	}
	if m.CryptoKitID != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.CryptoKitID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CellHeader) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CellHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExternalLink != nil {
		{
			size, err := m.ExternalLink.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAmp(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb2
	}
	if len(m.CellURL) > 0 {
		i -= len(m.CellURL)
		copy(dAtA[i:], m.CellURL)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.CellURL)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if m.Modified != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.Modified))
		i--
		dAtA[i] = 0x48
	}
	if m.Created != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.Created))
		i--
		dAtA[i] = 0x40
	}
	if len(m.Glyphs) > 0 {
		for iNdEx := len(m.Glyphs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Glyphs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAmp(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.About) > 0 {
		i -= len(m.About)
		copy(dAtA[i:], m.About)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.About)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Subtitle) > 0 {
		i -= len(m.Subtitle)
		copy(dAtA[i:], m.Subtitle)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.Subtitle)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

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

func (m *AuthToken) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AuthToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Expiry != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.Expiry))
		i--
		dAtA[i] = 0x20
	}
	if len(m.RefreshToken) > 0 {
		i -= len(m.RefreshToken)
		copy(dAtA[i:], m.RefreshToken)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.RefreshToken)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.TokenType) > 0 {
		i -= len(m.TokenType)
		copy(dAtA[i:], m.TokenType)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.TokenType)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccessToken) > 0 {
		i -= len(m.AccessToken)
		copy(dAtA[i:], m.AccessToken)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.AccessToken)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TRS) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TRS) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Rotate3 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rotate3))))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xfd
	}
	if m.Rotate2 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rotate2))))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xf5
	}
	if m.Rotate1 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rotate1))))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xed
	}
	if m.Scale3 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Scale3))))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xad
	}
	if m.Scale2 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Scale2))))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xa5
	}
	if m.Scale1 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Scale1))))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x9d
	}
	if m.ScaleMode != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.ScaleMode))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x90
	}
	if m.X3 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.X3))))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd9
	}
	if m.X2 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.X2))))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd1
	}
	if m.X1 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.X1))))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc9
	}
	return len(dAtA) - i, nil
}

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

func (m *FeedParams) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FeedParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdateIntervalMax != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UpdateIntervalMax))))
		i--
		dAtA[i] = 0x1d
	}
	if m.UpdateIntervalMin != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.UpdateIntervalMin))))
		i--
		dAtA[i] = 0x15
	}
	return len(dAtA) - i, nil
}

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

func (m *DataSegment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DataSegment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BlobID != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.BlobID))
		i--
		dAtA[i] = 0x50
	}
	if len(m.StreamURI) > 0 {
		i -= len(m.StreamURI)
		copy(dAtA[i:], m.StreamURI)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.StreamURI)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.InlineData) > 0 {
		i -= len(m.InlineData)
		copy(dAtA[i:], m.InlineData)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.InlineData)))
		i--
		dAtA[i] = 0x3a
	}
	if m.ByteSz != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.ByteSz))
		i--
		dAtA[i] = 0x30
	}
	if m.ByteOfs != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.ByteOfs))
		i--
		dAtA[i] = 0x28
	}
	return len(dAtA) - i, nil
}

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

func (m *Err) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Err) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Msg) > 0 {
		i -= len(m.Msg)
		copy(dAtA[i:], m.Msg)
		i = encodeVarintAmp(dAtA, i, uint64(len(m.Msg)))
		i--
		dAtA[i] = 0x22
	}
	if m.Level != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.Level))
		i--
		dAtA[i] = 0x10
	}
	if m.Code != 0 {
		i = encodeVarintAmp(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintAmp(dAtA []byte, offset int, v uint64) int {
	offset -= sovAmp(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Msg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReqID != 0 {
		n += 1 + sovAmp(uint64(m.ReqID))
	}
	if m.Status != 0 {
		n += 1 + sovAmp(uint64(m.Status))
	}
	if len(m.CellTxs) > 0 {
		for _, e := range m.CellTxs {
			l = e.Size()
			n += 1 + l + sovAmp(uint64(l))
		}
	}
	return n
}

func (m *CellTxPb) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovAmp(uint64(m.Op))
	}
	if m.CellID_0 != 0 {
		n += 9
	}
	if m.CellID_1 != 0 {
		n += 9
	}
	if len(m.Elems) > 0 {
		for _, e := range m.Elems {
			l = e.Size()
			n += 1 + l + sovAmp(uint64(l))
		}
	}
	return n
}

func (m *AttrElemPb) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AttrID != 0 {
		n += 1 + sovAmp(uint64(m.AttrID))
	}
	l = len(m.ValBuf)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	if m.SI != 0 {
		n += 1 + sovAmp(uint64(m.SI))
	}
	return n
}

func (m *Login) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UserUID)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	l = len(m.HostAddr)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	l = len(m.DeviceLabel)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	l = len(m.DeviceUID)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	return n
}

func (m *LoginChallenge) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	return n
}

func (m *LoginResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.HashResp)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	return n
}

func (m *Symbol) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovAmp(uint64(m.ID))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	return n
}

func (m *RegisterDefs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Symbols) > 0 {
		for _, e := range m.Symbols {
			l = e.Size()
			n += 1 + l + sovAmp(uint64(l))
		}
	}
	if len(m.Attrs) > 0 {
		for _, e := range m.Attrs {
			l = e.Size()
			n += 1 + l + sovAmp(uint64(l))
		}
	}
	if len(m.Selectors) > 0 {
		for _, e := range m.Selectors {
			l = e.Size()
			n += 1 + l + sovAmp(uint64(l))
		}
	}
	return n
}

func (m *AttrSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DefID != 0 {
		n += 1 + sovAmp(uint64(m.DefID))
	}
	if m.ElemType != 0 {
		n += 1 + sovAmp(uint64(m.ElemType))
	}
	if m.SeriesSpec != 0 {
		n += 1 + sovAmp(uint64(m.SeriesSpec))
	}
	if m.SeriesIndexType != 0 {
		n += 1 + sovAmp(uint64(m.SeriesIndexType))
	}
	if m.AttrName != 0 {
		n += 1 + sovAmp(uint64(m.AttrName))
	}
	return n
}

func (m *ItemSelector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DefID != 0 {
		n += 1 + sovAmp(uint64(m.DefID))
	}
	if len(m.Include) > 0 {
		l = 0
		for _, e := range m.Include {
			l += sovAmp(uint64(e))
		}
		n += 1 + sovAmp(uint64(l)) + l
	}
	if len(m.Exclude) > 0 {
		l = 0
		for _, e := range m.Exclude {
			l += sovAmp(uint64(e))
		}
		n += 1 + sovAmp(uint64(l)) + l
	}
	return n
}

func (m *HandleURI) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.URI)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	return n
}

func (m *PinRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ParentReqID != 0 {
		n += 1 + sovAmp(uint64(m.ParentReqID))
	}
	l = len(m.PinURL)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	if m.PinCellIDx0 != 0 {
		n += 1 + sovAmp(uint64(m.PinCellIDx0))
	}
	if m.PinCellIDx1 != 0 {
		n += 1 + sovAmp(uint64(m.PinCellIDx1))
	}
	if m.ParentAttrSelector != 0 {
		n += 1 + sovAmp(uint64(m.ParentAttrSelector))
	}
	if m.ChildCellSelector != 0 {
		n += 1 + sovAmp(uint64(m.ChildCellSelector))
	}
	if m.Flags != 0 {
		n += 1 + sovAmp(uint64(m.Flags))
	}
	return n
}

func (m *Position) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CordType != 0 {
		n += 1 + sovAmp(uint64(m.CordType))
	}
	if m.U != 0 {
		n += 9
	}
	if m.V != 0 {
		n += 9
	}
	if m.W != 0 {
		n += 9
	}
	if m.ROU != 0 {
		n += 5
	}
	return n
}

func (m *AssetTag) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SubTags) > 0 {
		for _, e := range m.SubTags {
			l = e.Size()
			n += 1 + l + sovAmp(uint64(l))
		}
	}
	if m.State != 0 {
		n += 1 + sovAmp(uint64(m.State))
	}
	l = len(m.ContentType)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	l = len(m.URI)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	if m.UIDx0 != 0 {
		n += 10
	}
	if m.UIDx1 != 0 {
		n += 10
	}
	if m.UIDx2 != 0 {
		n += 10
	}
	if m.Rx0 != 0 {
		n += 6
	}
	if m.Rx1 != 0 {
		n += 6
	}
	if m.Rx2 != 0 {
		n += 6
	}
	if m.PixelWidth != 0 {
		n += 2 + sovAmp(uint64(m.PixelWidth))
	}
	if m.PixelHeight != 0 {
		n += 2 + sovAmp(uint64(m.PixelHeight))
	}
	if m.MeterScale != 0 {
		n += 6
	}
	return n
}

func (m *SheetInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppSheetURI)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	if len(m.BoundSeries) > 0 {
		for _, e := range m.BoundSeries {
			l = e.Size()
			n += 1 + l + sovAmp(uint64(l))
		}
	}
	return n
}

func (m *SheetGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SheetCatalog) > 0 {
		for _, e := range m.SheetCatalog {
			l = e.Size()
			n += 1 + l + sovAmp(uint64(l))
		}
	}
	return n
}

func (m *CryptoKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CryptoKitID != 0 {
		n += 1 + sovAmp(uint64(m.CryptoKitID))
	}
	l = len(m.KeyBytes)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	return n
}

func (m *CellHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	l = len(m.Subtitle)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	l = len(m.About)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	if len(m.Glyphs) > 0 {
		for _, e := range m.Glyphs {
			l = e.Size()
			n += 1 + l + sovAmp(uint64(l))
		}
	}
	if m.Created != 0 {
		n += 1 + sovAmp(uint64(m.Created))
	}
	if m.Modified != 0 {
		n += 1 + sovAmp(uint64(m.Modified))
	}
	l = len(m.CellURL)
	if l > 0 {
		n += 2 + l + sovAmp(uint64(l))
	}
	if m.ExternalLink != nil {
		l = m.ExternalLink.Size()
		n += 2 + l + sovAmp(uint64(l))
	}
	return n
}

func (m *AuthToken) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccessToken)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	l = len(m.TokenType)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	l = len(m.RefreshToken)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	if m.Expiry != 0 {
		n += 1 + sovAmp(uint64(m.Expiry))
	}
	return n
}

func (m *TRS) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.X1 != 0 {
		n += 10
	}
	if m.X2 != 0 {
		n += 10
	}
	if m.X3 != 0 {
		n += 10
	}
	if m.ScaleMode != 0 {
		n += 2 + sovAmp(uint64(m.ScaleMode))
	}
	if m.Scale1 != 0 {
		n += 6
	}
	if m.Scale2 != 0 {
		n += 6
	}
	if m.Scale3 != 0 {
		n += 6
	}
	if m.Rotate1 != 0 {
		n += 6
	}
	if m.Rotate2 != 0 {
		n += 6
	}
	if m.Rotate3 != 0 {
		n += 6
	}
	return n
}

func (m *FeedParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UpdateIntervalMin != 0 {
		n += 5
	}
	if m.UpdateIntervalMax != 0 {
		n += 5
	}
	return n
}

func (m *DataSegment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ByteOfs != 0 {
		n += 1 + sovAmp(uint64(m.ByteOfs))
	}
	if m.ByteSz != 0 {
		n += 1 + sovAmp(uint64(m.ByteSz))
	}
	l = len(m.InlineData)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	l = len(m.StreamURI)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	if m.BlobID != 0 {
		n += 1 + sovAmp(uint64(m.BlobID))
	}
	return n
}

func (m *Err) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovAmp(uint64(m.Code))
	}
	if m.Level != 0 {
		n += 1 + sovAmp(uint64(m.Level))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovAmp(uint64(l))
	}
	return n
}

func sovAmp(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozAmp(x uint64) (n int) {
	return sovAmp(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Msg) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForCellTxs := "[]*CellTxPb{"
	for _, f := range this.CellTxs {
		repeatedStringForCellTxs += strings.Replace(f.String(), "CellTxPb", "CellTxPb", 1) + ","
	}
	repeatedStringForCellTxs += "}"
	s := strings.Join([]string{`&Msg{`,
		`ReqID:` + fmt.Sprintf("%v", this.ReqID) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`CellTxs:` + repeatedStringForCellTxs + `,`,
		`}`,
	}, "")
	return s
}
func (this *CellTxPb) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForElems := "[]*AttrElemPb{"
	for _, f := range this.Elems {
		repeatedStringForElems += strings.Replace(f.String(), "AttrElemPb", "AttrElemPb", 1) + ","
	}
	repeatedStringForElems += "}"
	s := strings.Join([]string{`&CellTxPb{`,
		`Op:` + fmt.Sprintf("%v", this.Op) + `,`,
		`CellID_0:` + fmt.Sprintf("%v", this.CellID_0) + `,`,
		`CellID_1:` + fmt.Sprintf("%v", this.CellID_1) + `,`,
		`Elems:` + repeatedStringForElems + `,`,
		`}`,
	}, "")
	return s
}
func (this *AttrElemPb) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AttrElemPb{`,
		`AttrID:` + fmt.Sprintf("%v", this.AttrID) + `,`,
		`ValBuf:` + fmt.Sprintf("%v", this.ValBuf) + `,`,
		`SI:` + fmt.Sprintf("%v", this.SI) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Login) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Login{`,
		`UserUID:` + fmt.Sprintf("%v", this.UserUID) + `,`,
		`HostAddr:` + fmt.Sprintf("%v", this.HostAddr) + `,`,
		`DeviceLabel:` + fmt.Sprintf("%v", this.DeviceLabel) + `,`,
		`DeviceUID:` + fmt.Sprintf("%v", this.DeviceUID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LoginChallenge) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LoginChallenge{`,
		`Hash:` + fmt.Sprintf("%v", this.Hash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LoginResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LoginResponse{`,
		`HashResp:` + fmt.Sprintf("%v", this.HashResp) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Symbol) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Symbol{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterDefs) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSymbols := "[]*Symbol{"
	for _, f := range this.Symbols {
		repeatedStringForSymbols += strings.Replace(f.String(), "Symbol", "Symbol", 1) + ","
	}
	repeatedStringForSymbols += "}"
	repeatedStringForAttrs := "[]*AttrSpec{"
	for _, f := range this.Attrs {
		repeatedStringForAttrs += strings.Replace(f.String(), "AttrSpec", "AttrSpec", 1) + ","
	}
	repeatedStringForAttrs += "}"
	repeatedStringForSelectors := "[]*ItemSelector{"
	for _, f := range this.Selectors {
		repeatedStringForSelectors += strings.Replace(f.String(), "ItemSelector", "ItemSelector", 1) + ","
	}
	repeatedStringForSelectors += "}"
	s := strings.Join([]string{`&RegisterDefs{`,
		`Symbols:` + repeatedStringForSymbols + `,`,
		`Attrs:` + repeatedStringForAttrs + `,`,
		`Selectors:` + repeatedStringForSelectors + `,`,
		`}`,
	}, "")
	return s
}
func (this *AttrSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AttrSpec{`,
		`DefID:` + fmt.Sprintf("%v", this.DefID) + `,`,
		`ElemType:` + fmt.Sprintf("%v", this.ElemType) + `,`,
		`SeriesSpec:` + fmt.Sprintf("%v", this.SeriesSpec) + `,`,
		`SeriesIndexType:` + fmt.Sprintf("%v", this.SeriesIndexType) + `,`,
		`AttrName:` + fmt.Sprintf("%v", this.AttrName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ItemSelector) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ItemSelector{`,
		`DefID:` + fmt.Sprintf("%v", this.DefID) + `,`,
		`Include:` + fmt.Sprintf("%v", this.Include) + `,`,
		`Exclude:` + fmt.Sprintf("%v", this.Exclude) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HandleURI) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HandleURI{`,
		`URI:` + fmt.Sprintf("%v", this.URI) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PinRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PinRequest{`,
		`ParentReqID:` + fmt.Sprintf("%v", this.ParentReqID) + `,`,
		`PinURL:` + fmt.Sprintf("%v", this.PinURL) + `,`,
		`PinCellIDx0:` + fmt.Sprintf("%v", this.PinCellIDx0) + `,`,
		`PinCellIDx1:` + fmt.Sprintf("%v", this.PinCellIDx1) + `,`,
		`ParentAttrSelector:` + fmt.Sprintf("%v", this.ParentAttrSelector) + `,`,
		`ChildCellSelector:` + fmt.Sprintf("%v", this.ChildCellSelector) + `,`,
		`Flags:` + fmt.Sprintf("%v", this.Flags) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Position) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Position{`,
		`CordType:` + fmt.Sprintf("%v", this.CordType) + `,`,
		`U:` + fmt.Sprintf("%v", this.U) + `,`,
		`V:` + fmt.Sprintf("%v", this.V) + `,`,
		`W:` + fmt.Sprintf("%v", this.W) + `,`,
		`ROU:` + fmt.Sprintf("%v", this.ROU) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AssetTag) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSubTags := "[]*AssetTag{"
	for _, f := range this.SubTags {
		repeatedStringForSubTags += strings.Replace(f.String(), "AssetTag", "AssetTag", 1) + ","
	}
	repeatedStringForSubTags += "}"
	s := strings.Join([]string{`&AssetTag{`,
		`SubTags:` + repeatedStringForSubTags + `,`,
		`State:` + fmt.Sprintf("%v", this.State) + `,`,
		`ContentType:` + fmt.Sprintf("%v", this.ContentType) + `,`,
		`URI:` + fmt.Sprintf("%v", this.URI) + `,`,
		`UIDx0:` + fmt.Sprintf("%v", this.UIDx0) + `,`,
		`UIDx1:` + fmt.Sprintf("%v", this.UIDx1) + `,`,
		`UIDx2:` + fmt.Sprintf("%v", this.UIDx2) + `,`,
		`Rx0:` + fmt.Sprintf("%v", this.Rx0) + `,`,
		`Rx1:` + fmt.Sprintf("%v", this.Rx1) + `,`,
		`Rx2:` + fmt.Sprintf("%v", this.Rx2) + `,`,
		`PixelWidth:` + fmt.Sprintf("%v", this.PixelWidth) + `,`,
		`PixelHeight:` + fmt.Sprintf("%v", this.PixelHeight) + `,`,
		`MeterScale:` + fmt.Sprintf("%v", this.MeterScale) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SheetInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForBoundSeries := "[]*AttrSpec{"
	for _, f := range this.BoundSeries {
		repeatedStringForBoundSeries += strings.Replace(f.String(), "AttrSpec", "AttrSpec", 1) + ","
	}
	repeatedStringForBoundSeries += "}"
	s := strings.Join([]string{`&SheetInfo{`,
		`AppSheetURI:` + fmt.Sprintf("%v", this.AppSheetURI) + `,`,
		`BoundSeries:` + repeatedStringForBoundSeries + `,`,
		`}`,
	}, "")
	return s
}
func (this *SheetGroup) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSheetCatalog := "[]*SheetInfo{"
	for _, f := range this.SheetCatalog {
		repeatedStringForSheetCatalog += strings.Replace(f.String(), "SheetInfo", "SheetInfo", 1) + ","
	}
	repeatedStringForSheetCatalog += "}"
	s := strings.Join([]string{`&SheetGroup{`,
		`SheetCatalog:` + repeatedStringForSheetCatalog + `,`,
		`}`,
	}, "")
	return s
}
func (this *CryptoKey) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CryptoKey{`,
		`CryptoKitID:` + fmt.Sprintf("%v", this.CryptoKitID) + `,`,
		`KeyBytes:` + fmt.Sprintf("%v", this.KeyBytes) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CellHeader) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForGlyphs := "[]*AssetTag{"
	for _, f := range this.Glyphs {
		repeatedStringForGlyphs += strings.Replace(f.String(), "AssetTag", "AssetTag", 1) + ","
	}
	repeatedStringForGlyphs += "}"
	s := strings.Join([]string{`&CellHeader{`,
		`Title:` + fmt.Sprintf("%v", this.Title) + `,`,
		`Subtitle:` + fmt.Sprintf("%v", this.Subtitle) + `,`,
		`About:` + fmt.Sprintf("%v", this.About) + `,`,
		`Glyphs:` + repeatedStringForGlyphs + `,`,
		`Created:` + fmt.Sprintf("%v", this.Created) + `,`,
		`Modified:` + fmt.Sprintf("%v", this.Modified) + `,`,
		`CellURL:` + fmt.Sprintf("%v", this.CellURL) + `,`,
		`ExternalLink:` + strings.Replace(this.ExternalLink.String(), "AssetTag", "AssetTag", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AuthToken) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AuthToken{`,
		`AccessToken:` + fmt.Sprintf("%v", this.AccessToken) + `,`,
		`TokenType:` + fmt.Sprintf("%v", this.TokenType) + `,`,
		`RefreshToken:` + fmt.Sprintf("%v", this.RefreshToken) + `,`,
		`Expiry:` + fmt.Sprintf("%v", this.Expiry) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TRS) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TRS{`,
		`X1:` + fmt.Sprintf("%v", this.X1) + `,`,
		`X2:` + fmt.Sprintf("%v", this.X2) + `,`,
		`X3:` + fmt.Sprintf("%v", this.X3) + `,`,
		`ScaleMode:` + fmt.Sprintf("%v", this.ScaleMode) + `,`,
		`Scale1:` + fmt.Sprintf("%v", this.Scale1) + `,`,
		`Scale2:` + fmt.Sprintf("%v", this.Scale2) + `,`,
		`Scale3:` + fmt.Sprintf("%v", this.Scale3) + `,`,
		`Rotate1:` + fmt.Sprintf("%v", this.Rotate1) + `,`,
		`Rotate2:` + fmt.Sprintf("%v", this.Rotate2) + `,`,
		`Rotate3:` + fmt.Sprintf("%v", this.Rotate3) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FeedParams) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FeedParams{`,
		`UpdateIntervalMin:` + fmt.Sprintf("%v", this.UpdateIntervalMin) + `,`,
		`UpdateIntervalMax:` + fmt.Sprintf("%v", this.UpdateIntervalMax) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DataSegment) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DataSegment{`,
		`ByteOfs:` + fmt.Sprintf("%v", this.ByteOfs) + `,`,
		`ByteSz:` + fmt.Sprintf("%v", this.ByteSz) + `,`,
		`InlineData:` + fmt.Sprintf("%v", this.InlineData) + `,`,
		`StreamURI:` + fmt.Sprintf("%v", this.StreamURI) + `,`,
		`BlobID:` + fmt.Sprintf("%v", this.BlobID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Err) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Err{`,
		`Code:` + fmt.Sprintf("%v", this.Code) + `,`,
		`Level:` + fmt.Sprintf("%v", this.Level) + `,`,
		`Msg:` + fmt.Sprintf("%v", this.Msg) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringAmp(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Msg) 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 ErrIntOverflowAmp
			}
			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: Msg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Msg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReqID", wireType)
			}
			m.ReqID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReqID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ReqStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellTxs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CellTxs = append(m.CellTxs, &CellTxPb{})
			if err := m.CellTxs[len(m.CellTxs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CellTxPb) 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 ErrIntOverflowAmp
			}
			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: CellTxPb: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CellTxPb: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= CellTxOp(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellID_0", wireType)
			}
			m.CellID_0 = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.CellID_0 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellID_1", wireType)
			}
			m.CellID_1 = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.CellID_1 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Elems", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Elems = append(m.Elems, &AttrElemPb{})
			if err := m.Elems[len(m.Elems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AttrElemPb) 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 ErrIntOverflowAmp
			}
			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: AttrElemPb: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AttrElemPb: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttrID", wireType)
			}
			m.AttrID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AttrID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValBuf", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValBuf = append(m.ValBuf[:0], dAtA[iNdEx:postIndex]...)
			if m.ValBuf == nil {
				m.ValBuf = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SI", wireType)
			}
			m.SI = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SI |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Login) 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 ErrIntOverflowAmp
			}
			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: Login: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Login: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserUID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UserUID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceLabel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceLabel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceUID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceUID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LoginChallenge) 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 ErrIntOverflowAmp
			}
			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: LoginChallenge: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LoginChallenge: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
			if m.Hash == nil {
				m.Hash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LoginResponse) 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 ErrIntOverflowAmp
			}
			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: LoginResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LoginResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HashResp", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HashResp = append(m.HashResp[:0], dAtA[iNdEx:postIndex]...)
			if m.HashResp == nil {
				m.HashResp = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Symbol) 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 ErrIntOverflowAmp
			}
			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: Symbol: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Symbol: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = append(m.Name[:0], dAtA[iNdEx:postIndex]...)
			if m.Name == nil {
				m.Name = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterDefs) 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 ErrIntOverflowAmp
			}
			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: RegisterDefs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterDefs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbols", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbols = append(m.Symbols, &Symbol{})
			if err := m.Symbols[len(m.Symbols)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attrs = append(m.Attrs, &AttrSpec{})
			if err := m.Attrs[len(m.Attrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selectors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Selectors = append(m.Selectors, &ItemSelector{})
			if err := m.Selectors[len(m.Selectors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AttrSpec) 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 ErrIntOverflowAmp
			}
			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: AttrSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AttrSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefID", wireType)
			}
			m.DefID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DefID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ElemType", wireType)
			}
			m.ElemType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ElemType |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeriesSpec", wireType)
			}
			m.SeriesSpec = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SeriesSpec |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeriesIndexType", wireType)
			}
			m.SeriesIndexType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SeriesIndexType |= SeriesIndexType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttrName", wireType)
			}
			m.AttrName = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AttrName |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ItemSelector) 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 ErrIntOverflowAmp
			}
			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: ItemSelector: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ItemSelector: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefID", wireType)
			}
			m.DefID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DefID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAmp
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Include = append(m.Include, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAmp
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthAmp
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthAmp
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Include) == 0 {
					m.Include = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowAmp
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Include = append(m.Include, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Include", wireType)
			}
		case 5:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAmp
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Exclude = append(m.Exclude, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowAmp
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthAmp
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthAmp
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Exclude) == 0 {
					m.Exclude = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowAmp
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Exclude = append(m.Exclude, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Exclude", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HandleURI) 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 ErrIntOverflowAmp
			}
			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: HandleURI: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HandleURI: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field URI", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.URI = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PinRequest) 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 ErrIntOverflowAmp
			}
			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: PinRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PinRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentReqID", wireType)
			}
			m.ParentReqID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParentReqID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PinURL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PinURL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PinCellIDx0", wireType)
			}
			m.PinCellIDx0 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PinCellIDx0 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PinCellIDx1", wireType)
			}
			m.PinCellIDx1 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PinCellIDx1 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentAttrSelector", wireType)
			}
			m.ParentAttrSelector = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParentAttrSelector |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChildCellSelector", wireType)
			}
			m.ChildCellSelector = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChildCellSelector |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType)
			}
			m.Flags = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Flags |= PinFlags(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Position) 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 ErrIntOverflowAmp
			}
			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: Position: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Position: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CordType", wireType)
			}
			m.CordType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CordType |= CordType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field U", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.U = float64(math.Float64frombits(v))
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field V", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.V = float64(math.Float64frombits(v))
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field W", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.W = float64(math.Float64frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field ROU", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.ROU = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AssetTag) 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 ErrIntOverflowAmp
			}
			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: AssetTag: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AssetTag: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubTags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubTags = append(m.SubTags, &AssetTag{})
			if err := m.SubTags[len(m.SubTags)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= QuadState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContentType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field URI", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.URI = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field UIDx0", wireType)
			}
			m.UIDx0 = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.UIDx0 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 17:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field UIDx1", wireType)
			}
			m.UIDx1 = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.UIDx1 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 18:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field UIDx2", wireType)
			}
			m.UIDx2 = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.UIDx2 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 20:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rx0", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rx0 = float32(math.Float32frombits(v))
		case 21:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rx1", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rx1 = float32(math.Float32frombits(v))
		case 22:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rx2", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rx2 = float32(math.Float32frombits(v))
		case 28:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PixelWidth", wireType)
			}
			m.PixelWidth = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PixelWidth |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 29:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PixelHeight", wireType)
			}
			m.PixelHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PixelHeight |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 30:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field MeterScale", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.MeterScale = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SheetInfo) 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 ErrIntOverflowAmp
			}
			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: SheetInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SheetInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppSheetURI", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppSheetURI = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoundSeries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BoundSeries = append(m.BoundSeries, &AttrSpec{})
			if err := m.BoundSeries[len(m.BoundSeries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SheetGroup) 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 ErrIntOverflowAmp
			}
			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: SheetGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SheetGroup: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SheetCatalog", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SheetCatalog = append(m.SheetCatalog, &SheetInfo{})
			if err := m.SheetCatalog[len(m.SheetCatalog)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CryptoKey) 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 ErrIntOverflowAmp
			}
			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: CryptoKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CryptoKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CryptoKitID", wireType)
			}
			m.CryptoKitID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CryptoKitID |= CryptoKitID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyBytes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KeyBytes = append(m.KeyBytes[:0], dAtA[iNdEx:postIndex]...)
			if m.KeyBytes == nil {
				m.KeyBytes = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CellHeader) 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 ErrIntOverflowAmp
			}
			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: CellHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CellHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subtitle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Subtitle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field About", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.About = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Glyphs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Glyphs = append(m.Glyphs, &AssetTag{})
			if err := m.Glyphs[len(m.Glyphs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Created", wireType)
			}
			m.Created = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Created |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Modified", wireType)
			}
			m.Modified = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Modified |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellURL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CellURL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalLink", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExternalLink == nil {
				m.ExternalLink = &AssetTag{}
			}
			if err := m.ExternalLink.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AuthToken) 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 ErrIntOverflowAmp
			}
			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: AuthToken: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AuthToken: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessToken", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessToken = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RefreshToken", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RefreshToken = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expiry", wireType)
			}
			m.Expiry = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Expiry |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TRS) 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 ErrIntOverflowAmp
			}
			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: TRS: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TRS: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 41:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field X1", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.X1 = float64(math.Float64frombits(v))
		case 42:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field X2", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.X2 = float64(math.Float64frombits(v))
		case 43:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field X3", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.X3 = float64(math.Float64frombits(v))
		case 50:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleMode", wireType)
			}
			m.ScaleMode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScaleMode |= TRS_VisualScaleMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 51:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scale1", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Scale1 = float32(math.Float32frombits(v))
		case 52:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scale2", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Scale2 = float32(math.Float32frombits(v))
		case 53:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scale3", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Scale3 = float32(math.Float32frombits(v))
		case 61:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rotate1", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rotate1 = float32(math.Float32frombits(v))
		case 62:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rotate2", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rotate2 = float32(math.Float32frombits(v))
		case 63:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rotate3", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rotate3 = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FeedParams) 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 ErrIntOverflowAmp
			}
			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: FeedParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FeedParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateIntervalMin", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UpdateIntervalMin = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateIntervalMax", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.UpdateIntervalMax = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataSegment) 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 ErrIntOverflowAmp
			}
			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: DataSegment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DataSegment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ByteOfs", wireType)
			}
			m.ByteOfs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ByteOfs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ByteSz", wireType)
			}
			m.ByteSz = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ByteSz |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InlineData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAmp
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InlineData = append(m.InlineData[:0], dAtA[iNdEx:postIndex]...)
			if m.InlineData == nil {
				m.InlineData = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamURI", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StreamURI = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlobID", wireType)
			}
			m.BlobID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlobID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Err) 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 ErrIntOverflowAmp
			}
			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: Err: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Err: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= ErrCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
			}
			m.Level = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Level |= LogLevel(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAmp
				}
				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 ErrInvalidLengthAmp
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAmp
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAmp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAmp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipAmp(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowAmp
			}
			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, ErrIntOverflowAmp
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowAmp
				}
				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, ErrInvalidLengthAmp
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupAmp
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthAmp
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthAmp        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAmp          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupAmp = fmt.Errorf("proto: unexpected end of group")
)