dqpbft.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: protocols/dqpbft/dqpbftpb/dqpbft.proto

package dqpbftpb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_ibalajiarun_go_consensus_peer_peerpb "github.com/ibalajiarun/go-consensus/peer/peerpb"
	commandpb "github.com/ibalajiarun/go-consensus/pkg/command/commandpb"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type InstanceState_Status int32

const (
	InstanceState_None        InstanceState_Status = 0
	InstanceState_PrePrepared InstanceState_Status = 1
	InstanceState_Prepared    InstanceState_Status = 2
	InstanceState_Committed   InstanceState_Status = 3
	InstanceState_Executed    InstanceState_Status = 4
)

var InstanceState_Status_name = map[int32]string{
	0: "None",
	1: "PrePrepared",
	2: "Prepared",
	3: "Committed",
	4: "Executed",
}

var InstanceState_Status_value = map[string]int32{
	"None":        0,
	"PrePrepared": 1,
	"Prepared":    2,
	"Committed":   3,
	"Executed":    4,
}

func (x InstanceState_Status) String() string {
	return proto.EnumName(InstanceState_Status_name, int32(x))
}

func (InstanceState_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{2, 0}
}

type AgreementMessage_Type int32

const (
	AgreementMessage_PrePrepare AgreementMessage_Type = 0
	AgreementMessage_Prepare    AgreementMessage_Type = 1
	AgreementMessage_Commit     AgreementMessage_Type = 2
)

var AgreementMessage_Type_name = map[int32]string{
	0: "PrePrepare",
	1: "Prepare",
	2: "Commit",
}

var AgreementMessage_Type_value = map[string]int32{
	"PrePrepare": 0,
	"Prepare":    1,
	"Commit":     2,
}

func (x AgreementMessage_Type) String() string {
	return proto.EnumName(AgreementMessage_Type_name, int32(x))
}

func (AgreementMessage_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{3, 0}
}

type OInstanceState_Status int32

const (
	OInstanceState_None         OInstanceState_Status = 0
	OInstanceState_OPrePrepared OInstanceState_Status = 1
	OInstanceState_OPrepared    OInstanceState_Status = 2
	OInstanceState_OCommitted   OInstanceState_Status = 3
	OInstanceState_OExecuted    OInstanceState_Status = 4
)

var OInstanceState_Status_name = map[int32]string{
	0: "None",
	1: "OPrePrepared",
	2: "OPrepared",
	3: "OCommitted",
	4: "OExecuted",
}

var OInstanceState_Status_value = map[string]int32{
	"None":         0,
	"OPrePrepared": 1,
	"OPrepared":    2,
	"OCommitted":   3,
	"OExecuted":    4,
}

func (x OInstanceState_Status) String() string {
	return proto.EnumName(OInstanceState_Status_name, int32(x))
}

func (OInstanceState_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{4, 0}
}

type OAgreementMessage_Type int32

const (
	OAgreementMessage_OPrePrepare OAgreementMessage_Type = 0
	OAgreementMessage_OPrepare    OAgreementMessage_Type = 1
	OAgreementMessage_OCommit     OAgreementMessage_Type = 2
)

var OAgreementMessage_Type_name = map[int32]string{
	0: "OPrePrepare",
	1: "OPrepare",
	2: "OCommit",
}

var OAgreementMessage_Type_value = map[string]int32{
	"OPrePrepare": 0,
	"OPrepare":    1,
	"OCommit":     2,
}

func (x OAgreementMessage_Type) String() string {
	return proto.EnumName(OAgreementMessage_Type_name, int32(x))
}

func (OAgreementMessage_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{5, 0}
}

type DQPBFTMessage struct {
	// Types that are valid to be assigned to Type:
	//	*DQPBFTMessage_Agreement
	//	*DQPBFTMessage_OAgreement
	Type isDQPBFTMessage_Type `protobuf_oneof:"type"`
}

func (m *DQPBFTMessage) Reset()         { *m = DQPBFTMessage{} }
func (m *DQPBFTMessage) String() string { return proto.CompactTextString(m) }
func (*DQPBFTMessage) ProtoMessage()    {}
func (*DQPBFTMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{0}
}
func (m *DQPBFTMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DQPBFTMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DQPBFTMessage.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 *DQPBFTMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DQPBFTMessage.Merge(m, src)
}
func (m *DQPBFTMessage) XXX_Size() int {
	return m.Size()
}
func (m *DQPBFTMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_DQPBFTMessage.DiscardUnknown(m)
}

var xxx_messageInfo_DQPBFTMessage proto.InternalMessageInfo

type isDQPBFTMessage_Type interface {
	isDQPBFTMessage_Type()
	MarshalTo([]byte) (int, error)
	Size() int
}

type DQPBFTMessage_Agreement struct {
	Agreement *AgreementMessage `protobuf:"bytes,1,opt,name=agreement,proto3,oneof" json:"agreement,omitempty"`
}
type DQPBFTMessage_OAgreement struct {
	OAgreement *OAgreementMessage `protobuf:"bytes,2,opt,name=o_agreement,json=oAgreement,proto3,oneof" json:"o_agreement,omitempty"`
}

func (*DQPBFTMessage_Agreement) isDQPBFTMessage_Type()  {}
func (*DQPBFTMessage_OAgreement) isDQPBFTMessage_Type() {}

func (m *DQPBFTMessage) GetType() isDQPBFTMessage_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *DQPBFTMessage) GetAgreement() *AgreementMessage {
	if x, ok := m.GetType().(*DQPBFTMessage_Agreement); ok {
		return x.Agreement
	}
	return nil
}

func (m *DQPBFTMessage) GetOAgreement() *OAgreementMessage {
	if x, ok := m.GetType().(*DQPBFTMessage_OAgreement); ok {
		return x.OAgreement
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*DQPBFTMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*DQPBFTMessage_Agreement)(nil),
		(*DQPBFTMessage_OAgreement)(nil),
	}
}

type InstanceID struct {
	ReplicaID github_com_ibalajiarun_go_consensus_peer_peerpb.PeerID `protobuf:"varint,1,opt,name=replica_id,json=replicaId,proto3,casttype=github.com/ibalajiarun/go-consensus/peer/peerpb.PeerID" json:"replica_id,omitempty"`
	Index     Index                                                  `protobuf:"varint,2,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
}

func (m *InstanceID) Reset()         { *m = InstanceID{} }
func (m *InstanceID) String() string { return proto.CompactTextString(m) }
func (*InstanceID) ProtoMessage()    {}
func (*InstanceID) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{1}
}
func (m *InstanceID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InstanceID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InstanceID.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 *InstanceID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InstanceID.Merge(m, src)
}
func (m *InstanceID) XXX_Size() int {
	return m.Size()
}
func (m *InstanceID) XXX_DiscardUnknown() {
	xxx_messageInfo_InstanceID.DiscardUnknown(m)
}

var xxx_messageInfo_InstanceID proto.InternalMessageInfo

func (m *InstanceID) GetReplicaID() github_com_ibalajiarun_go_consensus_peer_peerpb.PeerID {
	if m != nil {
		return m.ReplicaID
	}
	return 0
}

func (m *InstanceID) GetIndex() Index {
	if m != nil {
		return m.Index
	}
	return 0
}

type InstanceState struct {
	View        View                 `protobuf:"varint,1,opt,name=view,proto3,casttype=View" json:"view,omitempty"`
	InstanceID  InstanceID           `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id"`
	Status      InstanceState_Status `protobuf:"varint,3,opt,name=status,proto3,enum=dqpbftpb.InstanceState_Status" json:"status,omitempty"`
	Command     *commandpb.Command   `protobuf:"bytes,4,opt,name=command,proto3" json:"command,omitempty"`
	CommandHash []byte               `protobuf:"bytes,5,opt,name=command_hash,json=commandHash,proto3" json:"command_hash,omitempty"`
}

func (m *InstanceState) Reset()         { *m = InstanceState{} }
func (m *InstanceState) String() string { return proto.CompactTextString(m) }
func (*InstanceState) ProtoMessage()    {}
func (*InstanceState) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{2}
}
func (m *InstanceState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InstanceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InstanceState.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 *InstanceState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InstanceState.Merge(m, src)
}
func (m *InstanceState) XXX_Size() int {
	return m.Size()
}
func (m *InstanceState) XXX_DiscardUnknown() {
	xxx_messageInfo_InstanceState.DiscardUnknown(m)
}

var xxx_messageInfo_InstanceState proto.InternalMessageInfo

func (m *InstanceState) GetView() View {
	if m != nil {
		return m.View
	}
	return 0
}

func (m *InstanceState) GetInstanceID() InstanceID {
	if m != nil {
		return m.InstanceID
	}
	return InstanceID{}
}

func (m *InstanceState) GetStatus() InstanceState_Status {
	if m != nil {
		return m.Status
	}
	return InstanceState_None
}

func (m *InstanceState) GetCommand() *commandpb.Command {
	if m != nil {
		return m.Command
	}
	return nil
}

func (m *InstanceState) GetCommandHash() []byte {
	if m != nil {
		return m.CommandHash
	}
	return nil
}

type AgreementMessage struct {
	View        View                  `protobuf:"varint,1,opt,name=view,proto3,casttype=View" json:"view,omitempty"`
	InstanceID  InstanceID            `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id"`
	Type        AgreementMessage_Type `protobuf:"varint,3,opt,name=type,proto3,enum=dqpbftpb.AgreementMessage_Type" json:"type,omitempty"`
	Command     *commandpb.Command    `protobuf:"bytes,4,opt,name=command,proto3" json:"command,omitempty"`
	CommandHash []byte                `protobuf:"bytes,5,opt,name=command_hash,json=commandHash,proto3" json:"command_hash,omitempty"`
}

func (m *AgreementMessage) Reset()         { *m = AgreementMessage{} }
func (m *AgreementMessage) String() string { return proto.CompactTextString(m) }
func (*AgreementMessage) ProtoMessage()    {}
func (*AgreementMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{3}
}
func (m *AgreementMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgreementMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgreementMessage.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 *AgreementMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgreementMessage.Merge(m, src)
}
func (m *AgreementMessage) XXX_Size() int {
	return m.Size()
}
func (m *AgreementMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_AgreementMessage.DiscardUnknown(m)
}

var xxx_messageInfo_AgreementMessage proto.InternalMessageInfo

func (m *AgreementMessage) GetView() View {
	if m != nil {
		return m.View
	}
	return 0
}

func (m *AgreementMessage) GetInstanceID() InstanceID {
	if m != nil {
		return m.InstanceID
	}
	return InstanceID{}
}

func (m *AgreementMessage) GetType() AgreementMessage_Type {
	if m != nil {
		return m.Type
	}
	return AgreementMessage_PrePrepare
}

func (m *AgreementMessage) GetCommand() *commandpb.Command {
	if m != nil {
		return m.Command
	}
	return nil
}

func (m *AgreementMessage) GetCommandHash() []byte {
	if m != nil {
		return m.CommandHash
	}
	return nil
}

type OInstanceState struct {
	View        View                  `protobuf:"varint,1,opt,name=view,proto3,casttype=View" json:"view,omitempty"`
	Index       Index                 `protobuf:"varint,2,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	Status      OInstanceState_Status `protobuf:"varint,3,opt,name=status,proto3,enum=dqpbftpb.OInstanceState_Status" json:"status,omitempty"`
	Instances   []InstanceID          `protobuf:"bytes,4,rep,name=instances,proto3" json:"instances"`
	CommandHash []byte                `protobuf:"bytes,5,opt,name=command_hash,json=commandHash,proto3" json:"command_hash,omitempty"`
}

func (m *OInstanceState) Reset()         { *m = OInstanceState{} }
func (m *OInstanceState) String() string { return proto.CompactTextString(m) }
func (*OInstanceState) ProtoMessage()    {}
func (*OInstanceState) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{4}
}
func (m *OInstanceState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OInstanceState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OInstanceState.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 *OInstanceState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OInstanceState.Merge(m, src)
}
func (m *OInstanceState) XXX_Size() int {
	return m.Size()
}
func (m *OInstanceState) XXX_DiscardUnknown() {
	xxx_messageInfo_OInstanceState.DiscardUnknown(m)
}

var xxx_messageInfo_OInstanceState proto.InternalMessageInfo

func (m *OInstanceState) GetView() View {
	if m != nil {
		return m.View
	}
	return 0
}

func (m *OInstanceState) GetIndex() Index {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *OInstanceState) GetStatus() OInstanceState_Status {
	if m != nil {
		return m.Status
	}
	return OInstanceState_None
}

func (m *OInstanceState) GetInstances() []InstanceID {
	if m != nil {
		return m.Instances
	}
	return nil
}

func (m *OInstanceState) GetCommandHash() []byte {
	if m != nil {
		return m.CommandHash
	}
	return nil
}

type OAgreementMessage struct {
	View        View                   `protobuf:"varint,1,opt,name=view,proto3,casttype=View" json:"view,omitempty"`
	Index       Index                  `protobuf:"varint,2,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	Type        OAgreementMessage_Type `protobuf:"varint,3,opt,name=type,proto3,enum=dqpbftpb.OAgreementMessage_Type" json:"type,omitempty"`
	Instances   []InstanceID           `protobuf:"bytes,4,rep,name=instances,proto3" json:"instances"`
	CommandHash []byte                 `protobuf:"bytes,5,opt,name=command_hash,json=commandHash,proto3" json:"command_hash,omitempty"`
}

func (m *OAgreementMessage) Reset()         { *m = OAgreementMessage{} }
func (m *OAgreementMessage) String() string { return proto.CompactTextString(m) }
func (*OAgreementMessage) ProtoMessage()    {}
func (*OAgreementMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_c9d055c519e0129a, []int{5}
}
func (m *OAgreementMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OAgreementMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OAgreementMessage.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 *OAgreementMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OAgreementMessage.Merge(m, src)
}
func (m *OAgreementMessage) XXX_Size() int {
	return m.Size()
}
func (m *OAgreementMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_OAgreementMessage.DiscardUnknown(m)
}

var xxx_messageInfo_OAgreementMessage proto.InternalMessageInfo

func (m *OAgreementMessage) GetView() View {
	if m != nil {
		return m.View
	}
	return 0
}

func (m *OAgreementMessage) GetIndex() Index {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *OAgreementMessage) GetType() OAgreementMessage_Type {
	if m != nil {
		return m.Type
	}
	return OAgreementMessage_OPrePrepare
}

func (m *OAgreementMessage) GetInstances() []InstanceID {
	if m != nil {
		return m.Instances
	}
	return nil
}

func (m *OAgreementMessage) GetCommandHash() []byte {
	if m != nil {
		return m.CommandHash
	}
	return nil
}

func init() {
	proto.RegisterEnum("dqpbftpb.InstanceState_Status", InstanceState_Status_name, InstanceState_Status_value)
	proto.RegisterEnum("dqpbftpb.AgreementMessage_Type", AgreementMessage_Type_name, AgreementMessage_Type_value)
	proto.RegisterEnum("dqpbftpb.OInstanceState_Status", OInstanceState_Status_name, OInstanceState_Status_value)
	proto.RegisterEnum("dqpbftpb.OAgreementMessage_Type", OAgreementMessage_Type_name, OAgreementMessage_Type_value)
	proto.RegisterType((*DQPBFTMessage)(nil), "dqpbftpb.DQPBFTMessage")
	proto.RegisterType((*InstanceID)(nil), "dqpbftpb.InstanceID")
	proto.RegisterType((*InstanceState)(nil), "dqpbftpb.InstanceState")
	proto.RegisterType((*AgreementMessage)(nil), "dqpbftpb.AgreementMessage")
	proto.RegisterType((*OInstanceState)(nil), "dqpbftpb.OInstanceState")
	proto.RegisterType((*OAgreementMessage)(nil), "dqpbftpb.OAgreementMessage")
}

func init() {
	proto.RegisterFile("protocols/dqpbft/dqpbftpb/dqpbft.proto", fileDescriptor_c9d055c519e0129a)
}

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

func (m *DQPBFTMessage) 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 *DQPBFTMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DQPBFTMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		{
			size := m.Type.Size()
			i -= size
			if _, err := m.Type.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *DQPBFTMessage_Agreement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Agreement != nil {
		{
			size, err := m.Agreement.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDqpbft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *DQPBFTMessage_OAgreement) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DQPBFTMessage_OAgreement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.OAgreement != nil {
		{
			size, err := m.OAgreement.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDqpbft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *InstanceID) 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 *InstanceID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InstanceID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if m.ReplicaID != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.ReplicaID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *InstanceState) 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 *InstanceState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InstanceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CommandHash) > 0 {
		i -= len(m.CommandHash)
		copy(dAtA[i:], m.CommandHash)
		i = encodeVarintDqpbft(dAtA, i, uint64(len(m.CommandHash)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Command != nil {
		{
			size, err := m.Command.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDqpbft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Status != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.InstanceID.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintDqpbft(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.View != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.View))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AgreementMessage) 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 *AgreementMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgreementMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CommandHash) > 0 {
		i -= len(m.CommandHash)
		copy(dAtA[i:], m.CommandHash)
		i = encodeVarintDqpbft(dAtA, i, uint64(len(m.CommandHash)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Command != nil {
		{
			size, err := m.Command.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDqpbft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Type != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.InstanceID.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintDqpbft(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.View != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.View))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *OInstanceState) 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 *OInstanceState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OInstanceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CommandHash) > 0 {
		i -= len(m.CommandHash)
		copy(dAtA[i:], m.CommandHash)
		i = encodeVarintDqpbft(dAtA, i, uint64(len(m.CommandHash)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Instances) > 0 {
		for iNdEx := len(m.Instances) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Instances[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDqpbft(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Status != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x18
	}
	if m.Index != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if m.View != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.View))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *OAgreementMessage) 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 *OAgreementMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OAgreementMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CommandHash) > 0 {
		i -= len(m.CommandHash)
		copy(dAtA[i:], m.CommandHash)
		i = encodeVarintDqpbft(dAtA, i, uint64(len(m.CommandHash)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Instances) > 0 {
		for iNdEx := len(m.Instances) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Instances[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDqpbft(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Type != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x18
	}
	if m.Index != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if m.View != 0 {
		i = encodeVarintDqpbft(dAtA, i, uint64(m.View))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintDqpbft(dAtA []byte, offset int, v uint64) int {
	offset -= sovDqpbft(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DQPBFTMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != nil {
		n += m.Type.Size()
	}
	return n
}

func (m *DQPBFTMessage_Agreement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Agreement != nil {
		l = m.Agreement.Size()
		n += 1 + l + sovDqpbft(uint64(l))
	}
	return n
}
func (m *DQPBFTMessage_OAgreement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OAgreement != nil {
		l = m.OAgreement.Size()
		n += 1 + l + sovDqpbft(uint64(l))
	}
	return n
}
func (m *InstanceID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReplicaID != 0 {
		n += 1 + sovDqpbft(uint64(m.ReplicaID))
	}
	if m.Index != 0 {
		n += 1 + sovDqpbft(uint64(m.Index))
	}
	return n
}

func (m *InstanceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.View != 0 {
		n += 1 + sovDqpbft(uint64(m.View))
	}
	l = m.InstanceID.Size()
	n += 1 + l + sovDqpbft(uint64(l))
	if m.Status != 0 {
		n += 1 + sovDqpbft(uint64(m.Status))
	}
	if m.Command != nil {
		l = m.Command.Size()
		n += 1 + l + sovDqpbft(uint64(l))
	}
	l = len(m.CommandHash)
	if l > 0 {
		n += 1 + l + sovDqpbft(uint64(l))
	}
	return n
}

func (m *AgreementMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.View != 0 {
		n += 1 + sovDqpbft(uint64(m.View))
	}
	l = m.InstanceID.Size()
	n += 1 + l + sovDqpbft(uint64(l))
	if m.Type != 0 {
		n += 1 + sovDqpbft(uint64(m.Type))
	}
	if m.Command != nil {
		l = m.Command.Size()
		n += 1 + l + sovDqpbft(uint64(l))
	}
	l = len(m.CommandHash)
	if l > 0 {
		n += 1 + l + sovDqpbft(uint64(l))
	}
	return n
}

func (m *OInstanceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.View != 0 {
		n += 1 + sovDqpbft(uint64(m.View))
	}
	if m.Index != 0 {
		n += 1 + sovDqpbft(uint64(m.Index))
	}
	if m.Status != 0 {
		n += 1 + sovDqpbft(uint64(m.Status))
	}
	if len(m.Instances) > 0 {
		for _, e := range m.Instances {
			l = e.Size()
			n += 1 + l + sovDqpbft(uint64(l))
		}
	}
	l = len(m.CommandHash)
	if l > 0 {
		n += 1 + l + sovDqpbft(uint64(l))
	}
	return n
}

func (m *OAgreementMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.View != 0 {
		n += 1 + sovDqpbft(uint64(m.View))
	}
	if m.Index != 0 {
		n += 1 + sovDqpbft(uint64(m.Index))
	}
	if m.Type != 0 {
		n += 1 + sovDqpbft(uint64(m.Type))
	}
	if len(m.Instances) > 0 {
		for _, e := range m.Instances {
			l = e.Size()
			n += 1 + l + sovDqpbft(uint64(l))
		}
	}
	l = len(m.CommandHash)
	if l > 0 {
		n += 1 + l + sovDqpbft(uint64(l))
	}
	return n
}

func sovDqpbft(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDqpbft(x uint64) (n int) {
	return sovDqpbft(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DQPBFTMessage) 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 ErrIntOverflowDqpbft
			}
			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: DQPBFTMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DQPBFTMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Agreement", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AgreementMessage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Type = &DQPBFTMessage_Agreement{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OAgreement", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OAgreementMessage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Type = &DQPBFTMessage_OAgreement{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDqpbft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InstanceID) 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 ErrIntOverflowDqpbft
			}
			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: InstanceID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InstanceID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaID", wireType)
			}
			m.ReplicaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReplicaID |= github_com_ibalajiarun_go_consensus_peer_peerpb.PeerID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDqpbft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InstanceState) 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 ErrIntOverflowDqpbft
			}
			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: InstanceState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InstanceState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field View", wireType)
			}
			m.View = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.View |= View(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.InstanceID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= InstanceState_Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Command", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Command == nil {
				m.Command = &commandpb.Command{}
			}
			if err := m.Command.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommandHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CommandHash = append(m.CommandHash[:0], dAtA[iNdEx:postIndex]...)
			if m.CommandHash == nil {
				m.CommandHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDqpbft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgreementMessage) 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 ErrIntOverflowDqpbft
			}
			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: AgreementMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgreementMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field View", wireType)
			}
			m.View = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.View |= View(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.InstanceID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= AgreementMessage_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Command", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Command == nil {
				m.Command = &commandpb.Command{}
			}
			if err := m.Command.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommandHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CommandHash = append(m.CommandHash[:0], dAtA[iNdEx:postIndex]...)
			if m.CommandHash == nil {
				m.CommandHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDqpbft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OInstanceState) 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 ErrIntOverflowDqpbft
			}
			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: OInstanceState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OInstanceState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field View", wireType)
			}
			m.View = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.View |= View(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= OInstanceState_Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Instances", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Instances = append(m.Instances, InstanceID{})
			if err := m.Instances[len(m.Instances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommandHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CommandHash = append(m.CommandHash[:0], dAtA[iNdEx:postIndex]...)
			if m.CommandHash == nil {
				m.CommandHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDqpbft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OAgreementMessage) 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 ErrIntOverflowDqpbft
			}
			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: OAgreementMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OAgreementMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field View", wireType)
			}
			m.View = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.View |= View(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= OAgreementMessage_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Instances", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Instances = append(m.Instances, InstanceID{})
			if err := m.Instances[len(m.Instances)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommandHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDqpbft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDqpbft
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDqpbft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CommandHash = append(m.CommandHash[:0], dAtA[iNdEx:postIndex]...)
			if m.CommandHash == nil {
				m.CommandHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDqpbft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDqpbft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipDqpbft(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, ErrIntOverflowDqpbft
			}
			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, ErrIntOverflowDqpbft
				}
				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, ErrIntOverflowDqpbft
				}
				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, ErrInvalidLengthDqpbft
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupDqpbft
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthDqpbft
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthDqpbft        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDqpbft          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupDqpbft = fmt.Errorf("proto: unexpected end of group")
)