clientmessage.pb.go

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

package pb

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

import strconv "strconv"

import bytes "bytes"

import strings "strings"
import reflect "reflect"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type ClientMessageType int32

const (
	OUTBOUND_MESSAGE ClientMessageType = 0
	INBOUND_MESSAGE  ClientMessageType = 1
	RECEIPT          ClientMessageType = 2
)

var ClientMessageType_name = map[int32]string{
	0: "OUTBOUND_MESSAGE",
	1: "INBOUND_MESSAGE",
	2: "RECEIPT",
}
var ClientMessageType_value = map[string]int32{
	"OUTBOUND_MESSAGE": 0,
	"INBOUND_MESSAGE":  1,
	"RECEIPT":          2,
}

func (ClientMessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_clientmessage_19995f0679e9e3d6, []int{0}
}

type CompressionType int32

const (
	COMPRESSION_NONE CompressionType = 0
	COMPRESSION_ZLIB CompressionType = 1
)

var CompressionType_name = map[int32]string{
	0: "COMPRESSION_NONE",
	1: "COMPRESSION_ZLIB",
}
var CompressionType_value = map[string]int32{
	"COMPRESSION_NONE": 0,
	"COMPRESSION_ZLIB": 1,
}

func (CompressionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_clientmessage_19995f0679e9e3d6, []int{1}
}

type ClientMessage struct {
	MessageType     ClientMessageType `protobuf:"varint,1,opt,name=message_type,json=messageType,proto3,enum=pb.ClientMessageType" json:"message_type,omitempty"`
	Message         []byte            `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	CompressionType CompressionType   `protobuf:"varint,3,opt,name=compression_type,json=compressionType,proto3,enum=pb.CompressionType" json:"compression_type,omitempty"`
}

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

var xxx_messageInfo_ClientMessage proto.InternalMessageInfo

func (m *ClientMessage) GetMessageType() ClientMessageType {
	if m != nil {
		return m.MessageType
	}
	return OUTBOUND_MESSAGE
}

func (m *ClientMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *ClientMessage) GetCompressionType() CompressionType {
	if m != nil {
		return m.CompressionType
	}
	return COMPRESSION_NONE
}

type OutboundMessage struct {
	Dest              string   `protobuf:"bytes,1,opt,name=dest,proto3" json:"dest,omitempty"`
	Payload           []byte   `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	Dests             []string `protobuf:"bytes,3,rep,name=dests" json:"dests,omitempty"`
	MaxHoldingSeconds uint32   `protobuf:"varint,4,opt,name=max_holding_seconds,json=maxHoldingSeconds,proto3" json:"max_holding_seconds,omitempty"`
	Nonce             uint32   `protobuf:"varint,5,opt,name=nonce,proto3" json:"nonce,omitempty"`
	BlockHash         []byte   `protobuf:"bytes,6,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
	Signatures        [][]byte `protobuf:"bytes,7,rep,name=signatures" json:"signatures,omitempty"`
	Payloads          [][]byte `protobuf:"bytes,8,rep,name=payloads" json:"payloads,omitempty"`
}

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

var xxx_messageInfo_OutboundMessage proto.InternalMessageInfo

func (m *OutboundMessage) GetDest() string {
	if m != nil {
		return m.Dest
	}
	return ""
}

func (m *OutboundMessage) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *OutboundMessage) GetDests() []string {
	if m != nil {
		return m.Dests
	}
	return nil
}

func (m *OutboundMessage) GetMaxHoldingSeconds() uint32 {
	if m != nil {
		return m.MaxHoldingSeconds
	}
	return 0
}

func (m *OutboundMessage) GetNonce() uint32 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *OutboundMessage) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

func (m *OutboundMessage) GetSignatures() [][]byte {
	if m != nil {
		return m.Signatures
	}
	return nil
}

func (m *OutboundMessage) GetPayloads() [][]byte {
	if m != nil {
		return m.Payloads
	}
	return nil
}

type InboundMessage struct {
	Src           string `protobuf:"bytes,1,opt,name=src,proto3" json:"src,omitempty"`
	Payload       []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	PrevSignature []byte `protobuf:"bytes,3,opt,name=prev_signature,json=prevSignature,proto3" json:"prev_signature,omitempty"`
}

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

var xxx_messageInfo_InboundMessage proto.InternalMessageInfo

func (m *InboundMessage) GetSrc() string {
	if m != nil {
		return m.Src
	}
	return ""
}

func (m *InboundMessage) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *InboundMessage) GetPrevSignature() []byte {
	if m != nil {
		return m.PrevSignature
	}
	return nil
}

type Receipt struct {
	PrevSignature []byte `protobuf:"bytes,1,opt,name=prev_signature,json=prevSignature,proto3" json:"prev_signature,omitempty"`
	Signature     []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
}

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

var xxx_messageInfo_Receipt proto.InternalMessageInfo

func (m *Receipt) GetPrevSignature() []byte {
	if m != nil {
		return m.PrevSignature
	}
	return nil
}

func (m *Receipt) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func init() {
	proto.RegisterType((*ClientMessage)(nil), "pb.ClientMessage")
	proto.RegisterType((*OutboundMessage)(nil), "pb.OutboundMessage")
	proto.RegisterType((*InboundMessage)(nil), "pb.InboundMessage")
	proto.RegisterType((*Receipt)(nil), "pb.Receipt")
	proto.RegisterEnum("pb.ClientMessageType", ClientMessageType_name, ClientMessageType_value)
	proto.RegisterEnum("pb.CompressionType", CompressionType_name, CompressionType_value)
}
func (x ClientMessageType) String() string {
	s, ok := ClientMessageType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x CompressionType) String() string {
	s, ok := CompressionType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *ClientMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ClientMessage)
	if !ok {
		that2, ok := that.(ClientMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MessageType != that1.MessageType {
		return false
	}
	if !bytes.Equal(this.Message, that1.Message) {
		return false
	}
	if this.CompressionType != that1.CompressionType {
		return false
	}
	return true
}
func (this *OutboundMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OutboundMessage)
	if !ok {
		that2, ok := that.(OutboundMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Dest != that1.Dest {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if len(this.Dests) != len(that1.Dests) {
		return false
	}
	for i := range this.Dests {
		if this.Dests[i] != that1.Dests[i] {
			return false
		}
	}
	if this.MaxHoldingSeconds != that1.MaxHoldingSeconds {
		return false
	}
	if this.Nonce != that1.Nonce {
		return false
	}
	if !bytes.Equal(this.BlockHash, that1.BlockHash) {
		return false
	}
	if len(this.Signatures) != len(that1.Signatures) {
		return false
	}
	for i := range this.Signatures {
		if !bytes.Equal(this.Signatures[i], that1.Signatures[i]) {
			return false
		}
	}
	if len(this.Payloads) != len(that1.Payloads) {
		return false
	}
	for i := range this.Payloads {
		if !bytes.Equal(this.Payloads[i], that1.Payloads[i]) {
			return false
		}
	}
	return true
}
func (this *InboundMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*InboundMessage)
	if !ok {
		that2, ok := that.(InboundMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Src != that1.Src {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if !bytes.Equal(this.PrevSignature, that1.PrevSignature) {
		return false
	}
	return true
}
func (this *Receipt) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Receipt)
	if !ok {
		that2, ok := that.(Receipt)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.PrevSignature, that1.PrevSignature) {
		return false
	}
	if !bytes.Equal(this.Signature, that1.Signature) {
		return false
	}
	return true
}
func (this *ClientMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&pb.ClientMessage{")
	s = append(s, "MessageType: "+fmt.Sprintf("%#v", this.MessageType)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "CompressionType: "+fmt.Sprintf("%#v", this.CompressionType)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *OutboundMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&pb.OutboundMessage{")
	s = append(s, "Dest: "+fmt.Sprintf("%#v", this.Dest)+",\n")
	s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
	s = append(s, "Dests: "+fmt.Sprintf("%#v", this.Dests)+",\n")
	s = append(s, "MaxHoldingSeconds: "+fmt.Sprintf("%#v", this.MaxHoldingSeconds)+",\n")
	s = append(s, "Nonce: "+fmt.Sprintf("%#v", this.Nonce)+",\n")
	s = append(s, "BlockHash: "+fmt.Sprintf("%#v", this.BlockHash)+",\n")
	s = append(s, "Signatures: "+fmt.Sprintf("%#v", this.Signatures)+",\n")
	s = append(s, "Payloads: "+fmt.Sprintf("%#v", this.Payloads)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *InboundMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&pb.InboundMessage{")
	s = append(s, "Src: "+fmt.Sprintf("%#v", this.Src)+",\n")
	s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
	s = append(s, "PrevSignature: "+fmt.Sprintf("%#v", this.PrevSignature)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Receipt) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.Receipt{")
	s = append(s, "PrevSignature: "+fmt.Sprintf("%#v", this.PrevSignature)+",\n")
	s = append(s, "Signature: "+fmt.Sprintf("%#v", this.Signature)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringClientmessage(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 *ClientMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ClientMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.MessageType != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(m.MessageType))
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	if m.CompressionType != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(m.CompressionType))
	}
	return i, nil
}

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

func (m *OutboundMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Dest) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(len(m.Dest)))
		i += copy(dAtA[i:], m.Dest)
	}
	if len(m.Payload) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(len(m.Payload)))
		i += copy(dAtA[i:], m.Payload)
	}
	if len(m.Dests) > 0 {
		for _, s := range m.Dests {
			dAtA[i] = 0x1a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.MaxHoldingSeconds != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(m.MaxHoldingSeconds))
	}
	if m.Nonce != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(m.Nonce))
	}
	if len(m.BlockHash) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(len(m.BlockHash)))
		i += copy(dAtA[i:], m.BlockHash)
	}
	if len(m.Signatures) > 0 {
		for _, b := range m.Signatures {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintClientmessage(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	if len(m.Payloads) > 0 {
		for _, b := range m.Payloads {
			dAtA[i] = 0x42
			i++
			i = encodeVarintClientmessage(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	return i, nil
}

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

func (m *InboundMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Src) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(len(m.Src)))
		i += copy(dAtA[i:], m.Src)
	}
	if len(m.Payload) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(len(m.Payload)))
		i += copy(dAtA[i:], m.Payload)
	}
	if len(m.PrevSignature) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(len(m.PrevSignature)))
		i += copy(dAtA[i:], m.PrevSignature)
	}
	return i, nil
}

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

func (m *Receipt) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PrevSignature) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(len(m.PrevSignature)))
		i += copy(dAtA[i:], m.PrevSignature)
	}
	if len(m.Signature) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintClientmessage(dAtA, i, uint64(len(m.Signature)))
		i += copy(dAtA[i:], m.Signature)
	}
	return i, nil
}

func encodeVarintClientmessage(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func NewPopulatedClientMessage(r randyClientmessage, easy bool) *ClientMessage {
	this := &ClientMessage{}
	this.MessageType = ClientMessageType([]int32{0, 1, 2}[r.Intn(3)])
	v1 := r.Intn(100)
	this.Message = make([]byte, v1)
	for i := 0; i < v1; i++ {
		this.Message[i] = byte(r.Intn(256))
	}
	this.CompressionType = CompressionType([]int32{0, 1}[r.Intn(2)])
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedOutboundMessage(r randyClientmessage, easy bool) *OutboundMessage {
	this := &OutboundMessage{}
	this.Dest = string(randStringClientmessage(r))
	v2 := r.Intn(100)
	this.Payload = make([]byte, v2)
	for i := 0; i < v2; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	v3 := r.Intn(10)
	this.Dests = make([]string, v3)
	for i := 0; i < v3; i++ {
		this.Dests[i] = string(randStringClientmessage(r))
	}
	this.MaxHoldingSeconds = uint32(r.Uint32())
	this.Nonce = uint32(r.Uint32())
	v4 := r.Intn(100)
	this.BlockHash = make([]byte, v4)
	for i := 0; i < v4; i++ {
		this.BlockHash[i] = byte(r.Intn(256))
	}
	v5 := r.Intn(10)
	this.Signatures = make([][]byte, v5)
	for i := 0; i < v5; i++ {
		v6 := r.Intn(100)
		this.Signatures[i] = make([]byte, v6)
		for j := 0; j < v6; j++ {
			this.Signatures[i][j] = byte(r.Intn(256))
		}
	}
	v7 := r.Intn(10)
	this.Payloads = make([][]byte, v7)
	for i := 0; i < v7; i++ {
		v8 := r.Intn(100)
		this.Payloads[i] = make([]byte, v8)
		for j := 0; j < v8; j++ {
			this.Payloads[i][j] = byte(r.Intn(256))
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedInboundMessage(r randyClientmessage, easy bool) *InboundMessage {
	this := &InboundMessage{}
	this.Src = string(randStringClientmessage(r))
	v9 := r.Intn(100)
	this.Payload = make([]byte, v9)
	for i := 0; i < v9; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	v10 := r.Intn(100)
	this.PrevSignature = make([]byte, v10)
	for i := 0; i < v10; i++ {
		this.PrevSignature[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedReceipt(r randyClientmessage, easy bool) *Receipt {
	this := &Receipt{}
	v11 := r.Intn(100)
	this.PrevSignature = make([]byte, v11)
	for i := 0; i < v11; i++ {
		this.PrevSignature[i] = byte(r.Intn(256))
	}
	v12 := r.Intn(100)
	this.Signature = make([]byte, v12)
	for i := 0; i < v12; i++ {
		this.Signature[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyClientmessage interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneClientmessage(r randyClientmessage) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringClientmessage(r randyClientmessage) string {
	v13 := r.Intn(100)
	tmps := make([]rune, v13)
	for i := 0; i < v13; i++ {
		tmps[i] = randUTF8RuneClientmessage(r)
	}
	return string(tmps)
}
func randUnrecognizedClientmessage(r randyClientmessage, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldClientmessage(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldClientmessage(dAtA []byte, r randyClientmessage, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateClientmessage(dAtA, uint64(key))
		v14 := r.Int63()
		if r.Intn(2) == 0 {
			v14 *= -1
		}
		dAtA = encodeVarintPopulateClientmessage(dAtA, uint64(v14))
	case 1:
		dAtA = encodeVarintPopulateClientmessage(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateClientmessage(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateClientmessage(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateClientmessage(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateClientmessage(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *ClientMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MessageType != 0 {
		n += 1 + sovClientmessage(uint64(m.MessageType))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovClientmessage(uint64(l))
	}
	if m.CompressionType != 0 {
		n += 1 + sovClientmessage(uint64(m.CompressionType))
	}
	return n
}

func (m *OutboundMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Dest)
	if l > 0 {
		n += 1 + l + sovClientmessage(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovClientmessage(uint64(l))
	}
	if len(m.Dests) > 0 {
		for _, s := range m.Dests {
			l = len(s)
			n += 1 + l + sovClientmessage(uint64(l))
		}
	}
	if m.MaxHoldingSeconds != 0 {
		n += 1 + sovClientmessage(uint64(m.MaxHoldingSeconds))
	}
	if m.Nonce != 0 {
		n += 1 + sovClientmessage(uint64(m.Nonce))
	}
	l = len(m.BlockHash)
	if l > 0 {
		n += 1 + l + sovClientmessage(uint64(l))
	}
	if len(m.Signatures) > 0 {
		for _, b := range m.Signatures {
			l = len(b)
			n += 1 + l + sovClientmessage(uint64(l))
		}
	}
	if len(m.Payloads) > 0 {
		for _, b := range m.Payloads {
			l = len(b)
			n += 1 + l + sovClientmessage(uint64(l))
		}
	}
	return n
}

func (m *InboundMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Src)
	if l > 0 {
		n += 1 + l + sovClientmessage(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovClientmessage(uint64(l))
	}
	l = len(m.PrevSignature)
	if l > 0 {
		n += 1 + l + sovClientmessage(uint64(l))
	}
	return n
}

func (m *Receipt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PrevSignature)
	if l > 0 {
		n += 1 + l + sovClientmessage(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovClientmessage(uint64(l))
	}
	return n
}

func sovClientmessage(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozClientmessage(x uint64) (n int) {
	return sovClientmessage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *ClientMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ClientMessage{`,
		`MessageType:` + fmt.Sprintf("%v", this.MessageType) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`CompressionType:` + fmt.Sprintf("%v", this.CompressionType) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OutboundMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OutboundMessage{`,
		`Dest:` + fmt.Sprintf("%v", this.Dest) + `,`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Dests:` + fmt.Sprintf("%v", this.Dests) + `,`,
		`MaxHoldingSeconds:` + fmt.Sprintf("%v", this.MaxHoldingSeconds) + `,`,
		`Nonce:` + fmt.Sprintf("%v", this.Nonce) + `,`,
		`BlockHash:` + fmt.Sprintf("%v", this.BlockHash) + `,`,
		`Signatures:` + fmt.Sprintf("%v", this.Signatures) + `,`,
		`Payloads:` + fmt.Sprintf("%v", this.Payloads) + `,`,
		`}`,
	}, "")
	return s
}
func (this *InboundMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&InboundMessage{`,
		`Src:` + fmt.Sprintf("%v", this.Src) + `,`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`PrevSignature:` + fmt.Sprintf("%v", this.PrevSignature) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Receipt) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Receipt{`,
		`PrevSignature:` + fmt.Sprintf("%v", this.PrevSignature) + `,`,
		`Signature:` + fmt.Sprintf("%v", this.Signature) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringClientmessage(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *ClientMessage) 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 ErrIntOverflowClientmessage
			}
			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: ClientMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClientMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageType", wireType)
			}
			m.MessageType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MessageType |= (ClientMessageType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClientmessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = append(m.Message[:0], dAtA[iNdEx:postIndex]...)
			if m.Message == nil {
				m.Message = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompressionType", wireType)
			}
			m.CompressionType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompressionType |= (CompressionType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipClientmessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthClientmessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutboundMessage) 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 ErrIntOverflowClientmessage
			}
			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: OutboundMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutboundMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dest", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				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 ErrInvalidLengthClientmessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dest = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClientmessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dests", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				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 ErrInvalidLengthClientmessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dests = append(m.Dests, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxHoldingSeconds", wireType)
			}
			m.MaxHoldingSeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxHoldingSeconds |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			m.Nonce = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Nonce |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClientmessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockHash = append(m.BlockHash[:0], dAtA[iNdEx:postIndex]...)
			if m.BlockHash == nil {
				m.BlockHash = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClientmessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signatures = append(m.Signatures, make([]byte, postIndex-iNdEx))
			copy(m.Signatures[len(m.Signatures)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payloads", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowClientmessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthClientmessage
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payloads = append(m.Payloads, make([]byte, postIndex-iNdEx))
			copy(m.Payloads[len(m.Payloads)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipClientmessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthClientmessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

func init() {
	proto.RegisterFile("pb/clientmessage.proto", fileDescriptor_clientmessage_19995f0679e9e3d6)
}

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