Epoch Processing: Receipt Root, Justification and Finalization (#1158)

beacon-chain/core/blocks/block_operations.go

@@ -43,11 +43,11 @@ func ProcessPOWReceiptRoots(
 	currentCandidateReceiptRoots := beaconState.GetCandidatePowReceiptRoots()
 	for idx, root := range currentCandidateReceiptRoots {
 		if bytes.Equal(block.GetCandidatePowReceiptRootHash32(), root.GetCandidatePowReceiptRootHash32()) {
-			currentCandidateReceiptRoots[idx].Votes++
+			currentCandidateReceiptRoots[idx].VoteCount++
 		} else {
 			newCandidateReceiptRoots = append(newCandidateReceiptRoots, &pb.CandidatePoWReceiptRootRecord{
 				CandidatePowReceiptRootHash32: block.GetCandidatePowReceiptRootHash32(),
-				Votes:                         1,
+				VoteCount:                     1,
 			})
 		}
 	}

beacon-chain/core/blocks/block_operations_test.go

@@ -16,7 +16,7 @@ func TestProcessPOWReceiptRoots_SameRootHash(t *testing.T) {
 		CandidatePowReceiptRoots: []*pb.CandidatePoWReceiptRootRecord{
 			{
 				CandidatePowReceiptRootHash32: []byte{1},
-				Votes:                         5,
+				VoteCount:                     5,
 			},
 		},
 	}
@@ -24,8 +24,8 @@ func TestProcessPOWReceiptRoots_SameRootHash(t *testing.T) {
 		CandidatePowReceiptRootHash32: []byte{1},
 	}
 	newReceiptRoots := ProcessPOWReceiptRoots(beaconState, block)
-	if newReceiptRoots[0].Votes != 6 {
-		t.Errorf("expected votes to increase from 5 to 6, received %v", newReceiptRoots[0].Votes)
+	if newReceiptRoots[0].VoteCount != 6 {
+		t.Errorf("expected votes to increase from 5 to 6, received %v", newReceiptRoots[0].VoteCount)
 	}
 }
 
@@ -34,7 +34,7 @@ func TestProcessPOWReceiptRoots_NewCandidateRecord(t *testing.T) {
 		CandidatePowReceiptRoots: []*pb.CandidatePoWReceiptRootRecord{
 			{
 				CandidatePowReceiptRootHash32: []byte{0},
-				Votes:                         5,
+				VoteCount:                     5,
 			},
 		},
 	}
@@ -45,10 +45,10 @@ func TestProcessPOWReceiptRoots_NewCandidateRecord(t *testing.T) {
 	if len(newReceiptRoots) == 1 {
 		t.Error("expected new receipt roots to have length > 1")
 	}
-	if newReceiptRoots[1].Votes != 1 {
+	if newReceiptRoots[1].VoteCount != 1 {
 		t.Errorf(
 			"expected new receipt roots to have a new element with votes = 1, received votes = %d",
-			newReceiptRoots[1].Votes,
+			newReceiptRoots[1].VoteCount,
 		)
 	}
 	if !bytes.Equal(newReceiptRoots[1].CandidatePowReceiptRootHash32, []byte{1}) {

beacon-chain/core/epoch/BUILD.bazel

@@ -2,7 +2,10 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = ["epoch_operations.go"],
+    srcs = [
+        "epoch_operations.go",
+        "epoch_processing.go",
+    ],
     importpath = "github.com/prysmaticlabs/prysm/beacon-chain/core/epoch",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
@@ -16,7 +19,10 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = ["epoch_operations_test.go"],
+    srcs = [
+        "epoch_operations_test.go",
+        "epoch_processing_test.go",
+    ],
     embed = [":go_default_library"],
     deps = [
         "//proto/beacon/p2p/v1:go_default_library",

beacon-chain/core/epoch/epoch_operations.go

@@ -16,7 +16,7 @@ import (
 // included in the chain during the epoch.
 //
 // Spec pseudocode definition:
-//   [a for a in state.latest_attestations
+//   return [a for a in state.latest_attestations
 //   if state.slot - EPOCH_LENGTH <= a.data.slot < state.slot]
 func Attestations(state *pb.BeaconState) []*pb.PendingAttestationRecord {
 	epochLength := params.BeaconConfig().EpochLength
@@ -43,7 +43,7 @@ func Attestations(state *pb.BeaconState) []*pb.PendingAttestationRecord {
 // the epoch's boundary block.
 //
 // Spec pseudocode definition:
-//   [a for a in this_epoch_attestations if a.data.epoch_boundary_root ==
+//   return [a for a in this_epoch_attestations if a.data.epoch_boundary_root ==
 //   get_block_root(state, state.slot-EPOCH_LENGTH) and a.justified_slot ==
 //   state.justified_slot]
 func BoundaryAttestations(
@@ -74,7 +74,7 @@ func BoundaryAttestations(
 // (state.slot - 2 * EPOCH_LENGTH...state.slot - EPOCH_LENGTH).
 //
 // Spec pseudocode definition:
-//   [a for a in state.latest_attestations
+//   return [a for a in state.latest_attestations
 //   if state.slot - 2 * EPOCH_LENGTH <= a.slot < state.slot - EPOCH_LENGTH]
 func PrevAttestations(state *pb.BeaconState) []*pb.PendingAttestationRecord {
 	epochLength := params.BeaconConfig().EpochLength
@@ -102,7 +102,7 @@ func PrevAttestations(state *pb.BeaconState) []*pb.PendingAttestationRecord {
 // of the previous 2 epochs.
 //
 // Spec pseudocode definition:
-//   [a for a in this_epoch_attestations + previous_epoch_attestations
+//   return [a for a in this_epoch_attestations + previous_epoch_attestations
 //   if a.justified_slot == state.previous_justified_slot]
 func PrevJustifiedAttestations(
 	state *pb.BeaconState,
@@ -125,7 +125,7 @@ func PrevJustifiedAttestations(
 // the canonical beacon chain.
 //
 // Spec pseudocode definition:
-//   [a for a in previous_epoch_attestations
+//   return [a for a in previous_epoch_attestations
 //   if a.beacon_block_root == get_block_root(state, a.slot)]
 func PrevHeadAttestations(
 	state *pb.BeaconState,
@@ -167,8 +167,8 @@ func WinningRoot(
 	attestations := append(thisEpochAttestations, prevEpochAttestations...)
 
 	for _, attestation := range attestations {
-		if attestation.Data.Shard == shardCommittee.Shard {
-			candidateRoots = append(candidateRoots, attestation.Data.ShardBlockRootHash32)
+		if attestation.GetData().GetShard() == shardCommittee.Shard {
+			candidateRoots = append(candidateRoots, attestation.GetData().ShardBlockRootHash32)
 		}
 	}
 
@@ -283,7 +283,7 @@ func TotalBalance(
 func InclusionSlot(state *pb.BeaconState, validatorIndex uint32) (uint64, error) {
 
 	for _, attestation := range state.LatestAttestations {
-		participatedValidators, err := validators.AttestationParticipants(state, attestation.Data, attestation.ParticipationBitfield)
+		participatedValidators, err := validators.AttestationParticipants(state, attestation.GetData(), attestation.ParticipationBitfield)
 		if err != nil {
 			return 0, fmt.Errorf("could not get attestation participants: %v", err)
 		}
@@ -307,14 +307,14 @@ func InclusionSlot(state *pb.BeaconState, validatorIndex uint32) (uint64, error)
 func InclusionDistance(state *pb.BeaconState, validatorIndex uint32) (uint64, error) {
 
 	for _, attestation := range state.LatestAttestations {
-		participatedValidators, err := validators.AttestationParticipants(state, attestation.Data, attestation.ParticipationBitfield)
+		participatedValidators, err := validators.AttestationParticipants(state, attestation.GetData(), attestation.ParticipationBitfield)
 		if err != nil {
 			return 0, fmt.Errorf("could not get attestation participants: %v", err)
 		}
 
 		for _, index := range participatedValidators {
 			if index == validatorIndex {
-				return attestation.SlotIncluded - attestation.Data.Slot, nil
+				return attestation.SlotIncluded - attestation.GetData().GetSlot(), nil
 			}
 		}
 	}

beacon-chain/core/epoch/epoch_processing.go

@@ -0,0 +1,104 @@
+package epoch
+
+import (
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+// CanProcessEpoch checks the eligibility to process epoch.
+// The epoch can be processed every EPOCH_LENGTH.
+//
+// Spec pseudocode definition:
+//    If state.slot % EPOCH_LENGTH == 0:
+func CanProcessEpoch(state *pb.BeaconState) bool {
+	return state.Slot%params.BeaconConfig().EpochLength == 0
+}
+
+// CanProcessReceiptRoots checks the eligibility to process PoW receipt root.
+// The receipt root can be processed every POW_RECEIPT_ROOT_VOTING_PERIOD.
+//
+// Spec pseudocode definition:
+//    If state.slot % POW_RECEIPT_ROOT_VOTING_PERIOD == 0:
+func CanProcessReceiptRoots(state *pb.BeaconState) bool {
+	return state.Slot%params.BeaconConfig().PowReceiptRootVotingPeriod == 0
+}
+
+// ProcessReceipt processes PoW receipt roots by checking its vote count.
+// With sufficient votes (>2*POW_RECEIPT_ROOT_VOTING_PERIOD), it then
+// assigns root hash to processed receipt vote in state.
+func ProcessReceipt(state *pb.BeaconState) *pb.BeaconState {
+
+	for _, receiptRoot := range state.CandidatePowReceiptRoots {
+		if receiptRoot.VoteCount*2 > params.BeaconConfig().PowReceiptRootVotingPeriod {
+			state.ProcessedPowReceiptRootHash32 = receiptRoot.CandidatePowReceiptRootHash32
+		}
+	}
+	state.CandidatePowReceiptRoots = make([]*pb.CandidatePoWReceiptRootRecord, 0)
+	return state
+}
+
+// ProcessJustification processes for justified slot by comparing
+// epoch boundary balance and total balance.
+//
+// Spec pseudocode definition:
+//    Set state.previous_justified_slot = state.justified_slot.
+//    Set state.justification_bitfield = (state.justification_bitfield * 2) % 2**64.
+//    Set state.justification_bitfield |= 2 and state.justified_slot =
+//    state.slot - 2 * EPOCH_LENGTH if 3 * previous_epoch_boundary_attesting_balance >= 2 * total_balance.
+//    Set state.justification_bitfield |= 1 and state.justified_slot =
+//    state.slot - 1 * EPOCH_LENGTH if 3 * this_epoch_boundary_attesting_balance >= 2 * total_balance.
+func ProcessJustification(
+	state *pb.BeaconState,
+	thisEpochBoundaryAttestingBalance uint64,
+	prevEpochBoundaryAttestingBalance uint64,
+	totalBalance uint64) *pb.BeaconState {
+
+	state.PreviousJustifiedSlot = state.JustifiedSlot
+	// Shifts all the bits over one to create a new bit for the recent epoch.
+	state.JustificationBitfield = state.JustificationBitfield * 2
+
+	// If prev prev epoch was justified then we ensure the 2nd bit in the bitfield is set,
+	// assign new justified slot to 2 * EPOCH_LENGTH before.
+	if 3*prevEpochBoundaryAttestingBalance >= 2*totalBalance {
+		state.JustificationBitfield |= 2
+		state.JustifiedSlot = state.Slot - 2*params.BeaconConfig().EpochLength
+	}
+
+	// If this epoch was justified then we ensure the 1st bit in the bitfield is set,
+	// assign new justified slot to 1 * EPOCH_LENGTH before.
+	if 3*thisEpochBoundaryAttestingBalance >= 2*totalBalance {
+		state.JustificationBitfield |= 1
+		state.JustifiedSlot = state.Slot - 1*params.BeaconConfig().EpochLength
+	}
+	return state
+}
+
+// ProcessFinalization processes for finalized slot by checking
+// consecutive justified slots.
+//
+// Spec pseudocode definition:
+//   Set state.finalized_slot = state.previous_justified_slot if any of the following are true:
+//		state.previous_justified_slot == state.slot - 2 * EPOCH_LENGTH and state.justification_bitfield % 4 == 3
+//		state.previous_justified_slot == state.slot - 3 * EPOCH_LENGTH and state.justification_bitfield % 8 == 7
+//		state.previous_justified_slot == state.slot - 4 * EPOCH_LENGTH and state.justification_bitfield % 16 in (15, 14)
+func ProcessFinalization(state *pb.BeaconState) *pb.BeaconState {
+	epochLength := params.BeaconConfig().EpochLength
+
+	if state.PreviousJustifiedSlot == state.Slot-2*epochLength &&
+		state.JustificationBitfield%4 == 3 {
+		state.FinalizedSlot = state.JustifiedSlot
+		return state
+	}
+	if state.PreviousJustifiedSlot == state.Slot-3*epochLength &&
+		state.JustificationBitfield%8 == 7 {
+		state.FinalizedSlot = state.JustifiedSlot
+		return state
+	}
+	if state.PreviousJustifiedSlot == state.Slot-4*epochLength &&
+		(state.JustificationBitfield%16 == 15 ||
+			state.JustificationBitfield%16 == 14) {
+		state.FinalizedSlot = state.JustifiedSlot
+		return state
+	}
+	return state
+}

beacon-chain/core/epoch/epoch_processing_test.go

@@ -0,0 +1,222 @@
+package epoch
+
+import (
+	"bytes"
+	"testing"
+
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
+	"github.com/prysmaticlabs/prysm/shared/params"
+)
+
+func TestCanProcessEpoch(t *testing.T) {
+	if params.BeaconConfig().EpochLength != 64 {
+		t.Errorf("EpochLength should be 64 for these tests to pass")
+	}
+	tests := []struct {
+		slot            uint64
+		canProcessEpoch bool
+	}{
+		{
+			slot:            1,
+			canProcessEpoch: false,
+		},
+		{
+			slot:            63,
+			canProcessEpoch: false,
+		},
+		{
+			slot:            64,
+			canProcessEpoch: true,
+		}, {
+			slot:            128,
+			canProcessEpoch: true,
+		}, {
+			slot:            1000000000,
+			canProcessEpoch: true,
+		},
+	}
+	for _, tt := range tests {
+		state := &pb.BeaconState{Slot: tt.slot}
+		if CanProcessEpoch(state) != tt.canProcessEpoch {
+			t.Errorf(
+				"CanProcessEpoch(%d) = %v. Wanted %v",
+				tt.slot,
+				CanProcessEpoch(state),
+				tt.canProcessEpoch,
+			)
+		}
+	}
+}
+
+func TestCanProcessReceiptRoots(t *testing.T) {
+	if params.BeaconConfig().PowReceiptRootVotingPeriod != 1024 {
+		t.Errorf("PowReceiptRootVotingPeriod should be 1024 for these tests to pass")
+	}
+	tests := []struct {
+		slot                   uint64
+		canProcessReceiptRoots bool
+	}{
+		{
+			slot:                   1,
+			canProcessReceiptRoots: false,
+		},
+		{
+			slot:                   1022,
+			canProcessReceiptRoots: false,
+		},
+		{
+			slot:                   1024,
+			canProcessReceiptRoots: true,
+		}, {
+			slot:                   4096,
+			canProcessReceiptRoots: true,
+		}, {
+			slot:                   234234,
+			canProcessReceiptRoots: false,
+		},
+	}
+	for _, tt := range tests {
+		state := &pb.BeaconState{Slot: tt.slot}
+		if CanProcessReceiptRoots(state) != tt.canProcessReceiptRoots {
+			t.Errorf(
+				"CanProcessReceiptRoots(%d) = %v. Wanted %v",
+				tt.slot,
+				CanProcessReceiptRoots(state),
+				tt.canProcessReceiptRoots,
+			)
+		}
+	}
+}
+
+func TestProcessReceipt(t *testing.T) {
+	if params.BeaconConfig().PowReceiptRootVotingPeriod != 1024 {
+		t.Errorf("PowReceiptRootVotingPeriod should be 1024 for these tests to pass")
+	}
+	requiredVoteCount := params.BeaconConfig().PowReceiptRootVotingPeriod
+	state := &pb.BeaconState{
+		CandidatePowReceiptRoots: []*pb.CandidatePoWReceiptRootRecord{
+			{VoteCount: 0, CandidatePowReceiptRootHash32: []byte{'A'}},
+			// CandidatePowReceiptRootHash32 ['B'] gets to process with sufficient vote count.
+			{VoteCount: requiredVoteCount/2 + 1, CandidatePowReceiptRootHash32: []byte{'B'}},
+			{VoteCount: requiredVoteCount / 2, CandidatePowReceiptRootHash32: []byte{'C'}},
+		},
+	}
+	newState := ProcessReceipt(state)
+	if !bytes.Equal(newState.ProcessedPowReceiptRootHash32, []byte{'B'}) {
+		t.Errorf("Incorrect ProcessedPowReceiptRootHash32. Wanted: %v, got: %v",
+			[]byte{'B'}, newState.ProcessedPowReceiptRootHash32)
+	}
+
+	// Adding a new receipt root ['D'] which should be the new processed receipt root.
+	state.CandidatePowReceiptRoots = append(state.CandidatePowReceiptRoots,
+		&pb.CandidatePoWReceiptRootRecord{VoteCount: requiredVoteCount,
+			CandidatePowReceiptRootHash32: []byte{'D'}})
+	newState = ProcessReceipt(state)
+	if !bytes.Equal(newState.ProcessedPowReceiptRootHash32, []byte{'D'}) {
+		t.Errorf("Incorrect ProcessedPowReceiptRootHash32. Wanted: %v, got: %v",
+			[]byte{'D'}, newState.ProcessedPowReceiptRootHash32)
+	}
+
+	if len(newState.CandidatePowReceiptRoots) != 0 {
+		t.Errorf("Failed to clean up CandidatePowReceiptRoots slice. Length: %d",
+			len(newState.CandidatePowReceiptRoots))
+	}
+}
+
+func TestProcessJustification(t *testing.T) {
+	if params.BeaconConfig().EpochLength != 64 {
+		t.Errorf("EpochLength should be 64 for these tests to pass")
+	}
+
+	state := &pb.BeaconState{
+		Slot:                  300,
+		JustifiedSlot:         200,
+		JustificationBitfield: 4,
+	}
+	newState := ProcessJustification(state, 1, 1, 1)
+
+	if newState.PreviousJustifiedSlot != 200 {
+		t.Errorf("New state's prev justified slot %d != old state's justified slot %d",
+			newState.PreviousJustifiedSlot, state.JustifiedSlot)
+	}
+	// Since this epoch was justified (not prev), justified_slot = state.slot - EPOCH_LENGTH.
+	if newState.JustifiedSlot != state.Slot-params.BeaconConfig().EpochLength {
+		t.Errorf("New state's justified slot %d != state's slot - EPOCH_LENGTH %d",
+			newState.JustifiedSlot, state.Slot-params.BeaconConfig().EpochLength)
+	}
+	// The new JustificationBitfield is 11, it went from 0100 to 1011. Two 1's were appended because both
+	// prev epoch and this epoch were justified.
+	if newState.JustificationBitfield != 11 {
+		t.Errorf("New state's justification bitfield %d != 11", newState.JustificationBitfield)
+	}
+
+	// Assume for the case where only prev epoch got justified. Verify
+	// justified_slot = state.slot - 2 * EPOCH_LENGTH.
+	newState = ProcessJustification(state, 0, 1, 1)
+	if newState.JustifiedSlot != state.Slot-2*params.BeaconConfig().EpochLength {
+		t.Errorf("New state's justified slot %d != state's slot - 2 * EPOCH_LENGTH %d",
+			newState.JustifiedSlot, state.Slot-params.BeaconConfig().EpochLength)
+	}
+}
+
+func TestProcessFinalization(t *testing.T) {
+	if params.BeaconConfig().EpochLength != 64 {
+		t.Errorf("EpochLength should be 64 for these tests to pass")
+	}
+	epochLength := params.BeaconConfig().EpochLength
+
+	// 2 consecutive justified slot in a row,
+	// and previous justified slot is state slot - 2 * EPOCH_LENGTH.
+	state := &pb.BeaconState{
+		Slot:                  200,
+		JustifiedSlot:         200 - epochLength,
+		PreviousJustifiedSlot: 200 - 2*epochLength,
+		JustificationBitfield: 3,
+	}
+	newState := ProcessFinalization(state)
+	if newState.FinalizedSlot != state.JustifiedSlot {
+		t.Errorf("Wanted finalized slot to be %d, got %d:",
+			state.JustifiedSlot, newState.FinalizedSlot)
+	}
+
+	// 3 consecutive justified slot in a row.
+	// and previous justified slot is state slot - 3 * EPOCH_LENGTH.
+	state = &pb.BeaconState{
+		Slot:                  300,
+		JustifiedSlot:         300 - epochLength,
+		PreviousJustifiedSlot: 300 - 3*epochLength,
+		JustificationBitfield: 7,
+	}
+	newState = ProcessFinalization(state)
+	if newState.FinalizedSlot != state.JustifiedSlot {
+		t.Errorf("Wanted finalized slot to be %d, got %d:",
+			state.JustifiedSlot, newState.FinalizedSlot)
+	}
+
+	// 4 consecutive justified slot in a row.
+	// and previous justified slot is state slot - 3 * EPOCH_LENGTH.
+	state = &pb.BeaconState{
+		Slot:                  400,
+		JustifiedSlot:         400 - epochLength,
+		PreviousJustifiedSlot: 400 - 4*epochLength,
+		JustificationBitfield: 15,
+	}
+	newState = ProcessFinalization(state)
+	if newState.FinalizedSlot != state.JustifiedSlot {
+		t.Errorf("Wanted finalized slot to be %d, got %d:",
+			state.JustifiedSlot, newState.FinalizedSlot)
+	}
+
+	// if nothing gets finalized it just returns the same state.
+	state = &pb.BeaconState{
+		Slot:                  100,
+		JustifiedSlot:         65,
+		PreviousJustifiedSlot: 0,
+		JustificationBitfield: 1,
+	}
+	newState = ProcessFinalization(state)
+	if newState.FinalizedSlot != 0 {
+		t.Errorf("Wanted finalized slot to be %d, got %d:",
+			0, newState.FinalizedSlot)
+	}
+}

beacon-chain/core/state/state.go

@@ -48,7 +48,7 @@ func NewGenesisBeaconState(genesisValidatorRegistry []*pb.ValidatorRecord) (*pb.
 		PersistentCommitteeReassignments:     []*pb.ShardReassignmentRecord{},
 		PreviousJustifiedSlot:                0,
 		JustifiedSlot:                        0,
-		JustifiedSlotBitfield:                0,
+		JustificationBitfield:                0,
 		FinalizedSlot:                        0,
 		LatestCrosslinks:                     crosslinks,
 		LastStateRecalculationSlot:           0,

proto/beacon/p2p/v1/types.pb.go

@@ -51,7 +51,7 @@ func (x ValidatorRecord_StatusCodes) String() string {
 	return proto.EnumName(ValidatorRecord_StatusCodes_name, int32(x))
 }
 func (ValidatorRecord_StatusCodes) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{6, 0}
+	return fileDescriptor_types_8bf51971738cd628, []int{6, 0}
 }
 
 type BeaconState struct {
@@ -67,7 +67,7 @@ type BeaconState struct {
 	PersistentCommitteeReassignments     []*ShardReassignmentRecord       `protobuf:"bytes,1005,rep,name=persistent_committee_reassignments,json=persistentCommitteeReassignments" json:"persistent_committee_reassignments,omitempty"`
 	PreviousJustifiedSlot                uint64                           `protobuf:"varint,2001,opt,name=previous_justified_slot,json=previousJustifiedSlot,proto3" json:"previous_justified_slot,omitempty"`
 	JustifiedSlot                        uint64                           `protobuf:"varint,2002,opt,name=justified_slot,json=justifiedSlot,proto3" json:"justified_slot,omitempty"`
-	JustifiedSlotBitfield                uint64                           `protobuf:"varint,2003,opt,name=justified_slot_bitfield,json=justifiedSlotBitfield,proto3" json:"justified_slot_bitfield,omitempty"`
+	JustificationBitfield                uint64                           `protobuf:"varint,2003,opt,name=justification_bitfield,json=justificationBitfield,proto3" json:"justification_bitfield,omitempty"`
 	FinalizedSlot                        uint64                           `protobuf:"varint,2004,opt,name=finalized_slot,json=finalizedSlot,proto3" json:"finalized_slot,omitempty"`
 	LatestCrosslinks                     []*CrosslinkRecord               `protobuf:"bytes,3001,rep,name=latest_crosslinks,json=latestCrosslinks" json:"latest_crosslinks,omitempty"`
 	LastStateRecalculationSlot           uint64                           `protobuf:"varint,3002,opt,name=last_state_recalculation_slot,json=lastStateRecalculationSlot,proto3" json:"last_state_recalculation_slot,omitempty"`
@@ -90,7 +90,7 @@ func (m *BeaconState) Reset()         { *m = BeaconState{} }
 func (m *BeaconState) String() string { return proto.CompactTextString(m) }
 func (*BeaconState) ProtoMessage()    {}
 func (*BeaconState) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{0}
+	return fileDescriptor_types_8bf51971738cd628, []int{0}
 }
 func (m *BeaconState) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -203,9 +203,9 @@ func (m *BeaconState) GetJustifiedSlot() uint64 {
 	return 0
 }
 
-func (m *BeaconState) GetJustifiedSlotBitfield() uint64 {
+func (m *BeaconState) GetJustificationBitfield() uint64 {
 	if m != nil {
-		return m.JustifiedSlotBitfield
+		return m.JustificationBitfield
 	}
 	return 0
 }
@@ -316,7 +316,7 @@ func (m *ForkData) Reset()         { *m = ForkData{} }
 func (m *ForkData) String() string { return proto.CompactTextString(m) }
 func (*ForkData) ProtoMessage()    {}
 func (*ForkData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{1}
+	return fileDescriptor_types_8bf51971738cd628, []int{1}
 }
 func (m *ForkData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -368,7 +368,7 @@ func (m *ForkData) GetForkSlot() uint64 {
 
 type CandidatePoWReceiptRootRecord struct {
 	CandidatePowReceiptRootHash32 []byte   `protobuf:"bytes,1,opt,name=candidate_pow_receipt_root_hash32,json=candidatePowReceiptRootHash32,proto3" json:"candidate_pow_receipt_root_hash32,omitempty"`
-	Votes                         uint64   `protobuf:"varint,2,opt,name=votes,proto3" json:"votes,omitempty"`
+	VoteCount                     uint64   `protobuf:"varint,2,opt,name=vote_count,json=voteCount,proto3" json:"vote_count,omitempty"`
 	XXX_NoUnkeyedLiteral          struct{} `json:"-"`
 	XXX_unrecognized              []byte   `json:"-"`
 	XXX_sizecache                 int32    `json:"-"`
@@ -378,7 +378,7 @@ func (m *CandidatePoWReceiptRootRecord) Reset()         { *m = CandidatePoWRecei
 func (m *CandidatePoWReceiptRootRecord) String() string { return proto.CompactTextString(m) }
 func (*CandidatePoWReceiptRootRecord) ProtoMessage()    {}
 func (*CandidatePoWReceiptRootRecord) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{2}
+	return fileDescriptor_types_8bf51971738cd628, []int{2}
 }
 func (m *CandidatePoWReceiptRootRecord) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -414,9 +414,9 @@ func (m *CandidatePoWReceiptRootRecord) GetCandidatePowReceiptRootHash32() []byt
 	return nil
 }
 
-func (m *CandidatePoWReceiptRootRecord) GetVotes() uint64 {
+func (m *CandidatePoWReceiptRootRecord) GetVoteCount() uint64 {
 	if m != nil {
-		return m.Votes
+		return m.VoteCount
 	}
 	return 0
 }
@@ -435,7 +435,7 @@ func (m *PendingAttestationRecord) Reset()         { *m = PendingAttestationReco
 func (m *PendingAttestationRecord) String() string { return proto.CompactTextString(m) }
 func (*PendingAttestationRecord) ProtoMessage()    {}
 func (*PendingAttestationRecord) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{3}
+	return fileDescriptor_types_8bf51971738cd628, []int{3}
 }
 func (m *PendingAttestationRecord) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -506,7 +506,7 @@ func (m *Attestation) Reset()         { *m = Attestation{} }
 func (m *Attestation) String() string { return proto.CompactTextString(m) }
 func (*Attestation) ProtoMessage()    {}
 func (*Attestation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{4}
+	return fileDescriptor_types_8bf51971738cd628, []int{4}
 }
 func (m *Attestation) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -581,7 +581,7 @@ func (m *AttestationData) Reset()         { *m = AttestationData{} }
 func (m *AttestationData) String() string { return proto.CompactTextString(m) }
 func (*AttestationData) ProtoMessage()    {}
 func (*AttestationData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{5}
+	return fileDescriptor_types_8bf51971738cd628, []int{5}
 }
 func (m *AttestationData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -684,7 +684,7 @@ 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_types_aae01fd3d2e90d2d, []int{6}
+	return fileDescriptor_types_8bf51971738cd628, []int{6}
 }
 func (m *ValidatorRecord) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -783,7 +783,7 @@ func (m *ShardReassignmentRecord) Reset()         { *m = ShardReassignmentRecord
 func (m *ShardReassignmentRecord) String() string { return proto.CompactTextString(m) }
 func (*ShardReassignmentRecord) ProtoMessage()    {}
 func (*ShardReassignmentRecord) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{7}
+	return fileDescriptor_types_8bf51971738cd628, []int{7}
 }
 func (m *ShardReassignmentRecord) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -845,7 +845,7 @@ func (m *SpecialRecord) Reset()         { *m = SpecialRecord{} }
 func (m *SpecialRecord) String() string { return proto.CompactTextString(m) }
 func (*SpecialRecord) ProtoMessage()    {}
 func (*SpecialRecord) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{8}
+	return fileDescriptor_types_8bf51971738cd628, []int{8}
 }
 func (m *SpecialRecord) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -902,7 +902,7 @@ func (m *CrosslinkRecord) Reset()         { *m = CrosslinkRecord{} }
 func (m *CrosslinkRecord) String() string { return proto.CompactTextString(m) }
 func (*CrosslinkRecord) ProtoMessage()    {}
 func (*CrosslinkRecord) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{9}
+	return fileDescriptor_types_8bf51971738cd628, []int{9}
 }
 func (m *CrosslinkRecord) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -956,7 +956,7 @@ func (m *ShardAndCommitteeArray) Reset()         { *m = ShardAndCommitteeArray{}
 func (m *ShardAndCommitteeArray) String() string { return proto.CompactTextString(m) }
 func (*ShardAndCommitteeArray) ProtoMessage()    {}
 func (*ShardAndCommitteeArray) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{10}
+	return fileDescriptor_types_8bf51971738cd628, []int{10}
 }
 func (m *ShardAndCommitteeArray) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1005,7 +1005,7 @@ func (m *ShardAndCommittee) Reset()         { *m = ShardAndCommittee{} }
 func (m *ShardAndCommittee) String() string { return proto.CompactTextString(m) }
 func (*ShardAndCommittee) ProtoMessage()    {}
 func (*ShardAndCommittee) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{11}
+	return fileDescriptor_types_8bf51971738cd628, []int{11}
 }
 func (m *ShardAndCommittee) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1073,7 +1073,7 @@ func (m *BeaconBlock) Reset()         { *m = BeaconBlock{} }
 func (m *BeaconBlock) String() string { return proto.CompactTextString(m) }
 func (*BeaconBlock) ProtoMessage()    {}
 func (*BeaconBlock) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{12}
+	return fileDescriptor_types_8bf51971738cd628, []int{12}
 }
 func (m *BeaconBlock) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1174,7 +1174,7 @@ func (m *BeaconBlockBody) Reset()         { *m = BeaconBlockBody{} }
 func (m *BeaconBlockBody) String() string { return proto.CompactTextString(m) }
 func (*BeaconBlockBody) ProtoMessage()    {}
 func (*BeaconBlockBody) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{13}
+	return fileDescriptor_types_8bf51971738cd628, []int{13}
 }
 func (m *BeaconBlockBody) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1252,7 +1252,7 @@ func (m *DepositParameters) Reset()         { *m = DepositParameters{} }
 func (m *DepositParameters) String() string { return proto.CompactTextString(m) }
 func (*DepositParameters) ProtoMessage()    {}
 func (*DepositParameters) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{14}
+	return fileDescriptor_types_8bf51971738cd628, []int{14}
 }
 func (m *DepositParameters) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1322,7 +1322,7 @@ func (m *ProposalSignedData) Reset()         { *m = ProposalSignedData{} }
 func (m *ProposalSignedData) String() string { return proto.CompactTextString(m) }
 func (*ProposalSignedData) ProtoMessage()    {}
 func (*ProposalSignedData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{15}
+	return fileDescriptor_types_8bf51971738cd628, []int{15}
 }
 func (m *ProposalSignedData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1386,7 +1386,7 @@ func (m *SlashableVoteData) Reset()         { *m = SlashableVoteData{} }
 func (m *SlashableVoteData) String() string { return proto.CompactTextString(m) }
 func (*SlashableVoteData) ProtoMessage()    {}
 func (*SlashableVoteData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{16}
+	return fileDescriptor_types_8bf51971738cd628, []int{16}
 }
 func (m *SlashableVoteData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1456,7 +1456,7 @@ func (m *DepositData) Reset()         { *m = DepositData{} }
 func (m *DepositData) String() string { return proto.CompactTextString(m) }
 func (*DepositData) ProtoMessage()    {}
 func (*DepositData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{17}
+	return fileDescriptor_types_8bf51971738cd628, []int{17}
 }
 func (m *DepositData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1521,7 +1521,7 @@ func (m *ProposerSlashing) Reset()         { *m = ProposerSlashing{} }
 func (m *ProposerSlashing) String() string { return proto.CompactTextString(m) }
 func (*ProposerSlashing) ProtoMessage()    {}
 func (*ProposerSlashing) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{18}
+	return fileDescriptor_types_8bf51971738cd628, []int{18}
 }
 func (m *ProposerSlashing) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1597,7 +1597,7 @@ func (m *CasperSlashing) Reset()         { *m = CasperSlashing{} }
 func (m *CasperSlashing) String() string { return proto.CompactTextString(m) }
 func (*CasperSlashing) ProtoMessage()    {}
 func (*CasperSlashing) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{19}
+	return fileDescriptor_types_8bf51971738cd628, []int{19}
 }
 func (m *CasperSlashing) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1653,7 +1653,7 @@ func (m *Deposit) Reset()         { *m = Deposit{} }
 func (m *Deposit) String() string { return proto.CompactTextString(m) }
 func (*Deposit) ProtoMessage()    {}
 func (*Deposit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{20}
+	return fileDescriptor_types_8bf51971738cd628, []int{20}
 }
 func (m *Deposit) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1716,7 +1716,7 @@ func (m *Exit) Reset()         { *m = Exit{} }
 func (m *Exit) String() string { return proto.CompactTextString(m) }
 func (*Exit) ProtoMessage()    {}
 func (*Exit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_types_aae01fd3d2e90d2d, []int{21}
+	return fileDescriptor_types_8bf51971738cd628, []int{21}
 }
 func (m *Exit) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1923,12 +1923,12 @@ func (m *BeaconState) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintTypes(dAtA, i, uint64(m.JustifiedSlot))
 	}
-	if m.JustifiedSlotBitfield != 0 {
+	if m.JustificationBitfield != 0 {
 		dAtA[i] = 0x98
 		i++
 		dAtA[i] = 0x7d
 		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.JustifiedSlotBitfield))
+		i = encodeVarintTypes(dAtA, i, uint64(m.JustificationBitfield))
 	}
 	if m.FinalizedSlot != 0 {
 		dAtA[i] = 0xa0
@@ -2157,10 +2157,10 @@ func (m *CandidatePoWReceiptRootRecord) MarshalTo(dAtA []byte) (int, error) {
 		i = encodeVarintTypes(dAtA, i, uint64(len(m.CandidatePowReceiptRootHash32)))
 		i += copy(dAtA[i:], m.CandidatePowReceiptRootHash32)
 	}
-	if m.Votes != 0 {
+	if m.VoteCount != 0 {
 		dAtA[i] = 0x10
 		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.Votes))
+		i = encodeVarintTypes(dAtA, i, uint64(m.VoteCount))
 	}
 	if m.XXX_unrecognized != nil {
 		i += copy(dAtA[i:], m.XXX_unrecognized)
@@ -3182,8 +3182,8 @@ func (m *BeaconState) Size() (n int) {
 	if m.JustifiedSlot != 0 {
 		n += 2 + sovTypes(uint64(m.JustifiedSlot))
 	}
-	if m.JustifiedSlotBitfield != 0 {
-		n += 2 + sovTypes(uint64(m.JustifiedSlotBitfield))
+	if m.JustificationBitfield != 0 {
+		n += 2 + sovTypes(uint64(m.JustificationBitfield))
 	}
 	if m.FinalizedSlot != 0 {
 		n += 2 + sovTypes(uint64(m.FinalizedSlot))
@@ -3276,8 +3276,8 @@ func (m *CandidatePoWReceiptRootRecord) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.Votes != 0 {
-		n += 1 + sovTypes(uint64(m.Votes))
+	if m.VoteCount != 0 {
+		n += 1 + sovTypes(uint64(m.VoteCount))
 	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
@@ -4157,9 +4157,9 @@ func (m *BeaconState) Unmarshal(dAtA []byte) error {
 			}
 		case 2003:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field JustifiedSlotBitfield", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field JustificationBitfield", wireType)
 			}
-			m.JustifiedSlotBitfield = 0
+			m.JustificationBitfield = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -4169,7 +4169,7 @@ func (m *BeaconState) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.JustifiedSlotBitfield |= (uint64(b) & 0x7F) << shift
+				m.JustificationBitfield |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -4740,9 +4740,9 @@ func (m *CandidatePoWReceiptRootRecord) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Votes", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field VoteCount", wireType)
 			}
-			m.Votes = 0
+			m.VoteCount = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowTypes
@@ -4752,7 +4752,7 @@ func (m *CandidatePoWReceiptRootRecord) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.Votes |= (uint64(b) & 0x7F) << shift
+				m.VoteCount |= (uint64(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
@@ -7988,152 +7988,152 @@ var (
 )
 
 func init() {
-	proto.RegisterFile("proto/beacon/p2p/v1/types.proto", fileDescriptor_types_aae01fd3d2e90d2d)
+	proto.RegisterFile("proto/beacon/p2p/v1/types.proto", fileDescriptor_types_8bf51971738cd628)
 }
 
-var fileDescriptor_types_aae01fd3d2e90d2d = []byte{
-	// 2274 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x6f, 0x1c, 0x49,
-	0x15, 0xa7, 0xed, 0xb1, 0x9d, 0xbc, 0xb1, 0x3d, 0x33, 0xe5, 0xc4, 0xee, 0xd8, 0x71, 0xec, 0xed,
-	0xc0, 0xc6, 0x09, 0x30, 0x8e, 0x27, 0x8a, 0x02, 0x44, 0xcb, 0xca, 0x63, 0x27, 0x1b, 0x43, 0x48,
-	0x4c, 0x7b, 0x92, 0x2c, 0x12, 0x52, 0xab, 0xa6, 0xbb, 0x66, 0xdc, 0x71, 0x4f, 0x57, 0xd3, 0x55,
-	0xe3, 0xd8, 0x20, 0x76, 0x6f, 0x48, 0xc0, 0x01, 0x71, 0x40, 0x20, 0x71, 0x02, 0xfe, 0x02, 0x8e,
-	0x7c, 0x9d, 0x10, 0x12, 0x47, 0xbe, 0x2e, 0x1c, 0x40, 0x28, 0x27, 0xbe, 0xaf, 0x5c, 0x51, 0x7d,
-	0xf4, 0xc7, 0x7c, 0xc6, 0x59, 0x2e, 0x9c, 0x66, 0xfa, 0xbd, 0xdf, 0x7b, 0xf5, 0xfa, 0xd5, 0xfb,
-	0x6c, 0x58, 0x8b, 0x62, 0xca, 0xe9, 0x66, 0x93, 0x60, 0x97, 0x86, 0x9b, 0x51, 0x2d, 0xda, 0x3c,
-	0xde, 0xda, 0xe4, 0xa7, 0x11, 0x61, 0x55, 0xc9, 0x41, 0x8b, 0x84, 0x1f, 0x92, 0x98, 0x74, 0x3b,
-	0x55, 0x85, 0xa9, 0x46, 0xb5, 0xa8, 0x7a, 0xbc, 0xb5, 0xbc, 0xd6, 0xa6, 0xb4, 0x1d, 0x90, 0x4d,
-	0x89, 0x6a, 0x76, 0x5b, 0x9b, 0xdc, 0xef, 0x10, 0xc6, 0x71, 0x27, 0x52, 0x82, 0xcb, 0x2b, 0x4a,
-	0xb3, 0x4b, 0x3b, 0x1d, 0x1a, 0x6e, 0x76, 0x08, 0x63, 0xb8, 0x9d, 0x68, 0xb5, 0x7e, 0x39, 0x0f,
-	0xc5, 0xba, 0xd4, 0x77, 0xc0, 0x31, 0x27, 0xe8, 0x29, 0xa0, 0x63, 0x1c, 0xf8, 0x1e, 0xe6, 0x34,
-	0x76, 0x62, 0xd2, 0xf6, 0x19, 0x8f, 0x4f, 0x4d, 0x63, 0x7d, 0x72, 0xa3, 0x58, 0xbb, 0x56, 0x1d,
-	0x6e, 0x42, 0xf5, 0x69, 0x22, 0x61, 0x13, 0x97, 0xc6, 0x9e, 0x5d, 0x39, 0xce, 0x08, 0x4a, 0x03,
-	0x7a, 0x08, 0x57, 0x07, 0xf5, 0x3a, 0x01, 0x66, 0xdc, 0x71, 0x0f, 0x71, 0xd8, 0x26, 0x0e, 0x0b,
-	0x28, 0x37, 0x27, 0xd6, 0x8d, 0x8d, 0x82, 0xbd, 0x36, 0x20, 0xff, 0x10, 0x33, 0xbe, 0x23, 0x71,
-	0x07, 0x01, 0xe5, 0x68, 0x1b, 0x56, 0x87, 0x68, 0x23, 0x27, 0x3e, 0x77, 0x5c, 0xda, 0x0d, 0xb9,
-	0x39, 0x29, 0xf5, 0x2c, 0x0f, 0xe8, 0xb9, 0x77, 0xe2, 0xf3, 0x1d, 0x81, 0x40, 0xcf, 0xe0, 0xfa,
-	0x10, 0x15, 0x1e, 0x09, 0x38, 0x16, 0x16, 0xf9, 0xa1, 0xc3, 0xfd, 0xc8, 0x39, 0xc4, 0xec, 0xf0,
-	0x56, 0xcd, 0x2c, 0xac, 0x1b, 0x1b, 0xb3, 0xf6, 0x87, 0x07, 0xd4, 0xed, 0x0a, 0xf8, 0x8e, 0x40,
-	0x37, 0xfc, 0xe8, 0x81, 0xc4, 0xa2, 0x8f, 0xe7, 0x3d, 0xd8, 0xc4, 0x01, 0x0e, 0x5d, 0xc2, 0xcc,
-	0xa9, 0xf5, 0xc9, 0x8d, 0x42, 0xce, 0x31, 0x75, 0xcd, 0x40, 0x1f, 0x85, 0x4a, 0x8c, 0x43, 0x0f,
-	0x53, 0xa7, 0xe3, 0x9f, 0x24, 0xe7, 0xfd, 0x6d, 0x46, 0x1e, 0x58, 0x52, 0x9c, 0xcf, 0xf9, 0x27,
-	0x5a, 0xf7, 0x75, 0x28, 0x87, 0xe4, 0x84, 0x3b, 0x8c, 0x10, 0x2f, 0xc1, 0xfe, 0x5d, 0x61, 0xe7,
-	0x05, 0xe3, 0x80, 0x10, 0x4f, 0x43, 0xbf, 0x04, 0xab, 0xec, 0x10, 0xc7, 0x9e, 0x83, 0x43, 0xcf,
-	0x11, 0x77, 0xef, 0x73, 0x4e, 0x08, 0x73, 0x30, 0x97, 0x9e, 0x66, 0xe6, 0x3f, 0x66, 0xe4, 0xa5,
-	0x56, 0x47, 0x5d, 0xea, 0x81, 0x90, 0xde, 0x0e, 0xbd, 0x9d, 0x44, 0x76, 0x3b, 0x8e, 0xf1, 0xa9,
-	0x7d, 0x89, 0xf5, 0xd3, 0xd9, 0x36, 0x17, 0x97, 0xc2, 0xd0, 0xe7, 0xe1, 0x62, 0x44, 0x62, 0xe6,
-	0x33, 0x4e, 0x42, 0x9e, 0x3b, 0xd3, 0xfc, 0xa7, 0x3a, 0x6a, 0x25, 0x3b, 0x4a, 0x05, 0x63, 0xf5,
-	0x89, 0x1f, 0xf2, 0x5b, 0xb5, 0x87, 0x3e, 0xe3, 0xf6, 0x85, 0x4c, 0x34, 0xd3, 0x8c, 0xde, 0x03,
-	0x6b, 0x98, 0x4a, 0x27, 0x26, 0x98, 0x31, 0xbf, 0x1d, 0x76, 0x48, 0xc8, 0x99, 0xf9, 0x2f, 0xa5,
-	0x7f, 0x73, 0xec, 0xab, 0xd8, 0x39, 0x11, 0x1d, 0xa7, 0xeb, 0x43, 0xce, 0xcc, 0xc3, 0x18, 0xba,
-	0x03, 0x4b, 0x51, 0x4c, 0x8e, 0x7d, 0xda, 0x65, 0xce, 0xf3, 0x2e, 0xe3, 0x7e, 0xcb, 0x27, 0x9e,
-	0x0a, 0xd5, 0xdf, 0x96, 0x64, 0x8c, 0x5d, 0x4c, 0xf8, 0x9f, 0x49, 0xd8, 0x32, 0x42, 0xdf, 0x84,
-	0xf9, 0x3e, 0xfc, 0xef, 0x14, 0x7e, 0xee, 0x79, 0x0f, 0xee, 0x0e, 0x2c, 0xf5, 0xe2, 0x9c, 0xa6,
-	0xcf, 0x5b, 0x3e, 0x09, 0x3c, 0xf3, 0xf7, 0xfa, 0x80, 0x1e, 0x81, 0xba, 0xe6, 0x8a, 0x03, 0x5a,
-	0x7e, 0x88, 0x03, 0xff, 0xcb, 0xc9, 0x01, 0x7f, 0xd0, 0x07, 0xa4, 0x64, 0x79, 0xc0, 0x13, 0xa8,
-	0x04, 0x98, 0x13, 0x91, 0x67, 0x31, 0x65, 0x2c, 0xf0, 0xc3, 0x23, 0x66, 0xfe, 0x64, 0x69, 0x7c,
-	0x42, 0xef, 0x24, 0x50, 0xed, 0xa8, 0xb2, 0x52, 0x91, 0x92, 0x19, 0xaa, 0xc3, 0xaa, 0x4c, 0x5e,
-	0x26, 0xaa, 0x86, 0x13, 0x13, 0x17, 0x07, 0x6e, 0x37, 0xc0, 0xdc, 0xa7, 0xa1, 0xb2, 0xe6, 0xa7,
-	0x4b, 0x2a, 0x05, 0x05, 0x4a, 0x96, 0x16, 0x3b, 0x8f, 0x91, 0xa6, 0x7d, 0x0a, 0x2e, 0x69, 0xd3,
-	0x9a, 0x01, 0x75, 0x8f, 0x9c, 0x98, 0x52, 0xae, 0xa3, 0x9a, 0x99, 0x3f, 0x13, 0x26, 0xce, 0xda,
-	0x8b, 0x0a, 0x51, 0x17, 0x00, 0x9b, 0x52, 0xae, 0xa2, 0x9b, 0xa1, 0x5d, 0xb8, 0xa2, 0x65, 0x23,
-	0x92, 0x78, 0x41, 0xe6, 0x7f, 0x9a, 0x71, 0x3f, 0x5f, 0x92, 0x29, 0xb7, 0xa2, 0x60, 0xfb, 0x09,
-	0x4a, 0x54, 0x80, 0x34, 0xf9, 0x9a, 0xb0, 0xa0, 0xb5, 0x60, 0x2e, 0x7e, 0xa4, 0x6d, 0xcc, 0xfc,
-	0x85, 0x72, 0xcf, 0xcd, 0x51, 0xee, 0xd9, 0x27, 0xa1, 0xe7, 0x87, 0xed, 0xed, 0x4c, 0x46, 0xfb,
-	0x09, 0x29, 0x6d, 0x39, 0x06, 0x43, 0x7b, 0xf0, 0x46, 0x14, 0x53, 0x97, 0x30, 0x46, 0x3c, 0x27,
-	0xa2, 0x2f, 0x84, 0xb3, 0x88, 0x1f, 0xf1, 0xfc, 0xeb, 0x9a, 0x3f, 0x58, 0x93, 0x49, 0xbc, 0x9a,
-	0x22, 0xf7, 0xe9, 0x0b, 0x5b, 0xe1, 0xb2, 0xb7, 0x46, 0x5d, 0x58, 0x71, 0x71, 0xe8, 0x89, 0x0a,
-	0x42, 0x06, 0x54, 0x31, 0xf3, 0x87, 0x6b, 0xd2, 0xec, 0xdb, 0x23, 0x6f, 0x35, 0x91, 0xdd, 0xa7,
-	0xcf, 0x72, 0xca, 0xb5, 0xed, 0xa6, 0x9b, 0xb1, 0xf3, 0x67, 0x33, 0x64, 0xc1, 0x6c, 0x9b, 0x84,
-	0x84, 0xf9, 0xcc, 0x11, 0xbd, 0xc5, 0xfc, 0xfa, 0x35, 0x79, 0xb5, 0x45, 0x4d, 0x6c, 0xf8, 0x1d,
-	0x82, 0x3e, 0x0d, 0xe7, 0x5b, 0x34, 0x3e, 0x72, 0x3c, 0xcc, 0xb1, 0xf9, 0x0d, 0x01, 0x28, 0xd6,
-	0xd6, 0x47, 0x19, 0x72, 0x9f, 0xc6, 0x47, 0xbb, 0x98, 0x63, 0xfb, 0x5c, 0x4b, 0xff, 0x43, 0x0b,
-	0x50, 0x90, 0x61, 0xf3, 0x4d, 0xa5, 0x5b, 0x3e, 0xa0, 0x2a, 0x94, 0x73, 0xc9, 0xc1, 0x63, 0x82,
-	0x8f, 0xcc, 0xef, 0x3e, 0x12, 0x80, 0xfa, 0x84, 0x69, 0xd8, 0xa5, 0x2c, 0x33, 0x24, 0x0f, 0xbd,
-	0x80, 0x2b, 0x43, 0x6b, 0x5e, 0x8b, 0xc6, 0xba, 0xe8, 0xfd, 0xe8, 0xd1, 0x07, 0x29, 0x7a, 0xf2,
-	0xb4, 0xe5, 0xc1, 0xc2, 0x77, 0x9f, 0xc6, 0xb2, 0xf2, 0x59, 0x5f, 0x85, 0x73, 0xc9, 0x3b, 0xa1,
-	0x0d, 0x28, 0x47, 0x31, 0x71, 0xa4, 0x37, 0x8e, 0x45, 0x7d, 0xa1, 0xa1, 0x69, 0xc8, 0x97, 0x9a,
-	0x8f, 0x62, 0x22, 0x60, 0x4f, 0x15, 0x15, 0xdd, 0x80, 0x4a, 0x44, 0x19, 0xef, 0x85, 0xaa, 0x0e,
-	0x58, 0x12, 0x8c, 0x3c, 0x76, 0x45, 0xfb, 0x57, 0x3a, 0x49, 0x75, 0x37, 0xe9, 0x3c, 0x71, 0xbe,
-	0xf5, 0x3e, 0xac, 0x8e, 0xbd, 0x5b, 0xf4, 0x00, 0xde, 0x18, 0x1d, 0x38, 0x49, 0x0c, 0x1a, 0x2a,
-	0x04, 0x47, 0x84, 0x81, 0x0e, 0xc1, 0x0b, 0x30, 0x75, 0x4c, 0x39, 0x61, 0xda, 0x4e, 0xf5, 0x60,
-	0xfd, 0xd9, 0x00, 0x73, 0x54, 0x52, 0xa0, 0xbb, 0x50, 0x90, 0x51, 0x61, 0xc8, 0xa0, 0x18, 0x59,
-	0x73, 0x72, 0x82, 0x32, 0x36, 0xa4, 0x10, 0xba, 0x0d, 0x8b, 0x11, 0x8e, 0xb9, 0xef, 0xfa, 0x91,
-	0x2a, 0x2e, 0x69, 0x79, 0x9c, 0x90, 0xe6, 0x5e, 0xec, 0xe1, 0xa6, 0xd5, 0xf1, 0x3a, 0x94, 0xdd,
-	0x2e, 0xe3, 0xd4, 0x3b, 0xcd, 0x04, 0x26, 0x55, 0x4f, 0xd5, 0xf4, 0x14, 0x7a, 0x15, 0xe6, 0x64,
-	0xdd, 0xf5, 0x43, 0x37, 0xe8, 0x7a, 0xc4, 0x93, 0xcd, 0xbe, 0x60, 0xcf, 0x0a, 0xe2, 0x9e, 0xa6,
-	0x59, 0x7f, 0x32, 0xa0, 0x98, 0x33, 0xf0, 0xff, 0xfd, 0x9d, 0x36, 0x61, 0x01, 0xb7, 0xdb, 0x31,
-	0x69, 0x8b, 0xfb, 0x16, 0xdd, 0x0c, 0xf3, 0x6e, 0x4c, 0xf4, 0x18, 0x83, 0x52, 0xd6, 0x41, 0xc2,
-	0xb1, 0xbe, 0x35, 0x09, 0xa5, 0x3e, 0x63, 0x11, 0xd2, 0x29, 0x69, 0xe4, 0x32, 0xf2, 0x02, 0x4c,
-	0xc9, 0x34, 0x48, 0xae, 0x5f, 0x3e, 0xa0, 0x3b, 0x60, 0xaa, 0xf7, 0x1e, 0x2c, 0xe4, 0xda, 0xc2,
-	0x8b, 0x8a, 0xdf, 0x57, 0xc6, 0xd1, 0x5d, 0x58, 0x26, 0x11, 0x75, 0x0f, 0x9d, 0x26, 0xed, 0x86,
-	0x1e, 0x8e, 0x4f, 0x7b, 0x44, 0x95, 0xb9, 0x4b, 0x12, 0x51, 0xd7, 0x80, 0x9c, 0xf0, 0x6d, 0x58,
-	0x52, 0xd9, 0x3e, 0x78, 0xe8, 0x94, 0x94, 0xbc, 0x20, 0xd9, 0xfd, 0x67, 0xbe, 0x0d, 0x97, 0xfb,
-	0x1b, 0x62, 0x8f, 0xec, 0xb4, 0x94, 0xbd, 0xd4, 0xd7, 0xf1, 0x72, 0x0a, 0x3e, 0x32, 0xd0, 0xda,
-	0x67, 0x86, 0x75, 0xf6, 0xb7, 0x60, 0x25, 0x83, 0x0d, 0x9a, 0x78, 0x4e, 0x1e, 0x63, 0xa6, 0x90,
-	0x3e, 0x33, 0xad, 0xaf, 0x15, 0xa0, 0xd4, 0x37, 0x57, 0xa3, 0x45, 0x98, 0x8e, 0xba, 0xcd, 0x23,
-	0x72, 0xaa, 0x73, 0x55, 0x3f, 0x89, 0x80, 0x7a, 0xe1, 0xf3, 0x43, 0x2f, 0xc6, 0x2f, 0x70, 0xe0,
-	0xb8, 0x31, 0xf1, 0x48, 0xc8, 0x7d, 0x1c, 0xb0, 0x24, 0xa0, 0x32, 0xee, 0x4e, 0xc6, 0x44, 0x9f,
-	0x00, 0x53, 0x8f, 0x9e, 0xaa, 0x56, 0x8a, 0x91, 0xa7, 0xf7, 0xda, 0x16, 0x15, 0x7f, 0x27, 0x65,
-	0x6b, 0x17, 0x5c, 0x85, 0x39, 0x2d, 0x19, 0xe0, 0x53, 0x12, 0xb3, 0x24, 0x67, 0x14, 0xf1, 0xa1,
-	0xa4, 0xa1, 0xcf, 0xc2, 0xb4, 0x08, 0xa7, 0x2e, 0x93, 0xd7, 0x31, 0x5f, 0xbb, 0x75, 0xc6, 0xf5,
-	0xa1, 0x7a, 0x20, 0xa5, 0x76, 0xa8, 0x47, 0x98, 0xad, 0x55, 0xa0, 0x4f, 0xa6, 0xb3, 0x82, 0x22,
-	0xf4, 0x6c, 0x0d, 0xd3, 0xf2, 0x74, 0x3d, 0x2a, 0x68, 0xe9, 0x6c, 0x59, 0x58, 0x05, 0xc8, 0x6d,
-	0x06, 0xea, 0xae, 0xce, 0x93, 0x74, 0x11, 0x58, 0x85, 0x19, 0x3d, 0x33, 0x98, 0x7f, 0x9d, 0x49,
-	0x7b, 0x4b, 0x42, 0xb3, 0xde, 0x87, 0x62, 0xce, 0x1e, 0xb4, 0x08, 0x68, 0xff, 0xde, 0xa3, 0xdd,
-	0xbd, 0x47, 0xef, 0x38, 0xdb, 0x3b, 0x8d, 0xbd, 0xa7, 0xdb, 0x8d, 0xbd, 0xc7, 0x8f, 0xca, 0x1f,
-	0x42, 0x00, 0xd3, 0xf2, 0xf9, 0x5e, 0xd9, 0x40, 0x4b, 0xb0, 0xa0, 0xfe, 0x3b, 0x09, 0xf4, 0xde,
-	0xbb, 0x7b, 0x8d, 0xf2, 0x04, 0x5a, 0x86, 0x45, 0xf1, 0xef, 0xde, 0xae, 0xf3, 0x6c, 0xaf, 0xf1,
-	0xe0, 0xf1, 0x93, 0x86, 0x00, 0x6c, 0x3f, 0x6c, 0x7c, 0xa1, 0x3c, 0x29, 0x84, 0x72, 0xbc, 0x94,
-	0x51, 0xb0, 0x02, 0x58, 0x1a, 0x31, 0xbf, 0xa2, 0x6b, 0x50, 0xca, 0x56, 0x0d, 0x3f, 0xf4, 0xc8,
-	0x89, 0x0c, 0x8c, 0x39, 0x7b, 0x3e, 0x25, 0xef, 0x09, 0xea, 0x88, 0xb4, 0x4d, 0x12, 0x7c, 0x32,
-	0x4b, 0x70, 0xeb, 0x6d, 0x98, 0x3b, 0x88, 0x88, 0xeb, 0xe3, 0x20, 0x8d, 0xb9, 0xc2, 0x91, 0x1f,
-	0x7a, 0x4a, 0xb1, 0x74, 0x8d, 0x7c, 0x16, 0x74, 0x59, 0x01, 0x27, 0xc4, 0x98, 0xa6, 0xe8, 0xe2,
-	0xd9, 0xfa, 0x22, 0x94, 0xfa, 0xa6, 0xc7, 0xa1, 0x85, 0x64, 0x4c, 0xf2, 0x4e, 0x8c, 0x4e, 0x5e,
-	0xeb, 0x3d, 0x58, 0x1c, 0xde, 0xa2, 0x91, 0x07, 0x97, 0xb0, 0xf8, 0xe3, 0x0c, 0x99, 0x00, 0xf4,
-	0xfe, 0x7a, 0xfd, 0xcc, 0x5d, 0xdf, 0x5e, 0x94, 0xba, 0x06, 0xe8, 0xd6, 0x57, 0xa0, 0x32, 0x40,
-	0xcc, 0xbc, 0x6b, 0xe4, 0xbd, 0x7b, 0x19, 0xce, 0x67, 0x06, 0x08, 0x2f, 0xcd, 0xd9, 0x19, 0x01,
-	0xd5, 0xe0, 0x22, 0xa7, 0x1c, 0x07, 0x4e, 0x76, 0x81, 0xf9, 0xcd, 0x75, 0x41, 0x32, 0xd3, 0xc4,
-	0x90, 0x91, 0x6a, 0x7d, 0x7b, 0x32, 0xd9, 0xd5, 0xa5, 0x5b, 0x86, 0xfa, 0xf5, 0x63, 0x80, 0x22,
-	0x1c, 0x8b, 0x44, 0x1e, 0x74, 0x69, 0x59, 0x71, 0x72, 0xa5, 0xec, 0x06, 0x54, 0xf4, 0x00, 0x3f,
-	0x50, 0xb1, 0x4b, 0x92, 0x91, 0xc3, 0xde, 0x84, 0x0b, 0x3a, 0xe7, 0x63, 0x72, 0x4c, 0x70, 0xd0,
-	0x5b, 0xa5, 0x91, 0xe2, 0xd9, 0x92, 0xa5, 0x25, 0xce, 0x34, 0x75, 0x4c, 0x9d, 0x65, 0xea, 0xb8,
-	0x0c, 0xe7, 0xb3, 0x2e, 0x36, 0x2d, 0x17, 0x83, 0x8c, 0x20, 0x9a, 0x71, 0x93, 0x7a, 0xa7, 0x32,
-	0xb5, 0xc7, 0x34, 0xe3, 0x9c, 0xeb, 0xea, 0xd4, 0x3b, 0xb5, 0xa5, 0x10, 0x7a, 0x0b, 0xce, 0xa7,
-	0x1f, 0x4c, 0xcc, 0x7f, 0x2b, 0x15, 0xcb, 0x55, 0xf5, 0x4d, 0xa5, 0x9a, 0x7c, 0x53, 0xa9, 0x36,
-	0x12, 0x88, 0x8c, 0xf4, 0x4c, 0xc2, 0xfa, 0xcf, 0x04, 0x94, 0xfa, 0x14, 0xa3, 0x77, 0x60, 0xb6,
-	0x67, 0x9d, 0x50, 0xd1, 0x77, 0xf5, 0x0c, 0x43, 0x82, 0xdd, 0x23, 0x88, 0x9e, 0x01, 0x8a, 0x62,
-	0x1a, 0x51, 0x46, 0xc4, 0xfc, 0x8a, 0xd9, 0xa1, 0x1f, 0xb6, 0x99, 0x8c, 0xa5, 0x62, 0x6d, 0x63,
-	0xe4, 0x72, 0xa2, 0x25, 0x0e, 0xb4, 0x80, 0x5d, 0x89, 0xfa, 0x28, 0x62, 0x53, 0x2f, 0xbb, 0x98,
-	0x45, 0x3d, 0x6a, 0x27, 0xa5, 0xda, 0x37, 0x47, 0x2f, 0x0f, 0x02, 0x9f, 0x2a, 0x2d, 0xb9, 0x3d,
-	0xcf, 0x0c, 0xdd, 0x85, 0x73, 0x1e, 0x89, 0x28, 0xf3, 0xb9, 0xe8, 0x06, 0x42, 0xd5, 0xda, 0x28,
-	0x55, 0xbb, 0x0a, 0x67, 0xa7, 0x02, 0xa8, 0x06, 0x53, 0xa2, 0x20, 0xab, 0xcf, 0x24, 0xc5, 0xda,
-	0xe5, 0x51, 0x92, 0x62, 0x79, 0xb3, 0x15, 0xd4, 0xfa, 0xa3, 0x01, 0x15, 0xad, 0x69, 0x1f, 0xc7,
-	0xb8, 0x43, 0xb8, 0x68, 0x3a, 0xa3, 0x5a, 0x64, 0x15, 0x16, 0xa2, 0x98, 0xd2, 0x96, 0x43, 0x5b,
-	0x4e, 0x44, 0x19, 0x23, 0x2c, 0x9d, 0xb6, 0x67, 0xa5, 0x87, 0x68, 0xeb, 0x71, 0x6b, 0x3f, 0x65,
-	0x88, 0xfd, 0x76, 0x78, 0x4b, 0xed, 0xcd, 0x92, 0x95, 0xa1, 0x9d, 0x55, 0x47, 0xed, 0xb8, 0xfe,
-	0x5a, 0x18, 0xd7, 0x5f, 0xad, 0xe7, 0x80, 0xd4, 0x35, 0xe2, 0x40, 0xcc, 0x68, 0xc4, 0x7b, 0xcd,
-	0x81, 0xec, 0x06, 0x54, 0x46, 0x4d, 0x62, 0xa5, 0x66, 0x5f, 0x49, 0xfd, 0xce, 0x04, 0x54, 0xe4,
-	0x35, 0xe2, 0x66, 0x40, 0x9e, 0x52, 0x4e, 0xe4, 0x59, 0x0f, 0xe0, 0x8d, 0x21, 0x13, 0xa4, 0x13,
-	0x51, 0xd7, 0xb9, 0x29, 0x5a, 0x8d, 0x2f, 0x56, 0x6c, 0x43, 0x56, 0xb5, 0xd5, 0xc1, 0x79, 0x72,
-	0x9f, 0xba, 0x37, 0xf7, 0x14, 0x68, 0x9c, 0xa6, 0xad, 0x54, 0xd3, 0xc4, 0x18, 0x4d, 0x5b, 0x89,
-	0xa6, 0x64, 0xe8, 0x9e, 0xfc, 0x20, 0x43, 0xf7, 0x6b, 0x8f, 0xc4, 0xdf, 0x37, 0xa0, 0xa8, 0xe3,
-	0x4b, 0x7a, 0xe4, 0x5d, 0x40, 0x3a, 0x5e, 0x9d, 0x28, 0x8d, 0x37, 0xbd, 0x00, 0x5c, 0x7f, 0x45,
-	0xa8, 0x67, 0x01, 0x6a, 0x57, 0xbc, 0x81, 0x98, 0x15, 0x3b, 0x15, 0x0e, 0xba, 0x24, 0xdd, 0xa9,
-	0xc4, 0x83, 0xa8, 0x79, 0x59, 0x61, 0x52, 0x5d, 0x21, 0x57, 0x77, 0x7e, 0x35, 0x01, 0xe5, 0xfe,
-	0x4c, 0x17, 0x93, 0x69, 0x5a, 0x2f, 0xf2, 0xe3, 0xc0, 0x5c, 0x42, 0x55, 0xd3, 0x80, 0x0d, 0xa5,
-	0x48, 0x47, 0x97, 0xdc, 0xd7, 0x9d, 0x2d, 0x79, 0x72, 0xb1, 0x76, 0x63, 0x7c, 0x4d, 0xc9, 0x07,
-	0x63, 0xa2, 0x13, 0x07, 0xe2, 0x69, 0x4b, 0x74, 0x87, 0x54, 0x67, 0x76, 0xc9, 0x5b, 0x3a, 0xe8,
-	0x50, 0x94, 0x53, 0x20, 0x59, 0x5b, 0x83, 0x56, 0xa8, 0xa4, 0xf8, 0x1f, 0xac, 0xa8, 0x8d, 0xb0,
-	0x22, 0x69, 0x32, 0x83, 0x56, 0xd4, 0xac, 0xef, 0x19, 0x30, 0xdf, 0x5b, 0xda, 0x50, 0x1d, 0x66,
-	0xe4, 0x56, 0xeb, 0x6c, 0xbd, 0xea, 0x76, 0x07, 0xd2, 0xc6, 0x9e, 0x96, 0x92, 0x5b, 0x99, 0x8e,
-	0x9a, 0x76, 0xed, 0x6b, 0xeb, 0xa8, 0x59, 0x3f, 0x36, 0x60, 0x46, 0xc7, 0x8f, 0x18, 0x17, 0x3a,
-	0x24, 0x3e, 0x0a, 0x88, 0xd3, 0x8c, 0x71, 0xe8, 0x1e, 0xa6, 0x9f, 0xc9, 0x0c, 0xd9, 0x0c, 0x17,
-	0x14, 0xb3, 0x2e, 0x79, 0xc9, 0x27, 0xb2, 0x1b, 0x50, 0xd1, 0x32, 0x3c, 0x26, 0x44, 0x07, 0x84,
-	0xfe, 0xbc, 0xa0, 0x18, 0x8d, 0x98, 0x10, 0x15, 0x12, 0xf7, 0x61, 0x36, 0x09, 0xee, 0x5c, 0x8a,
-	0x5d, 0x7d, 0x45, 0x58, 0x4b, 0x73, 0x8b, 0x5e, 0xf6, 0x60, 0x61, 0x28, 0x88, 0x1a, 0x3d, 0xb4,
-	0x54, 0x0d, 0x99, 0x56, 0x95, 0x35, 0xfd, 0xd3, 0x6a, 0x4f, 0xb7, 0x57, 0x01, 0x94, 0x11, 0xea,
-	0xb3, 0xbf, 0x7e, 0x79, 0xc5, 0xf8, 0xcd, 0xcb, 0x2b, 0xc6, 0x5f, 0x5e, 0x5e, 0x31, 0x9a, 0xd3,
-	0xb2, 0x45, 0xdf, 0xfa, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x41, 0x58, 0x9f, 0x53, 0x3f, 0x19,
-	0x00, 0x00,
+var fileDescriptor_types_8bf51971738cd628 = []byte{
+	// 2280 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xc9, 0x6f, 0x1c, 0x5b,
+	0xd5, 0xff, 0xca, 0x6e, 0xdb, 0xf1, 0x69, 0xdb, 0xdd, 0x7d, 0x9d, 0xd8, 0x15, 0x3b, 0x8e, 0x9d,
+	0xca, 0xc7, 0x8b, 0x13, 0xa0, 0x1d, 0x77, 0x14, 0x1e, 0x10, 0x3d, 0x9e, 0xdc, 0x76, 0xf2, 0x62,
+	0x08, 0x89, 0x29, 0x77, 0x92, 0x87, 0x84, 0x54, 0xba, 0x5d, 0x75, 0xbb, 0x5d, 0x71, 0x75, 0xdd,
+	0xa2, 0xee, 0x6d, 0xc7, 0x06, 0xf1, 0xd8, 0x21, 0x86, 0x05, 0x62, 0x81, 0x40, 0x62, 0x05, 0xfc,
+	0x05, 0x2c, 0x99, 0x36, 0x48, 0x48, 0x2c, 0x99, 0x36, 0x2c, 0x40, 0x28, 0x2b, 0xe6, 0x2d, 0x5b,
+	0x74, 0x87, 0x1a, 0x7a, 0x4c, 0xf2, 0xd8, 0xb0, 0xea, 0xae, 0x33, 0xfc, 0xee, 0xa9, 0x73, 0xcf,
+	0x58, 0xb0, 0x1e, 0xc5, 0x94, 0xd3, 0xad, 0x26, 0xc1, 0x2e, 0x0d, 0xb7, 0xa2, 0x5a, 0xb4, 0x75,
+	0xb2, 0xbd, 0xc5, 0xcf, 0x22, 0xc2, 0xaa, 0x92, 0x83, 0x96, 0x08, 0x3f, 0x22, 0x31, 0xe9, 0x76,
+	0xaa, 0x4a, 0xa6, 0x1a, 0xd5, 0xa2, 0xea, 0xc9, 0xf6, 0xca, 0x7a, 0x9b, 0xd2, 0x76, 0x40, 0xb6,
+	0xa4, 0x54, 0xb3, 0xdb, 0xda, 0xe2, 0x7e, 0x87, 0x30, 0x8e, 0x3b, 0x91, 0x52, 0x5c, 0x59, 0x55,
+	0xc8, 0x2e, 0xed, 0x74, 0x68, 0xb8, 0xd5, 0x21, 0x8c, 0xe1, 0x76, 0x82, 0x6a, 0xfd, 0x62, 0x01,
+	0x8a, 0x75, 0x89, 0x77, 0xc8, 0x31, 0x27, 0xe8, 0x09, 0xa0, 0x13, 0x1c, 0xf8, 0x1e, 0xe6, 0x34,
+	0x76, 0x62, 0xd2, 0xf6, 0x19, 0x8f, 0xcf, 0x4c, 0x63, 0x63, 0x72, 0xb3, 0x58, 0xbb, 0x56, 0x1d,
+	0x6e, 0x42, 0xf5, 0x49, 0xa2, 0x61, 0x13, 0x97, 0xc6, 0x9e, 0x5d, 0x39, 0xc9, 0x08, 0x0a, 0x01,
+	0x3d, 0x80, 0xab, 0x83, 0xb8, 0x4e, 0x80, 0x19, 0x77, 0xdc, 0x23, 0x1c, 0xb6, 0x89, 0xc3, 0x02,
+	0xca, 0xcd, 0x89, 0x0d, 0x63, 0xb3, 0x60, 0xaf, 0x0f, 0xe8, 0x3f, 0xc0, 0x8c, 0xef, 0x4a, 0xb9,
+	0xc3, 0x80, 0x72, 0xb4, 0x03, 0x6b, 0x43, 0xd0, 0xc8, 0xa9, 0xcf, 0x1d, 0x97, 0x76, 0x43, 0x6e,
+	0x4e, 0x4a, 0x9c, 0x95, 0x01, 0x9c, 0xbb, 0xa7, 0x3e, 0xdf, 0x15, 0x12, 0xe8, 0x29, 0x5c, 0x1f,
+	0x02, 0xe1, 0x91, 0x80, 0x63, 0x61, 0x91, 0x1f, 0x3a, 0xdc, 0x8f, 0x9c, 0x23, 0xcc, 0x8e, 0x6e,
+	0xd5, 0xcc, 0xc2, 0x86, 0xb1, 0x39, 0x67, 0xff, 0xff, 0x00, 0xdc, 0x9e, 0x10, 0xdf, 0x15, 0xd2,
+	0x0d, 0x3f, 0xba, 0x2f, 0x65, 0xd1, 0x87, 0xf3, 0x1e, 0x6c, 0xe2, 0x00, 0x87, 0x2e, 0x61, 0xe6,
+	0xd4, 0xc6, 0xe4, 0x66, 0x21, 0xe7, 0x98, 0xba, 0x66, 0xa0, 0x0f, 0x42, 0x25, 0xc6, 0xa1, 0x87,
+	0xa9, 0xd3, 0xf1, 0x4f, 0x93, 0xf3, 0xfe, 0x3a, 0x23, 0x0f, 0x2c, 0x29, 0xce, 0xa7, 0xfd, 0x53,
+	0x8d, 0x7d, 0x1d, 0xca, 0x21, 0x39, 0xe5, 0x0e, 0x23, 0xc4, 0x4b, 0x64, 0xff, 0xa6, 0x64, 0x17,
+	0x04, 0xe3, 0x90, 0x10, 0x4f, 0x8b, 0x7e, 0x1e, 0xd6, 0xd8, 0x11, 0x8e, 0x3d, 0x07, 0x87, 0x9e,
+	0x23, 0xee, 0xde, 0xe7, 0x9c, 0x10, 0xe6, 0x60, 0x2e, 0x3d, 0xcd, 0xcc, 0xbf, 0xcf, 0xc8, 0x4b,
+	0xad, 0x8e, 0xba, 0xd4, 0x43, 0xa1, 0xbd, 0x13, 0x7a, 0xbb, 0x89, 0xee, 0x4e, 0x1c, 0xe3, 0x33,
+	0xfb, 0x22, 0xeb, 0xa7, 0xb3, 0x1d, 0x2e, 0x2e, 0x85, 0xa1, 0xcf, 0xc0, 0x85, 0x88, 0xc4, 0xcc,
+	0x67, 0x9c, 0x84, 0x3c, 0x77, 0xa6, 0xf9, 0x0f, 0x75, 0xd4, 0x6a, 0x76, 0x94, 0x0a, 0xc6, 0xea,
+	0x63, 0x3f, 0xe4, 0xb7, 0x6a, 0x0f, 0x7c, 0xc6, 0xed, 0xf3, 0x99, 0x6a, 0x86, 0x8c, 0xde, 0x03,
+	0x6b, 0x18, 0xa4, 0x13, 0x13, 0xcc, 0x98, 0xdf, 0x0e, 0x3b, 0x24, 0xe4, 0xcc, 0xfc, 0xa7, 0xc2,
+	0xdf, 0x1a, 0xfb, 0x2a, 0x76, 0x4e, 0x45, 0xc7, 0xe9, 0xc6, 0x90, 0x33, 0xf3, 0x62, 0x0c, 0xbd,
+	0x09, 0xcb, 0x51, 0x4c, 0x4e, 0x7c, 0xda, 0x65, 0xce, 0xb3, 0x2e, 0xe3, 0x7e, 0xcb, 0x27, 0x9e,
+	0x0a, 0xd5, 0xdf, 0x94, 0x64, 0x8c, 0x5d, 0x48, 0xf8, 0x9f, 0x4c, 0xd8, 0x32, 0x42, 0xdf, 0x80,
+	0x85, 0x3e, 0xf9, 0xdf, 0x2a, 0xf9, 0xf9, 0x67, 0x3d, 0x72, 0x1f, 0x81, 0x25, 0x4d, 0x70, 0x31,
+	0xf7, 0x69, 0xe8, 0x34, 0x7d, 0xde, 0xf2, 0x49, 0xe0, 0x99, 0xbf, 0xd3, 0xf8, 0x3d, 0xec, 0xba,
+	0xe6, 0x0a, 0xfc, 0x96, 0x1f, 0xe2, 0xc0, 0xff, 0x42, 0x82, 0xff, 0x7b, 0x8d, 0x9f, 0x92, 0x25,
+	0xfe, 0x63, 0xa8, 0x04, 0x98, 0x13, 0x91, 0x66, 0x31, 0x65, 0x2c, 0xf0, 0xc3, 0x63, 0x66, 0xfe,
+	0x78, 0x79, 0x7c, 0x3e, 0xef, 0x26, 0xa2, 0xda, 0x4f, 0x65, 0x05, 0x91, 0x92, 0x19, 0xaa, 0xc3,
+	0x9a, 0xcc, 0x5d, 0x26, 0x8a, 0x86, 0x13, 0x13, 0x17, 0x07, 0x6e, 0x37, 0x50, 0x6f, 0x20, 0xad,
+	0xf9, 0xc9, 0xb2, 0xca, 0x40, 0x21, 0x25, 0x2b, 0x8b, 0x9d, 0x97, 0x91, 0xa6, 0x7d, 0x1c, 0x2e,
+	0x6a, 0xd3, 0x9a, 0x01, 0x75, 0x8f, 0x9d, 0x98, 0x52, 0xae, 0x83, 0x9a, 0x99, 0x3f, 0x15, 0x26,
+	0xce, 0xd9, 0x4b, 0x4a, 0xa2, 0x2e, 0x04, 0x6c, 0x4a, 0xb9, 0x0a, 0x6e, 0x86, 0xf6, 0xe0, 0xb2,
+	0xd6, 0x8d, 0x48, 0xe2, 0x05, 0x99, 0xfe, 0x69, 0xc2, 0xfd, 0x6c, 0x59, 0x66, 0xdc, 0xaa, 0x12,
+	0x3b, 0x48, 0xa4, 0x44, 0x01, 0x48, 0x73, 0xaf, 0x09, 0x8b, 0x1a, 0x05, 0x73, 0xf1, 0x23, 0x6d,
+	0x63, 0xe6, 0xcf, 0x95, 0x7b, 0x6e, 0x8e, 0x72, 0xcf, 0x01, 0x09, 0x3d, 0x3f, 0x6c, 0xef, 0x64,
+	0x3a, 0xda, 0x4f, 0x48, 0xa1, 0xe5, 0x18, 0x0c, 0xed, 0xc3, 0x95, 0x28, 0xa6, 0x2e, 0x61, 0x8c,
+	0x78, 0x4e, 0x44, 0x9f, 0x0b, 0x67, 0x11, 0x3f, 0xe2, 0xf9, 0xd7, 0x35, 0xbf, 0xbf, 0x2e, 0x73,
+	0x78, 0x2d, 0x95, 0x3c, 0xa0, 0xcf, 0x6d, 0x25, 0x97, 0xbd, 0x35, 0xea, 0xc2, 0xaa, 0x8b, 0x43,
+	0x4f, 0x14, 0x10, 0x32, 0x00, 0xc5, 0xcc, 0x1f, 0xac, 0x4b, 0xb3, 0x6f, 0x8f, 0xbc, 0xd5, 0x44,
+	0xf7, 0x80, 0x3e, 0xcd, 0x81, 0x6b, 0xdb, 0x4d, 0x37, 0x63, 0xe7, 0xcf, 0x66, 0xc8, 0x82, 0xb9,
+	0x36, 0x09, 0x09, 0xf3, 0x99, 0x23, 0x5a, 0x8b, 0xf9, 0xb5, 0x6b, 0xf2, 0x6a, 0x8b, 0x9a, 0xd8,
+	0xf0, 0x3b, 0x04, 0x7d, 0x02, 0x66, 0x5b, 0x34, 0x3e, 0x76, 0x3c, 0xcc, 0xb1, 0xf9, 0x75, 0x21,
+	0x50, 0xac, 0x6d, 0x8c, 0x32, 0xe4, 0x1e, 0x8d, 0x8f, 0xf7, 0x30, 0xc7, 0xf6, 0xb9, 0x96, 0xfe,
+	0x87, 0x16, 0xa1, 0x20, 0xc3, 0xe6, 0x1b, 0x0a, 0x5b, 0x3e, 0xa0, 0x2a, 0x94, 0x73, 0x39, 0xc4,
+	0x63, 0x82, 0x8f, 0xcd, 0xef, 0x3c, 0x14, 0x02, 0xf5, 0x09, 0xd3, 0xb0, 0x4b, 0x59, 0x26, 0x49,
+	0x1e, 0x7a, 0x0e, 0x97, 0x87, 0x96, 0xbc, 0x16, 0x8d, 0x75, 0xcd, 0xfb, 0xe1, 0xc3, 0xf7, 0x53,
+	0xf3, 0xe4, 0x69, 0x2b, 0x83, 0x75, 0xef, 0x1e, 0x8d, 0x65, 0xe1, 0xb3, 0xbe, 0x04, 0xe7, 0x92,
+	0x77, 0x42, 0x9b, 0x50, 0x8e, 0x62, 0xe2, 0x48, 0x6f, 0x9c, 0x88, 0xf2, 0x42, 0x43, 0xd3, 0x90,
+	0x2f, 0xb5, 0x10, 0xc5, 0x44, 0x88, 0x3d, 0x51, 0x54, 0x74, 0x03, 0x2a, 0x11, 0x65, 0xbc, 0x57,
+	0x54, 0x35, 0xc0, 0x92, 0x60, 0xe4, 0x65, 0x57, 0xb5, 0x7f, 0xa5, 0x93, 0x54, 0x73, 0x93, 0xce,
+	0x13, 0xe7, 0x5b, 0x5f, 0x35, 0x60, 0x6d, 0xec, 0xe5, 0xa2, 0xfb, 0x70, 0x65, 0x74, 0xe4, 0x24,
+	0x41, 0x68, 0xa8, 0x18, 0x1c, 0x11, 0x07, 0x3a, 0x06, 0xd7, 0x00, 0x4e, 0x28, 0x27, 0xba, 0xcd,
+	0x2a, 0x6b, 0x67, 0x05, 0x45, 0x76, 0x55, 0xeb, 0x4f, 0x06, 0x98, 0xa3, 0xd2, 0x03, 0xdd, 0x81,
+	0x82, 0x8c, 0x0f, 0x43, 0x86, 0xc7, 0xc8, 0xea, 0x93, 0x53, 0x94, 0x51, 0x22, 0x95, 0xd0, 0x6d,
+	0x58, 0x8a, 0x70, 0xcc, 0x7d, 0xd7, 0x8f, 0xfa, 0x0a, 0xe5, 0x84, 0xb4, 0xfb, 0x42, 0x0f, 0x37,
+	0xad, 0x93, 0xd7, 0xa1, 0xec, 0x76, 0x19, 0xa7, 0xde, 0x59, 0xa6, 0x30, 0xa9, 0x9a, 0xab, 0xa6,
+	0xa7, 0xa2, 0x57, 0x61, 0x5e, 0xb8, 0xd7, 0xf1, 0x43, 0x37, 0xe8, 0x7a, 0xc4, 0x93, 0x5d, 0xbf,
+	0x60, 0xcf, 0x09, 0xe2, 0xbe, 0xa6, 0x59, 0x7f, 0x34, 0xa0, 0x98, 0x33, 0xf0, 0x7f, 0xfd, 0x9d,
+	0xb6, 0x60, 0x11, 0xb7, 0xdb, 0x31, 0x69, 0x8b, 0x8b, 0x17, 0x6d, 0x0d, 0xf3, 0x6e, 0x4c, 0xf4,
+	0x3c, 0x83, 0x52, 0xd6, 0x61, 0xc2, 0xb1, 0xbe, 0x39, 0x09, 0xa5, 0x3e, 0x63, 0x11, 0xd2, 0xc9,
+	0x69, 0xe4, 0x72, 0xf3, 0x3c, 0x4c, 0xc9, 0x84, 0xd0, 0x21, 0xa0, 0x1e, 0xd0, 0x9b, 0x60, 0xaa,
+	0xf7, 0x1e, 0x2c, 0xe9, 0xda, 0xc2, 0x0b, 0x8a, 0xdf, 0x57, 0xd0, 0xd1, 0x1d, 0x58, 0x21, 0x11,
+	0x75, 0x8f, 0x9c, 0x26, 0xed, 0x86, 0x1e, 0x8e, 0xcf, 0x7a, 0x54, 0x95, 0xb9, 0xcb, 0x52, 0xa2,
+	0xae, 0x05, 0x72, 0xca, 0xb7, 0x61, 0x59, 0xe5, 0xfd, 0xe0, 0xa1, 0x53, 0x52, 0xf3, 0xbc, 0x64,
+	0xf7, 0x9f, 0xf9, 0x36, 0x5c, 0xea, 0x6f, 0x8d, 0x3d, 0xba, 0xd3, 0x52, 0xf7, 0x62, 0x5f, 0xef,
+	0xcb, 0x01, 0x7c, 0x60, 0xa0, 0xc7, 0xcf, 0x0c, 0x6b, 0xf1, 0x6f, 0xc1, 0x6a, 0x26, 0x36, 0x68,
+	0xe2, 0x39, 0x79, 0x8c, 0x99, 0x8a, 0xf4, 0x99, 0x69, 0x7d, 0xa5, 0x00, 0xa5, 0xbe, 0x01, 0x1b,
+	0x2d, 0xc1, 0x74, 0xd4, 0x6d, 0x1e, 0x93, 0x33, 0x9d, 0xb4, 0xfa, 0x49, 0x04, 0xd4, 0x73, 0x9f,
+	0x1f, 0x79, 0x31, 0x7e, 0x8e, 0x03, 0xc7, 0x8d, 0x89, 0x47, 0x42, 0xee, 0xe3, 0x80, 0x25, 0x01,
+	0x95, 0x71, 0x77, 0x33, 0x26, 0xfa, 0x28, 0x98, 0x7a, 0x06, 0x55, 0x55, 0x53, 0xcc, 0x3e, 0xbd,
+	0xd7, 0xb6, 0xa4, 0xf8, 0xbb, 0x29, 0x5b, 0xbb, 0xe0, 0x2a, 0xcc, 0x6b, 0xcd, 0x00, 0x9f, 0x91,
+	0x98, 0x25, 0x39, 0xa3, 0x88, 0x0f, 0x24, 0x0d, 0x7d, 0x0a, 0xa6, 0x45, 0x38, 0x75, 0x99, 0xbc,
+	0x8e, 0x85, 0xda, 0xad, 0x57, 0xdc, 0x23, 0xaa, 0x87, 0x52, 0x6b, 0x97, 0x7a, 0x84, 0xd9, 0x1a,
+	0x02, 0x7d, 0x2c, 0x9d, 0x1a, 0x14, 0xa1, 0x67, 0x7d, 0x98, 0x96, 0xa7, 0xeb, 0xa1, 0x41, 0x6b,
+	0x67, 0x5b, 0xc3, 0x1a, 0x40, 0x6e, 0x45, 0x50, 0x77, 0x35, 0x4b, 0xd2, 0x8d, 0x60, 0x0d, 0x66,
+	0xf4, 0xf4, 0x60, 0xfe, 0x65, 0x26, 0xed, 0x32, 0x09, 0xcd, 0xfa, 0x32, 0x14, 0x73, 0xf6, 0xa0,
+	0x25, 0x40, 0x07, 0x77, 0x1f, 0xee, 0xed, 0x3f, 0x7c, 0xc7, 0xd9, 0xd9, 0x6d, 0xec, 0x3f, 0xd9,
+	0x69, 0xec, 0x3f, 0x7a, 0x58, 0xfe, 0x3f, 0x04, 0x30, 0x2d, 0x9f, 0xef, 0x96, 0x0d, 0xb4, 0x0c,
+	0x8b, 0xea, 0xbf, 0x93, 0x88, 0xde, 0x7d, 0x77, 0xbf, 0x51, 0x9e, 0x40, 0x2b, 0xb0, 0x24, 0xfe,
+	0xdd, 0xdd, 0x73, 0x9e, 0xee, 0x37, 0xee, 0x3f, 0x7a, 0xdc, 0x10, 0x02, 0x3b, 0x0f, 0x1a, 0x9f,
+	0x2d, 0x4f, 0x0a, 0xa5, 0x1c, 0x2f, 0x65, 0x14, 0xac, 0x00, 0x96, 0x47, 0x0c, 0xb2, 0xe8, 0x1a,
+	0x94, 0xb2, 0x9d, 0xc3, 0x0f, 0x3d, 0x72, 0x2a, 0x03, 0x63, 0xde, 0x5e, 0x48, 0xc9, 0xfb, 0x82,
+	0x3a, 0x22, 0x6d, 0x93, 0x04, 0x9f, 0xcc, 0x12, 0xdc, 0x7a, 0x1b, 0xe6, 0x0f, 0x23, 0xe2, 0xfa,
+	0x38, 0x48, 0x63, 0xae, 0x70, 0xec, 0x87, 0x9e, 0x02, 0x96, 0xae, 0x91, 0xcf, 0x82, 0x2e, 0x2b,
+	0xe0, 0x84, 0x18, 0xd8, 0x14, 0x5d, 0x3c, 0x5b, 0x9f, 0x83, 0x52, 0xdf, 0x1c, 0x39, 0xb4, 0x90,
+	0x8c, 0x49, 0xde, 0x89, 0xd1, 0xc9, 0x6b, 0xbd, 0x07, 0x4b, 0xc3, 0x9b, 0x35, 0xf2, 0xe0, 0x22,
+	0x16, 0x7f, 0x9c, 0x21, 0xb3, 0x80, 0x5e, 0x64, 0xaf, 0xbf, 0x72, 0xff, 0xb7, 0x97, 0x24, 0xd6,
+	0x00, 0xdd, 0xfa, 0x22, 0x54, 0x06, 0x88, 0x99, 0x77, 0x8d, 0xbc, 0x77, 0x2f, 0xc1, 0x6c, 0x66,
+	0x80, 0xf0, 0xd2, 0xbc, 0x9d, 0x11, 0x50, 0x0d, 0x2e, 0x70, 0xca, 0x71, 0xe0, 0x64, 0x17, 0x98,
+	0x5f, 0x61, 0x17, 0x25, 0x33, 0x4d, 0x0c, 0xd5, 0x65, 0xbf, 0x35, 0x99, 0x2c, 0xed, 0xd2, 0x2d,
+	0x43, 0xfd, 0xfa, 0x21, 0x40, 0x11, 0x8e, 0x45, 0x22, 0x0f, 0xba, 0xb4, 0xac, 0x38, 0xb9, 0x52,
+	0x76, 0x03, 0x2a, 0x7a, 0x94, 0x1f, 0xa8, 0xd8, 0x25, 0xc9, 0xc8, 0xc9, 0xde, 0x84, 0xf3, 0x3a,
+	0xe7, 0x63, 0x72, 0x42, 0x70, 0xd0, 0x5b, 0xa5, 0x91, 0xe2, 0xd9, 0x92, 0xa5, 0x35, 0x5e, 0x69,
+	0xfc, 0x98, 0x7a, 0x95, 0xf1, 0xe3, 0x12, 0xcc, 0x66, 0x5d, 0x6c, 0x5a, 0xae, 0x08, 0x19, 0x41,
+	0x34, 0xe3, 0x26, 0xf5, 0xce, 0x64, 0x6a, 0x8f, 0x69, 0xc6, 0x39, 0xd7, 0xd5, 0xa9, 0x77, 0x66,
+	0x4b, 0x25, 0xf4, 0x16, 0xcc, 0xa6, 0x5f, 0x4e, 0xcc, 0x7f, 0x29, 0x88, 0x95, 0xaa, 0xfa, 0xb8,
+	0x52, 0x4d, 0x3e, 0xae, 0x54, 0x1b, 0x89, 0x88, 0x8c, 0xf4, 0x4c, 0xc3, 0xfa, 0xf7, 0x04, 0x94,
+	0xfa, 0x80, 0xd1, 0x3b, 0x30, 0xd7, 0xb3, 0x58, 0xa8, 0xe8, 0xbb, 0xfa, 0x0a, 0x43, 0x82, 0xdd,
+	0xa3, 0x88, 0x9e, 0x02, 0x8a, 0x62, 0x1a, 0x51, 0x46, 0xc4, 0x24, 0x8b, 0xd9, 0x91, 0x1f, 0xb6,
+	0x99, 0x8c, 0xa5, 0x62, 0x6d, 0x73, 0xe4, 0x9a, 0xa2, 0x35, 0x0e, 0xb5, 0x82, 0x5d, 0x89, 0xfa,
+	0x28, 0x62, 0x65, 0x2f, 0xbb, 0x98, 0x45, 0x3d, 0xb0, 0x93, 0x12, 0xf6, 0x8d, 0xd1, 0x6b, 0x84,
+	0x90, 0x4f, 0x41, 0x4b, 0x6e, 0xcf, 0x33, 0x43, 0x77, 0xe0, 0x9c, 0x47, 0x22, 0xca, 0x7c, 0x2e,
+	0xba, 0x81, 0x80, 0x5a, 0x1f, 0x05, 0xb5, 0xa7, 0xe4, 0xec, 0x54, 0x01, 0xd5, 0x60, 0x4a, 0x14,
+	0x64, 0xf5, 0xbd, 0xa4, 0x58, 0xbb, 0x34, 0x4a, 0x53, 0xac, 0x71, 0xb6, 0x12, 0xb5, 0xfe, 0x60,
+	0x40, 0x45, 0x23, 0x1d, 0xe0, 0x18, 0x77, 0x08, 0x17, 0x4d, 0x67, 0x54, 0x8b, 0xac, 0xc2, 0x62,
+	0x14, 0x53, 0xda, 0x72, 0x68, 0xcb, 0x89, 0x28, 0x63, 0x84, 0xa5, 0x73, 0xf7, 0x9c, 0xf4, 0x10,
+	0x6d, 0x3d, 0x6a, 0x1d, 0xa4, 0x0c, 0xb1, 0xe9, 0x0e, 0x6f, 0xa9, 0xbd, 0x59, 0xb2, 0x3a, 0xb4,
+	0xb3, 0xea, 0xa8, 0x1d, 0xd7, 0x5f, 0x0b, 0xe3, 0xfa, 0xab, 0xf5, 0x0c, 0x90, 0xba, 0x46, 0x1c,
+	0x88, 0x19, 0x8d, 0x78, 0xaf, 0x39, 0x90, 0xdd, 0x80, 0xca, 0xa8, 0x49, 0xac, 0xd4, 0xec, 0x2b,
+	0xa9, 0xdf, 0x9e, 0x80, 0x8a, 0xbc, 0x46, 0xdc, 0x0c, 0xc8, 0x13, 0xca, 0x89, 0x3c, 0xeb, 0x3e,
+	0x5c, 0x19, 0x32, 0x41, 0x3a, 0x11, 0x75, 0x9d, 0x9b, 0xa2, 0xd5, 0xf8, 0x62, 0xd9, 0x36, 0x64,
+	0x55, 0x5b, 0x1b, 0x9c, 0x27, 0x0f, 0xa8, 0x7b, 0x73, 0x5f, 0x09, 0x8d, 0x43, 0xda, 0x4e, 0x91,
+	0x26, 0xc6, 0x20, 0x6d, 0x27, 0x48, 0xc9, 0xd0, 0x3d, 0xf9, 0x7e, 0x86, 0xee, 0xd7, 0x1e, 0x89,
+	0xbf, 0x67, 0x40, 0x51, 0xc7, 0x97, 0xf4, 0xc8, 0xbb, 0x80, 0x74, 0xbc, 0x3a, 0x51, 0x1a, 0x6f,
+	0x7a, 0x01, 0xb8, 0xfe, 0x92, 0x50, 0xcf, 0x02, 0xd4, 0xae, 0x78, 0x03, 0x31, 0x7b, 0x1e, 0xa6,
+	0x4e, 0x70, 0xd0, 0x25, 0xc9, 0x1d, 0xca, 0x07, 0x51, 0xf3, 0xb2, 0xc2, 0xa4, 0xba, 0x42, 0xae,
+	0xee, 0xfc, 0x72, 0x02, 0xca, 0xfd, 0x99, 0x2e, 0x26, 0xd3, 0xb4, 0x5e, 0xe4, 0xc7, 0x81, 0xf9,
+	0x84, 0xaa, 0xa6, 0x01, 0x1b, 0x4a, 0x91, 0x8e, 0x2e, 0xb9, 0xb9, 0x3b, 0xdb, 0xf2, 0xe4, 0x62,
+	0xed, 0xc6, 0xf8, 0x9a, 0x92, 0x0f, 0xc6, 0x04, 0x13, 0x07, 0xe2, 0x69, 0x5b, 0x74, 0x87, 0x14,
+	0x33, 0xbb, 0xe4, 0x6d, 0x1d, 0x74, 0x28, 0xca, 0x01, 0x48, 0xd6, 0xf6, 0xa0, 0x15, 0x2a, 0x29,
+	0xfe, 0x0b, 0x2b, 0x6a, 0x23, 0xac, 0x48, 0x9a, 0xcc, 0xa0, 0x15, 0x35, 0xeb, 0xbb, 0x06, 0x2c,
+	0xf4, 0x96, 0x36, 0x54, 0x87, 0x19, 0xb1, 0xd9, 0x32, 0x67, 0xfb, 0x65, 0xb7, 0x3b, 0x90, 0x36,
+	0xf6, 0xb4, 0xd4, 0xdc, 0xce, 0x30, 0x6a, 0xda, 0xb5, 0xaf, 0x8d, 0x51, 0xb3, 0x7e, 0x64, 0xc0,
+	0x8c, 0x8e, 0x1f, 0x31, 0x2e, 0x74, 0x48, 0x7c, 0x1c, 0x10, 0xa7, 0x19, 0xe3, 0xd0, 0x3d, 0x4a,
+	0x3f, 0x98, 0x19, 0xb2, 0x19, 0x2e, 0x2a, 0x66, 0x5d, 0xf2, 0x92, 0x8f, 0x65, 0x37, 0xa0, 0xa2,
+	0x75, 0x78, 0x4c, 0x88, 0x0e, 0x08, 0xfd, 0xa1, 0x41, 0x31, 0x1a, 0x31, 0x21, 0x2a, 0x24, 0xee,
+	0xc1, 0x5c, 0x12, 0xdc, 0xb9, 0x14, 0xbb, 0xfa, 0x92, 0xb0, 0x96, 0xe6, 0x16, 0xbd, 0xec, 0xc1,
+	0xc2, 0x50, 0x10, 0x35, 0x7a, 0x68, 0xa9, 0x1a, 0x32, 0xad, 0x2a, 0x6b, 0xfa, 0xa7, 0xd5, 0x9e,
+	0x6e, 0xaf, 0x02, 0x28, 0x23, 0xd4, 0xe7, 0x7e, 0xf5, 0xe2, 0xb2, 0xf1, 0xeb, 0x17, 0x97, 0x8d,
+	0x3f, 0xbf, 0xb8, 0x6c, 0x34, 0xa7, 0x65, 0x8b, 0xbe, 0xf5, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff,
+	0x47, 0x01, 0x62, 0xa6, 0x48, 0x19, 0x00, 0x00,
 }

proto/beacon/p2p/v1/types.proto

@@ -24,7 +24,7 @@ message BeaconState {
   // Finality [2001-3000] 
   uint64 previous_justified_slot = 2001;
   uint64 justified_slot = 2002;
-  uint64 justified_slot_bitfield = 2003;
+  uint64 justification_bitfield = 2003;
   uint64 finalized_slot = 2004;
 
   // Recent state [3001-4000]
@@ -58,7 +58,7 @@ message ForkData {
 
 message CandidatePoWReceiptRootRecord {
   bytes candidate_pow_receipt_root_hash32 = 1;
-  uint64 votes = 2;
+  uint64 vote_count = 2;
 }
 
 message PendingAttestationRecord {

shared/params/config.go

@@ -97,6 +97,7 @@ var defaultBeaconConfig = &BeaconChainConfig{
 	GenesisTime:                   time.Date(2018, 9, 0, 0, 0, 0, 0, time.UTC),
 	MaxNumLog2Validators:          24,
 	EpochLength:                   64,
+	PowReceiptRootVotingPeriod:    1024,
 }
 
 var demoBeaconConfig = &BeaconChainConfig{
@@ -129,6 +130,7 @@ var demoBeaconConfig = &BeaconChainConfig{
 	GenesisTime:                   time.Now(),
 	MaxNumLog2Validators:          24,
 	EpochLength:                   defaultBeaconConfig.EpochLength,
+	PowReceiptRootVotingPeriod:    1024,
 }
 
 var defaultShardConfig = &ShardChainConfig{