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

package types

import (
	bytes "bytes"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "github.com/golang/protobuf/ptypes/timestamp"
	bits "github.com/tendermint/tendermint/proto/libs/bits"
	version "github.com/tendermint/tendermint/proto/version"
	math "math"
	time "time"
)

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

// 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

// BlockIdFlag indicates which BlcokID the signature is for
type BlockIDFlag int32

const (
	BLOCKD_ID_FLAG_UNKNOWN BlockIDFlag = 0
	BlockIDFlagAbsent      BlockIDFlag = 1
	BlockIDFlagCommit      BlockIDFlag = 2
	BlockIDFlagNil         BlockIDFlag = 3
)

var BlockIDFlag_name = map[int32]string{
	0: "BLOCKD_ID_FLAG_UNKNOWN",
	1: "BLOCK_ID_FLAG_ABSENT",
	2: "BLOCK_ID_FLAG_COMMIT",
	3: "BLOCK_ID_FLAG_NIL",
}

var BlockIDFlag_value = map[string]int32{
	"BLOCKD_ID_FLAG_UNKNOWN": 0,
	"BLOCK_ID_FLAG_ABSENT":   1,
	"BLOCK_ID_FLAG_COMMIT":   2,
	"BLOCK_ID_FLAG_NIL":      3,
}

func (BlockIDFlag) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ff06f8095857fb18, []int{0}
}

// SignedMsgType is a type of signed message in the consensus.
type SignedMsgType int32

const (
	SIGNED_MSG_TYPE_UNKNOWN SignedMsgType = 0
	PrevoteType             SignedMsgType = 1
	PrecommitType           SignedMsgType = 2
	ProposalType            SignedMsgType = 3
)

var SignedMsgType_name = map[int32]string{
	0: "SIGNED_MSG_TYPE_UNKNOWN",
	1: "PREVOTE_TYPE",
	2: "PRECOMMIT_TYPE",
	3: "PROPOSAL_TYPE",
}

var SignedMsgType_value = map[string]int32{
	"SIGNED_MSG_TYPE_UNKNOWN": 0,
	"PREVOTE_TYPE":            1,
	"PRECOMMIT_TYPE":          2,
	"PROPOSAL_TYPE":           3,
}

func (SignedMsgType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ff06f8095857fb18, []int{1}
}

// PartsetHeader
type PartSetHeader struct {
	Total                uint32   `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	Hash                 []byte   `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PartSetHeader proto.InternalMessageInfo

func (m *PartSetHeader) GetTotal() uint32 {
	if m != nil {
		return m.Total
	}
	return 0
}

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

// BlockID
type BlockID struct {
	Hash                 []byte        `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	PartsHeader          PartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_BlockID proto.InternalMessageInfo

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

func (m *BlockID) GetPartsHeader() PartSetHeader {
	if m != nil {
		return m.PartsHeader
	}
	return PartSetHeader{}
}

// Header defines the structure of a Tendermint block header.
type Header struct {
	// basic block info
	Version version.Consensus `protobuf:"bytes,1,opt,name=version,proto3" json:"version"`
	ChainID string            `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	Height  int64             `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	Time    time.Time         `protobuf:"bytes,4,opt,name=time,proto3,stdtime" json:"time"`
	// prev block info
	LastBlockID BlockID `protobuf:"bytes,5,opt,name=last_block_id,json=lastBlockId,proto3" json:"last_block_id"`
	// hashes of block data
	LastCommitHash []byte `protobuf:"bytes,6,opt,name=last_commit_hash,json=lastCommitHash,proto3" json:"last_commit_hash,omitempty"`
	DataHash       []byte `protobuf:"bytes,7,opt,name=data_hash,json=dataHash,proto3" json:"data_hash,omitempty"`
	// hashes from the app output from the prev block
	ValidatorsHash     []byte `protobuf:"bytes,8,opt,name=validators_hash,json=validatorsHash,proto3" json:"validators_hash,omitempty"`
	NextValidatorsHash []byte `protobuf:"bytes,9,opt,name=next_validators_hash,json=nextValidatorsHash,proto3" json:"next_validators_hash,omitempty"`
	ConsensusHash      []byte `protobuf:"bytes,10,opt,name=consensus_hash,json=consensusHash,proto3" json:"consensus_hash,omitempty"`
	AppHash            []byte `protobuf:"bytes,11,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
	LastResultsHash    []byte `protobuf:"bytes,12,opt,name=last_results_hash,json=lastResultsHash,proto3" json:"last_results_hash,omitempty"`
	// consensus info
	EvidenceHash         []byte   `protobuf:"bytes,13,opt,name=evidence_hash,json=evidenceHash,proto3" json:"evidence_hash,omitempty"`
	ProposerAddress      []byte   `protobuf:"bytes,14,opt,name=proposer_address,json=proposerAddress,proto3" json:"proposer_address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Header proto.InternalMessageInfo

func (m *Header) GetVersion() version.Consensus {
	if m != nil {
		return m.Version
	}
	return version.Consensus{}
}

func (m *Header) GetChainID() string {
	if m != nil {
		return m.ChainID
	}
	return ""
}

func (m *Header) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *Header) GetTime() time.Time {
	if m != nil {
		return m.Time
	}
	return time.Time{}
}

func (m *Header) GetLastBlockID() BlockID {
	if m != nil {
		return m.LastBlockID
	}
	return BlockID{}
}

func (m *Header) GetLastCommitHash() []byte {
	if m != nil {
		return m.LastCommitHash
	}
	return nil
}

func (m *Header) GetDataHash() []byte {
	if m != nil {
		return m.DataHash
	}
	return nil
}

func (m *Header) GetValidatorsHash() []byte {
	if m != nil {
		return m.ValidatorsHash
	}
	return nil
}

func (m *Header) GetNextValidatorsHash() []byte {
	if m != nil {
		return m.NextValidatorsHash
	}
	return nil
}

func (m *Header) GetConsensusHash() []byte {
	if m != nil {
		return m.ConsensusHash
	}
	return nil
}

func (m *Header) GetAppHash() []byte {
	if m != nil {
		return m.AppHash
	}
	return nil
}

func (m *Header) GetLastResultsHash() []byte {
	if m != nil {
		return m.LastResultsHash
	}
	return nil
}

func (m *Header) GetEvidenceHash() []byte {
	if m != nil {
		return m.EvidenceHash
	}
	return nil
}

func (m *Header) GetProposerAddress() []byte {
	if m != nil {
		return m.ProposerAddress
	}
	return nil
}

// Data contains the set of transactions included in the block
type Data struct {
	// Txs that will be applied by state @ block.Height+1.
	// NOTE: not all txs here are valid.  We're just agreeing on the order first.
	// This means that block.AppHash does not include these txs.
	Txs [][]byte `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
	// Volatile
	Hash                 []byte   `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Data proto.InternalMessageInfo

func (m *Data) GetTxs() [][]byte {
	if m != nil {
		return m.Txs
	}
	return nil
}

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

// Vote represents a prevote, precommit, or commit vote from validators for
// consensus.
type Vote struct {
	Type                 SignedMsgType `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
	Height               int64         `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	Round                int32         `protobuf:"varint,3,opt,name=round,proto3" json:"round,omitempty"`
	BlockID              BlockID       `protobuf:"bytes,4,opt,name=block_id,json=blockId,proto3" json:"block_id"`
	Timestamp            time.Time     `protobuf:"bytes,5,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
	ValidatorAddress     []byte        `protobuf:"bytes,6,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	ValidatorIndex       uint32        `protobuf:"varint,7,opt,name=validator_index,json=validatorIndex,proto3" json:"validator_index,omitempty"`
	Signature            []byte        `protobuf:"bytes,8,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_Vote proto.InternalMessageInfo

func (m *Vote) GetType() SignedMsgType {
	if m != nil {
		return m.Type
	}
	return SIGNED_MSG_TYPE_UNKNOWN
}

func (m *Vote) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *Vote) GetRound() int32 {
	if m != nil {
		return m.Round
	}
	return 0
}

func (m *Vote) GetBlockID() BlockID {
	if m != nil {
		return m.BlockID
	}
	return BlockID{}
}

func (m *Vote) GetTimestamp() time.Time {
	if m != nil {
		return m.Timestamp
	}
	return time.Time{}
}

func (m *Vote) GetValidatorAddress() []byte {
	if m != nil {
		return m.ValidatorAddress
	}
	return nil
}

func (m *Vote) GetValidatorIndex() uint32 {
	if m != nil {
		return m.ValidatorIndex
	}
	return 0
}

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

// Commit contains the evidence that a block was committed by a set of validators.
type Commit struct {
	Height               int64          `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Round                int32          `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
	BlockID              BlockID        `protobuf:"bytes,3,opt,name=block_id,json=blockId,proto3" json:"block_id"`
	Signatures           []CommitSig    `protobuf:"bytes,4,rep,name=signatures,proto3" json:"signatures"`
	Hash                 []byte         `protobuf:"bytes,5,opt,name=hash,proto3" json:"hash,omitempty"`
	BitArray             *bits.BitArray `protobuf:"bytes,6,opt,name=bit_array,json=bitArray,proto3" json:"bit_array,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_Commit proto.InternalMessageInfo

func (m *Commit) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *Commit) GetRound() int32 {
	if m != nil {
		return m.Round
	}
	return 0
}

func (m *Commit) GetBlockID() BlockID {
	if m != nil {
		return m.BlockID
	}
	return BlockID{}
}

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

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

func (m *Commit) GetBitArray() *bits.BitArray {
	if m != nil {
		return m.BitArray
	}
	return nil
}

// CommitSig is a part of the Vote included in a Commit.
type CommitSig struct {
	BlockIdFlag          BlockIDFlag `protobuf:"varint,1,opt,name=block_id_flag,json=blockIdFlag,proto3,enum=tendermint.proto.types.BlockIDFlag" json:"block_id_flag,omitempty"`
	ValidatorAddress     []byte      `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	Timestamp            time.Time   `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
	Signature            []byte      `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_CommitSig proto.InternalMessageInfo

func (m *CommitSig) GetBlockIdFlag() BlockIDFlag {
	if m != nil {
		return m.BlockIdFlag
	}
	return BLOCKD_ID_FLAG_UNKNOWN
}

func (m *CommitSig) GetValidatorAddress() []byte {
	if m != nil {
		return m.ValidatorAddress
	}
	return nil
}

func (m *CommitSig) GetTimestamp() time.Time {
	if m != nil {
		return m.Timestamp
	}
	return time.Time{}
}

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

type Proposal struct {
	Type                 SignedMsgType `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
	Height               int64         `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	Round                int32         `protobuf:"varint,3,opt,name=round,proto3" json:"round,omitempty"`
	PolRound             int32         `protobuf:"varint,4,opt,name=pol_round,json=polRound,proto3" json:"pol_round,omitempty"`
	BlockID              BlockID       `protobuf:"bytes,5,opt,name=block_id,json=blockId,proto3" json:"block_id"`
	Timestamp            time.Time     `protobuf:"bytes,6,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
	Signature            []byte        `protobuf:"bytes,7,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_Proposal proto.InternalMessageInfo

func (m *Proposal) GetType() SignedMsgType {
	if m != nil {
		return m.Type
	}
	return SIGNED_MSG_TYPE_UNKNOWN
}

func (m *Proposal) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *Proposal) GetRound() int32 {
	if m != nil {
		return m.Round
	}
	return 0
}

func (m *Proposal) GetPolRound() int32 {
	if m != nil {
		return m.PolRound
	}
	return 0
}

func (m *Proposal) GetBlockID() BlockID {
	if m != nil {
		return m.BlockID
	}
	return BlockID{}
}

func (m *Proposal) GetTimestamp() time.Time {
	if m != nil {
		return m.Timestamp
	}
	return time.Time{}
}

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

type SignedHeader struct {
	Header               *Header  `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	Commit               *Commit  `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SignedHeader proto.InternalMessageInfo

func (m *SignedHeader) GetHeader() *Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *SignedHeader) GetCommit() *Commit {
	if m != nil {
		return m.Commit
	}
	return nil
}

func init() {
	proto.RegisterEnum("tendermint.proto.types.BlockIDFlag", BlockIDFlag_name, BlockIDFlag_value)
	proto.RegisterEnum("tendermint.proto.types.SignedMsgType", SignedMsgType_name, SignedMsgType_value)
	proto.RegisterType((*PartSetHeader)(nil), "tendermint.proto.types.PartSetHeader")
	proto.RegisterType((*BlockID)(nil), "tendermint.proto.types.BlockID")
	proto.RegisterType((*Header)(nil), "tendermint.proto.types.Header")
	proto.RegisterType((*Data)(nil), "tendermint.proto.types.Data")
	proto.RegisterType((*Vote)(nil), "tendermint.proto.types.Vote")
	proto.RegisterType((*Commit)(nil), "tendermint.proto.types.Commit")
	proto.RegisterType((*CommitSig)(nil), "tendermint.proto.types.CommitSig")
	proto.RegisterType((*Proposal)(nil), "tendermint.proto.types.Proposal")
	proto.RegisterType((*SignedHeader)(nil), "tendermint.proto.types.SignedHeader")
}

func init() { proto.RegisterFile("proto/types/types.proto", fileDescriptor_ff06f8095857fb18) }

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

func (this *PartSetHeader) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

	that1, ok := that.(*Header)
	if !ok {
		that2, ok := that.(Header)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Version.Equal(&that1.Version) {
		return false
	}
	if this.ChainID != that1.ChainID {
		return false
	}
	if this.Height != that1.Height {
		return false
	}
	if !this.Time.Equal(that1.Time) {
		return false
	}
	if !this.LastBlockID.Equal(&that1.LastBlockID) {
		return false
	}
	if !bytes.Equal(this.LastCommitHash, that1.LastCommitHash) {
		return false
	}
	if !bytes.Equal(this.DataHash, that1.DataHash) {
		return false
	}
	if !bytes.Equal(this.ValidatorsHash, that1.ValidatorsHash) {
		return false
	}
	if !bytes.Equal(this.NextValidatorsHash, that1.NextValidatorsHash) {
		return false
	}
	if !bytes.Equal(this.ConsensusHash, that1.ConsensusHash) {
		return false
	}
	if !bytes.Equal(this.AppHash, that1.AppHash) {
		return false
	}
	if !bytes.Equal(this.LastResultsHash, that1.LastResultsHash) {
		return false
	}
	if !bytes.Equal(this.EvidenceHash, that1.EvidenceHash) {
		return false
	}
	if !bytes.Equal(this.ProposerAddress, that1.ProposerAddress) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func NewPopulatedPartSetHeader(r randyTypes, easy bool) *PartSetHeader {
	this := &PartSetHeader{}
	this.Total = uint32(r.Uint32())
	v1 := r.Intn(100)
	this.Hash = make([]byte, v1)
	for i := 0; i < v1; i++ {
		this.Hash[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 3)
	}
	return this
}

func NewPopulatedBlockID(r randyTypes, easy bool) *BlockID {
	this := &BlockID{}
	v2 := r.Intn(100)
	this.Hash = make([]byte, v2)
	for i := 0; i < v2; i++ {
		this.Hash[i] = byte(r.Intn(256))
	}
	v3 := NewPopulatedPartSetHeader(r, easy)
	this.PartsHeader = *v3
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 3)
	}
	return this
}

func NewPopulatedHeader(r randyTypes, easy bool) *Header {
	this := &Header{}
	v4 := version.NewPopulatedConsensus(r, easy)
	this.Version = *v4
	this.ChainID = string(randStringTypes(r))
	this.Height = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Height *= -1
	}
	v5 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.Time = *v5
	v6 := NewPopulatedBlockID(r, easy)
	this.LastBlockID = *v6
	v7 := r.Intn(100)
	this.LastCommitHash = make([]byte, v7)
	for i := 0; i < v7; i++ {
		this.LastCommitHash[i] = byte(r.Intn(256))
	}
	v8 := r.Intn(100)
	this.DataHash = make([]byte, v8)
	for i := 0; i < v8; i++ {
		this.DataHash[i] = byte(r.Intn(256))
	}
	v9 := r.Intn(100)
	this.ValidatorsHash = make([]byte, v9)
	for i := 0; i < v9; i++ {
		this.ValidatorsHash[i] = byte(r.Intn(256))
	}
	v10 := r.Intn(100)
	this.NextValidatorsHash = make([]byte, v10)
	for i := 0; i < v10; i++ {
		this.NextValidatorsHash[i] = byte(r.Intn(256))
	}
	v11 := r.Intn(100)
	this.ConsensusHash = make([]byte, v11)
	for i := 0; i < v11; i++ {
		this.ConsensusHash[i] = byte(r.Intn(256))
	}
	v12 := r.Intn(100)
	this.AppHash = make([]byte, v12)
	for i := 0; i < v12; i++ {
		this.AppHash[i] = byte(r.Intn(256))
	}
	v13 := r.Intn(100)
	this.LastResultsHash = make([]byte, v13)
	for i := 0; i < v13; i++ {
		this.LastResultsHash[i] = byte(r.Intn(256))
	}
	v14 := r.Intn(100)
	this.EvidenceHash = make([]byte, v14)
	for i := 0; i < v14; i++ {
		this.EvidenceHash[i] = byte(r.Intn(256))
	}
	v15 := r.Intn(100)
	this.ProposerAddress = make([]byte, v15)
	for i := 0; i < v15; i++ {
		this.ProposerAddress[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTypes(r, 15)
	}
	return this
}

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

func randUTF8RuneTypes(r randyTypes) 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 randStringTypes(r randyTypes) string {
	v16 := r.Intn(100)
	tmps := make([]rune, v16)
	for i := 0; i < v16; i++ {
		tmps[i] = randUTF8RuneTypes(r)
	}
	return string(tmps)
}
func randUnrecognizedTypes(r randyTypes, 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 = randFieldTypes(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
		v17 := r.Int63()
		if r.Intn(2) == 0 {
			v17 *= -1
		}
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(v17))
	case 1:
		dAtA = encodeVarintPopulateTypes(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 = encodeVarintPopulateTypes(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateTypes(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateTypes(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 encodeVarintPopulateTypes(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
}