prysm-pulse/proto/sharding/v1/messages.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: messages.proto

package ethereum_messages_v1

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"

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

type Topic int32

const (
	Topic_UNKNOWN                    Topic = 0
	Topic_COLLATION_BODY_REQUEST     Topic = 1
	Topic_COLLATION_BODY_RESPONSE    Topic = 2
	Topic_TRANSACTIONS               Topic = 3
	Topic_BEACON_BLOCK_HASH_ANNOUNCE Topic = 4
	Topic_BEACON_BLOCK_REQUEST       Topic = 5
	Topic_BEACON_BLOCK_RESPONSE      Topic = 6
)

var Topic_name = map[int32]string{
	0: "UNKNOWN",
	1: "COLLATION_BODY_REQUEST",
	2: "COLLATION_BODY_RESPONSE",
	3: "TRANSACTIONS",
	4: "BEACON_BLOCK_HASH_ANNOUNCE",
	5: "BEACON_BLOCK_REQUEST",
	6: "BEACON_BLOCK_RESPONSE",
}
var Topic_value = map[string]int32{
	"UNKNOWN":                    0,
	"COLLATION_BODY_REQUEST":     1,
	"COLLATION_BODY_RESPONSE":    2,
	"TRANSACTIONS":               3,
	"BEACON_BLOCK_HASH_ANNOUNCE": 4,
	"BEACON_BLOCK_REQUEST":       5,
	"BEACON_BLOCK_RESPONSE":      6,
}

func (x Topic) String() string {
	return proto.EnumName(Topic_name, int32(x))
}
func (Topic) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_messages_7e3c5d5de878ef23, []int{0}
}

type BeaconBlockHashAnnounce struct {
	Hash                 []byte   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_BeaconBlockHashAnnounce proto.InternalMessageInfo

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

type BeaconBlockRequest struct {
	Hash                 []byte   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_BeaconBlockRequest proto.InternalMessageInfo

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

type BeaconBlockResponse struct {
	ParentHash              []byte               `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
	SlotNumber              uint64               `protobuf:"varint,2,opt,name=slot_number,json=slotNumber,proto3" json:"slot_number,omitempty"`
	RandaoReveal            []byte               `protobuf:"bytes,3,opt,name=randao_reveal,json=randaoReveal,proto3" json:"randao_reveal,omitempty"`
	AttestationBitmask      []byte               `protobuf:"bytes,4,opt,name=attestation_bitmask,json=attestationBitmask,proto3" json:"attestation_bitmask,omitempty"`
	AttestationAggregateSig []uint32             `protobuf:"varint,5,rep,packed,name=attestation_aggregate_sig,json=attestationAggregateSig,proto3" json:"attestation_aggregate_sig,omitempty"`
	ShardAggregateVotes     []*AggregateVote     `protobuf:"bytes,6,rep,name=shard_aggregate_votes,json=shardAggregateVotes,proto3" json:"shard_aggregate_votes,omitempty"`
	MainChainRef            []byte               `protobuf:"bytes,7,opt,name=main_chain_ref,json=mainChainRef,proto3" json:"main_chain_ref,omitempty"`
	ActiveStateHash         []byte               `protobuf:"bytes,8,opt,name=active_state_hash,json=activeStateHash,proto3" json:"active_state_hash,omitempty"`
	CrystallizedStateHash   []byte               `protobuf:"bytes,9,opt,name=crystallized_state_hash,json=crystallizedStateHash,proto3" json:"crystallized_state_hash,omitempty"`
	Timestamp               *timestamp.Timestamp `protobuf:"bytes,10,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}             `json:"-"`
	XXX_unrecognized        []byte               `json:"-"`
	XXX_sizecache           int32                `json:"-"`
}

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

var xxx_messageInfo_BeaconBlockResponse proto.InternalMessageInfo

func (m *BeaconBlockResponse) GetParentHash() []byte {
	if m != nil {
		return m.ParentHash
	}
	return nil
}

func (m *BeaconBlockResponse) GetSlotNumber() uint64 {
	if m != nil {
		return m.SlotNumber
	}
	return 0
}

func (m *BeaconBlockResponse) GetRandaoReveal() []byte {
	if m != nil {
		return m.RandaoReveal
	}
	return nil
}

func (m *BeaconBlockResponse) GetAttestationBitmask() []byte {
	if m != nil {
		return m.AttestationBitmask
	}
	return nil
}

func (m *BeaconBlockResponse) GetAttestationAggregateSig() []uint32 {
	if m != nil {
		return m.AttestationAggregateSig
	}
	return nil
}

func (m *BeaconBlockResponse) GetShardAggregateVotes() []*AggregateVote {
	if m != nil {
		return m.ShardAggregateVotes
	}
	return nil
}

func (m *BeaconBlockResponse) GetMainChainRef() []byte {
	if m != nil {
		return m.MainChainRef
	}
	return nil
}

func (m *BeaconBlockResponse) GetActiveStateHash() []byte {
	if m != nil {
		return m.ActiveStateHash
	}
	return nil
}

func (m *BeaconBlockResponse) GetCrystallizedStateHash() []byte {
	if m != nil {
		return m.CrystallizedStateHash
	}
	return nil
}

func (m *BeaconBlockResponse) GetTimestamp() *timestamp.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

type CrystallizedStateHashAnnounce struct {
	Hash                 []byte   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CrystallizedStateHashAnnounce proto.InternalMessageInfo

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

type CrystallizedStateRequest struct {
	Hash                 []byte   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CrystallizedStateRequest proto.InternalMessageInfo

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

type CrystallizedStateResponse struct {
	ActiveValidators      []*ValidatorRecord `protobuf:"bytes,1,rep,name=active_validators,json=activeValidators,proto3" json:"active_validators,omitempty"`
	QueuedValidators      []*ValidatorRecord `protobuf:"bytes,2,rep,name=queued_validators,json=queuedValidators,proto3" json:"queued_validators,omitempty"`
	ExitedValidators      []*ValidatorRecord `protobuf:"bytes,3,rep,name=exited_validators,json=exitedValidators,proto3" json:"exited_validators,omitempty"`
	CurrentEpochShuffling []uint64           `protobuf:"varint,4,rep,packed,name=current_epoch_shuffling,json=currentEpochShuffling,proto3" json:"current_epoch_shuffling,omitempty"`
	CurrentEpoch          uint64             `protobuf:"varint,5,opt,name=current_epoch,json=currentEpoch,proto3" json:"current_epoch,omitempty"`
	LastJustifiedEpoch    uint64             `protobuf:"varint,6,opt,name=last_justified_epoch,json=lastJustifiedEpoch,proto3" json:"last_justified_epoch,omitempty"`
	LastFinalizedEpoch    uint64             `protobuf:"varint,7,opt,name=last_finalized_epoch,json=lastFinalizedEpoch,proto3" json:"last_finalized_epoch,omitempty"`
	CurrentDynasty        uint64             `protobuf:"varint,8,opt,name=current_dynasty,json=currentDynasty,proto3" json:"current_dynasty,omitempty"`
	NextShard             uint64             `protobuf:"varint,9,opt,name=next_shard,json=nextShard,proto3" json:"next_shard,omitempty"`
	CurrentCheckPoint     []byte             `protobuf:"bytes,10,opt,name=current_check_point,json=currentCheckPoint,proto3" json:"current_check_point,omitempty"`
	TotalDeposits         uint64             `protobuf:"varint,11,opt,name=total_deposits,json=totalDeposits,proto3" json:"total_deposits,omitempty"`
	DynastySeed           []byte             `protobuf:"bytes,12,opt,name=dynasty_seed,json=dynastySeed,proto3" json:"dynasty_seed,omitempty"`
	DynastySeedLastReset  uint64             `protobuf:"varint,13,opt,name=dynasty_seed_last_reset,json=dynastySeedLastReset,proto3" json:"dynasty_seed_last_reset,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}           `json:"-"`
	XXX_unrecognized      []byte             `json:"-"`
	XXX_sizecache         int32              `json:"-"`
}

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

var xxx_messageInfo_CrystallizedStateResponse proto.InternalMessageInfo

func (m *CrystallizedStateResponse) GetActiveValidators() []*ValidatorRecord {
	if m != nil {
		return m.ActiveValidators
	}
	return nil
}

func (m *CrystallizedStateResponse) GetQueuedValidators() []*ValidatorRecord {
	if m != nil {
		return m.QueuedValidators
	}
	return nil
}

func (m *CrystallizedStateResponse) GetExitedValidators() []*ValidatorRecord {
	if m != nil {
		return m.ExitedValidators
	}
	return nil
}

func (m *CrystallizedStateResponse) GetCurrentEpochShuffling() []uint64 {
	if m != nil {
		return m.CurrentEpochShuffling
	}
	return nil
}

func (m *CrystallizedStateResponse) GetCurrentEpoch() uint64 {
	if m != nil {
		return m.CurrentEpoch
	}
	return 0
}

func (m *CrystallizedStateResponse) GetLastJustifiedEpoch() uint64 {
	if m != nil {
		return m.LastJustifiedEpoch
	}
	return 0
}

func (m *CrystallizedStateResponse) GetLastFinalizedEpoch() uint64 {
	if m != nil {
		return m.LastFinalizedEpoch
	}
	return 0
}

func (m *CrystallizedStateResponse) GetCurrentDynasty() uint64 {
	if m != nil {
		return m.CurrentDynasty
	}
	return 0
}

func (m *CrystallizedStateResponse) GetNextShard() uint64 {
	if m != nil {
		return m.NextShard
	}
	return 0
}

func (m *CrystallizedStateResponse) GetCurrentCheckPoint() []byte {
	if m != nil {
		return m.CurrentCheckPoint
	}
	return nil
}

func (m *CrystallizedStateResponse) GetTotalDeposits() uint64 {
	if m != nil {
		return m.TotalDeposits
	}
	return 0
}

func (m *CrystallizedStateResponse) GetDynastySeed() []byte {
	if m != nil {
		return m.DynastySeed
	}
	return nil
}

func (m *CrystallizedStateResponse) GetDynastySeedLastReset() uint64 {
	if m != nil {
		return m.DynastySeedLastReset
	}
	return 0
}

type ActiveStateHashAnnounce struct {
	Hash                 []byte   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ActiveStateHashAnnounce proto.InternalMessageInfo

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

type ActiveStateRequest struct {
	Hash                 []byte   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ActiveStateRequest proto.InternalMessageInfo

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

type ActiveStateResponse struct {
	TotalAttesterDeposits uint64   `protobuf:"varint,1,opt,name=total_attester_deposits,json=totalAttesterDeposits,proto3" json:"total_attester_deposits,omitempty"`
	AttesterBitfield      []byte   `protobuf:"bytes,2,opt,name=attester_bitfield,json=attesterBitfield,proto3" json:"attester_bitfield,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

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

var xxx_messageInfo_ActiveStateResponse proto.InternalMessageInfo

func (m *ActiveStateResponse) GetTotalAttesterDeposits() uint64 {
	if m != nil {
		return m.TotalAttesterDeposits
	}
	return 0
}

func (m *ActiveStateResponse) GetAttesterBitfield() []byte {
	if m != nil {
		return m.AttesterBitfield
	}
	return nil
}

type AggregateVote struct {
	ShardId              uint32   `protobuf:"varint,1,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"`
	ShardBlockHash       []byte   `protobuf:"bytes,2,opt,name=shard_block_hash,json=shardBlockHash,proto3" json:"shard_block_hash,omitempty"`
	SignerBitmask        []byte   `protobuf:"bytes,3,opt,name=signer_bitmask,json=signerBitmask,proto3" json:"signer_bitmask,omitempty"`
	AggregateSig         []uint32 `protobuf:"varint,4,rep,packed,name=aggregate_sig,json=aggregateSig,proto3" json:"aggregate_sig,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AggregateVote proto.InternalMessageInfo

func (m *AggregateVote) GetShardId() uint32 {
	if m != nil {
		return m.ShardId
	}
	return 0
}

func (m *AggregateVote) GetShardBlockHash() []byte {
	if m != nil {
		return m.ShardBlockHash
	}
	return nil
}

func (m *AggregateVote) GetSignerBitmask() []byte {
	if m != nil {
		return m.SignerBitmask
	}
	return nil
}

func (m *AggregateVote) GetAggregateSig() []uint32 {
	if m != nil {
		return m.AggregateSig
	}
	return nil
}

type CollationBodyRequest struct {
	ShardId              uint64   `protobuf:"varint,1,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"`
	Period               uint64   `protobuf:"varint,2,opt,name=period,proto3" json:"period,omitempty"`
	ChunkRoot            []byte   `protobuf:"bytes,3,opt,name=chunk_root,json=chunkRoot,proto3" json:"chunk_root,omitempty"`
	ProposerAddress      []byte   `protobuf:"bytes,4,opt,name=proposer_address,json=proposerAddress,proto3" json:"proposer_address,omitempty"`
	Signature            []byte   `protobuf:"bytes,5,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CollationBodyRequest proto.InternalMessageInfo

func (m *CollationBodyRequest) GetShardId() uint64 {
	if m != nil {
		return m.ShardId
	}
	return 0
}

func (m *CollationBodyRequest) GetPeriod() uint64 {
	if m != nil {
		return m.Period
	}
	return 0
}

func (m *CollationBodyRequest) GetChunkRoot() []byte {
	if m != nil {
		return m.ChunkRoot
	}
	return nil
}

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

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

type ValidatorRecord struct {
	PublicKey            uint64   `protobuf:"varint,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	WithdrawalShard      uint64   `protobuf:"varint,2,opt,name=withdrawal_shard,json=withdrawalShard,proto3" json:"withdrawal_shard,omitempty"`
	WithdrawalAddress    []byte   `protobuf:"bytes,3,opt,name=withdrawal_address,json=withdrawalAddress,proto3" json:"withdrawal_address,omitempty"`
	RandaoCommitment     []byte   `protobuf:"bytes,4,opt,name=randao_commitment,json=randaoCommitment,proto3" json:"randao_commitment,omitempty"`
	Balance              uint64   `protobuf:"varint,5,opt,name=balance,proto3" json:"balance,omitempty"`
	SwitchDynasty        uint64   `protobuf:"varint,6,opt,name=switch_dynasty,json=switchDynasty,proto3" json:"switch_dynasty,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ValidatorRecord proto.InternalMessageInfo

func (m *ValidatorRecord) GetPublicKey() uint64 {
	if m != nil {
		return m.PublicKey
	}
	return 0
}

func (m *ValidatorRecord) GetWithdrawalShard() uint64 {
	if m != nil {
		return m.WithdrawalShard
	}
	return 0
}

func (m *ValidatorRecord) GetWithdrawalAddress() []byte {
	if m != nil {
		return m.WithdrawalAddress
	}
	return nil
}

func (m *ValidatorRecord) GetRandaoCommitment() []byte {
	if m != nil {
		return m.RandaoCommitment
	}
	return nil
}

func (m *ValidatorRecord) GetBalance() uint64 {
	if m != nil {
		return m.Balance
	}
	return 0
}

func (m *ValidatorRecord) GetSwitchDynasty() uint64 {
	if m != nil {
		return m.SwitchDynasty
	}
	return 0
}

type CollationBodyResponse struct {
	HeaderHash           []byte   `protobuf:"bytes,1,opt,name=header_hash,json=headerHash,proto3" json:"header_hash,omitempty"`
	Body                 []byte   `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CollationBodyResponse proto.InternalMessageInfo

func (m *CollationBodyResponse) GetHeaderHash() []byte {
	if m != nil {
		return m.HeaderHash
	}
	return nil
}

func (m *CollationBodyResponse) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

type Transaction struct {
	Nonce                uint64     `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	GasPrice             uint64     `protobuf:"varint,2,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"`
	GasLimit             uint64     `protobuf:"varint,3,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
	Recipient            []byte     `protobuf:"bytes,4,opt,name=recipient,proto3" json:"recipient,omitempty"`
	Value                uint64     `protobuf:"varint,5,opt,name=value,proto3" json:"value,omitempty"`
	Input                []byte     `protobuf:"bytes,6,opt,name=input,proto3" json:"input,omitempty"`
	Signature            *Signature `protobuf:"bytes,7,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_Transaction proto.InternalMessageInfo

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

func (m *Transaction) GetGasPrice() uint64 {
	if m != nil {
		return m.GasPrice
	}
	return 0
}

func (m *Transaction) GetGasLimit() uint64 {
	if m != nil {
		return m.GasLimit
	}
	return 0
}

func (m *Transaction) GetRecipient() []byte {
	if m != nil {
		return m.Recipient
	}
	return nil
}

func (m *Transaction) GetValue() uint64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *Transaction) GetInput() []byte {
	if m != nil {
		return m.Input
	}
	return nil
}

func (m *Transaction) GetSignature() *Signature {
	if m != nil {
		return m.Signature
	}
	return nil
}

type Signature struct {
	V                    uint64   `protobuf:"varint,1,opt,name=v,proto3" json:"v,omitempty"`
	R                    uint64   `protobuf:"varint,2,opt,name=r,proto3" json:"r,omitempty"`
	S                    uint64   `protobuf:"varint,3,opt,name=s,proto3" json:"s,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Signature proto.InternalMessageInfo

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

func (m *Signature) GetR() uint64 {
	if m != nil {
		return m.R
	}
	return 0
}

func (m *Signature) GetS() uint64 {
	if m != nil {
		return m.S
	}
	return 0
}

func init() {
	proto.RegisterType((*BeaconBlockHashAnnounce)(nil), "ethereum.messages.v1.BeaconBlockHashAnnounce")
	proto.RegisterType((*BeaconBlockRequest)(nil), "ethereum.messages.v1.BeaconBlockRequest")
	proto.RegisterType((*BeaconBlockResponse)(nil), "ethereum.messages.v1.BeaconBlockResponse")
	proto.RegisterType((*CrystallizedStateHashAnnounce)(nil), "ethereum.messages.v1.CrystallizedStateHashAnnounce")
	proto.RegisterType((*CrystallizedStateRequest)(nil), "ethereum.messages.v1.CrystallizedStateRequest")
	proto.RegisterType((*CrystallizedStateResponse)(nil), "ethereum.messages.v1.CrystallizedStateResponse")
	proto.RegisterType((*ActiveStateHashAnnounce)(nil), "ethereum.messages.v1.ActiveStateHashAnnounce")
	proto.RegisterType((*ActiveStateRequest)(nil), "ethereum.messages.v1.ActiveStateRequest")
	proto.RegisterType((*ActiveStateResponse)(nil), "ethereum.messages.v1.ActiveStateResponse")
	proto.RegisterType((*AggregateVote)(nil), "ethereum.messages.v1.AggregateVote")
	proto.RegisterType((*CollationBodyRequest)(nil), "ethereum.messages.v1.CollationBodyRequest")
	proto.RegisterType((*ValidatorRecord)(nil), "ethereum.messages.v1.ValidatorRecord")
	proto.RegisterType((*CollationBodyResponse)(nil), "ethereum.messages.v1.CollationBodyResponse")
	proto.RegisterType((*Transaction)(nil), "ethereum.messages.v1.Transaction")
	proto.RegisterType((*Signature)(nil), "ethereum.messages.v1.Signature")
	proto.RegisterEnum("ethereum.messages.v1.Topic", Topic_name, Topic_value)
}

func init() { proto.RegisterFile("messages.proto", fileDescriptor_messages_7e3c5d5de878ef23) }

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