diff --git a/beacon-chain/blockchain/fork_choice_test.go b/beacon-chain/blockchain/fork_choice_test.go
index 6e47316bf4d3..58b0a1424c55 100644
--- a/beacon-chain/blockchain/fork_choice_test.go
+++ b/beacon-chain/blockchain/fork_choice_test.go
@@ -1528,7 +1528,7 @@ func setupFFGTest(t *testing.T) ([32]byte, *pb.BeaconBlock, *pb.BeaconState, []*
 		LatestRandaoMixes:      latestRandaoMixes,
 		LatestActiveIndexRoots: make([][]byte, params.BeaconConfig().LatestActiveIndexRootsLength),
 		LatestSlashedBalances:  make([]uint64, params.BeaconConfig().LatestSlashedExitLength),
-		LatestCrosslinks:       crosslinks,
+		CurrentCrosslinks:      crosslinks,
 		ValidatorRegistry:      validatorRegistry,
 		Balances:               validatorBalances,
 		LatestBlock:            gBlock,
diff --git a/beacon-chain/blockchain/service.go b/beacon-chain/blockchain/service.go
index e3d55fb3dc8a..008d6284096a 100644
--- a/beacon-chain/blockchain/service.go
+++ b/beacon-chain/blockchain/service.go
@@ -149,9 +149,6 @@ func (c *ChainService) initializeBeaconChain(genesisTime time.Time, deposits []*
 		return nil, fmt.Errorf("could not hash beacon block: %v", err)
 	}
 
-	// TODO(#2011): Remove this in state caching.
-	beaconState.LatestBlock = genBlock
-
 	if err := c.beaconDB.SaveBlock(genBlock); err != nil {
 		return nil, fmt.Errorf("could not save genesis block to disk: %v", err)
 	}
diff --git a/beacon-chain/core/blocks/block.go b/beacon-chain/core/blocks/block.go
index b90c1218c3b5..308c6cf6f2aa 100644
--- a/beacon-chain/core/blocks/block.go
+++ b/beacon-chain/core/blocks/block.go
@@ -8,7 +8,6 @@ import (
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/utils"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/hashutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
@@ -69,12 +68,7 @@ func BlockRoot(state *pb.BeaconState, slot uint64) ([]byte, error) {
 // Spec:
 //  Let previous_block_root be the tree_hash_root of the previous beacon block processed in the chain.
 //	Set state.latest_block_roots[(state.slot - 1) % LATEST_BLOCK_ROOTS_LENGTH] = previous_block_root.
-//	If state.slot % LATEST_BLOCK_ROOTS_LENGTH == 0 append merkle_root(state.latest_block_roots) to state.batched_block_roots.
 func ProcessBlockRoots(state *pb.BeaconState, parentRoot [32]byte) *pb.BeaconState {
 	state.LatestBlockRoots[(state.Slot-1)%params.BeaconConfig().LatestBlockRootsLength] = parentRoot[:]
-	if state.Slot%params.BeaconConfig().LatestBlockRootsLength == 0 {
-		merkleRoot := hashutil.MerkleRoot(state.LatestBlockRoots)
-		state.BatchedBlockRootHash32S = append(state.BatchedBlockRootHash32S, merkleRoot)
-	}
 	return state
 }
diff --git a/beacon-chain/core/blocks/block_test.go b/beacon-chain/core/blocks/block_test.go
index 3d9c7f2d6bd1..04c533eacb1d 100644
--- a/beacon-chain/core/blocks/block_test.go
+++ b/beacon-chain/core/blocks/block_test.go
@@ -8,7 +8,6 @@ import (
 
 	"github.com/gogo/protobuf/proto"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
-	"github.com/prysmaticlabs/prysm/shared/hashutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
 
@@ -154,18 +153,4 @@ func TestProcessBlockRoots_AccurateMerkleTree(t *testing.T) {
 		t.Fatalf("Latest Block root hash not saved."+
 			" Supposed to get %#x , but got %#x", testRoot, newState.LatestBlockRoots[0])
 	}
-
-	newState.Slot = newState.Slot - 1
-
-	newState = ProcessBlockRoots(newState, testRoot)
-	expectedHashes := make([][]byte, params.BeaconConfig().LatestBlockRootsLength)
-	expectedHashes[0] = testRoot[:]
-	expectedHashes[params.BeaconConfig().LatestBlockRootsLength-1] = testRoot[:]
-
-	expectedRoot := hashutil.MerkleRoot(expectedHashes)
-
-	if !bytes.Equal(newState.BatchedBlockRootHash32S[0], expectedRoot[:]) {
-		t.Errorf("saved merkle root is not equal to expected merkle root"+
-			"\n expected %#x but got %#x", expectedRoot, newState.BatchedBlockRootHash32S[0])
-	}
 }
diff --git a/beacon-chain/core/state/state.go b/beacon-chain/core/state/state.go
index d91f41a8eece..d0f0175437af 100644
--- a/beacon-chain/core/state/state.go
+++ b/beacon-chain/core/state/state.go
@@ -64,11 +64,10 @@ func GenesisBeaconState(
 		latestActiveIndexRoots[i] = zeroHash
 	}
 
-	latestCrosslinks := make([]*pb.Crosslink, params.BeaconConfig().ShardCount)
-	for i := 0; i < len(latestCrosslinks); i++ {
-		latestCrosslinks[i] = &pb.Crosslink{
-			Epoch:                   0,
-			CrosslinkDataRootHash32: zeroHash,
+	crosslinks := make([]*pb.Crosslink, params.BeaconConfig().ShardCount)
+	for i := 0; i < len(crosslinks); i++ {
+		crosslinks[i] = &pb.Crosslink{
+			Shard: uint64(i),
 		}
 	}
 
@@ -107,18 +106,11 @@ func GenesisBeaconState(
 		},
 
 		// Validator registry fields.
-		ValidatorRegistry:            validatorRegistry,
-		Balances:                     latestBalances,
-		ValidatorRegistryUpdateEpoch: 0,
+		ValidatorRegistry: validatorRegistry,
+		Balances:          latestBalances,
 
 		// Randomness and committees.
-		LatestRandaoMixes:           latestRandaoMixes,
-		PreviousShufflingStartShard: params.BeaconConfig().GenesisStartShard,
-		CurrentShufflingStartShard:  params.BeaconConfig().GenesisStartShard,
-		PreviousShufflingEpoch:      0,
-		CurrentShufflingEpoch:       0,
-		PreviousShufflingSeedHash32: zeroHash,
-		CurrentShufflingSeedHash32:  zeroHash,
+		LatestRandaoMixes: latestRandaoMixes,
 
 		// Finality.
 		PreviousJustifiedEpoch: 0,
@@ -130,12 +122,13 @@ func GenesisBeaconState(
 		FinalizedRoot:          params.BeaconConfig().ZeroHash[:],
 
 		// Recent state.
-		LatestCrosslinks:        latestCrosslinks,
-		LatestActiveIndexRoots:  latestActiveIndexRoots,
-		LatestBlockRoots:        latestBlockRoots,
-		LatestSlashedBalances:   latestSlashedExitBalances,
-		LatestAttestations:      []*pb.PendingAttestation{},
-		BatchedBlockRootHash32S: [][]byte{},
+		CurrentCrosslinks:         crosslinks,
+		PreviousCrosslinks:        crosslinks,
+		LatestActiveIndexRoots:    latestActiveIndexRoots,
+		LatestBlockRoots:          latestBlockRoots,
+		LatestSlashedBalances:     latestSlashedExitBalances,
+		CurrentEpochAttestations:  []*pb.PendingAttestation{},
+		PreviousEpochAttestations: []*pb.PendingAttestation{},
 
 		// Eth1 data.
 		LatestEth1Data: eth1Data,
diff --git a/beacon-chain/core/state/state_test.go b/beacon-chain/core/state/state_test.go
index baf575de9fc4..ea79f8b7eb47 100644
--- a/beacon-chain/core/state/state_test.go
+++ b/beacon-chain/core/state/state_test.go
@@ -104,9 +104,6 @@ func TestGenesisBeaconState_OK(t *testing.T) {
 	}
 
 	// Validator registry fields checks.
-	if newState.ValidatorRegistryUpdateEpoch != 0 {
-		t.Error("ValidatorRegistryUpdateSlot was not correctly initialized")
-	}
 	if len(newState.ValidatorRegistry) != depositsForChainStart {
 		t.Error("ValidatorRegistry was not correctly initialized")
 	}
@@ -134,18 +131,22 @@ func TestGenesisBeaconState_OK(t *testing.T) {
 	}
 
 	// Recent state checks.
-	if len(newState.LatestCrosslinks) != shardCount {
-		t.Error("Length of LatestCrosslinks was not correctly initialized")
+	if len(newState.CurrentCrosslinks) != shardCount {
+		t.Error("Length of CurrentCrosslinks was not correctly initialized")
+	}
+	if len(newState.PreviousCrosslinks) != shardCount {
+		t.Error("Length of PreviousCrosslinks was not correctly initialized")
 	}
 	if !reflect.DeepEqual(newState.LatestSlashedBalances, make([]uint64, params.BeaconConfig().LatestSlashedExitLength)) {
 		t.Error("LatestSlashedBalances was not correctly initialized")
 	}
-	if !reflect.DeepEqual(newState.LatestAttestations, []*pb.PendingAttestation{}) {
-		t.Error("LatestAttestations was not correctly initialized")
+	if !reflect.DeepEqual(newState.CurrentEpochAttestations, []*pb.PendingAttestation{}) {
+		t.Error("CurrentEpochAttestations was not correctly initialized")
 	}
-	if !reflect.DeepEqual(newState.BatchedBlockRootHash32S, [][]byte{}) {
-		t.Error("BatchedBlockRootHash32S was not correctly initialized")
+	if !reflect.DeepEqual(newState.PreviousEpochAttestations, []*pb.PendingAttestation{}) {
+		t.Error("PreviousEpochAttestations was not correctly initialized")
 	}
+
 	activeValidators := helpers.ActiveValidatorIndices(newState, 0)
 	indicesBytes := []byte{}
 	for _, val := range activeValidators {
diff --git a/beacon-chain/core/state/transition.go b/beacon-chain/core/state/transition.go
index 7510ed12870a..65cda995517f 100644
--- a/beacon-chain/core/state/transition.go
+++ b/beacon-chain/core/state/transition.go
@@ -128,9 +128,6 @@ func ProcessBlock(
 		return nil, fmt.Errorf("could not hash block: %v", err)
 	}
 
-	// Save latest block.
-	state.LatestBlock = block
-
 	// Verify block RANDAO.
 	state, err = b.ProcessRandao(state, block.Body, config.VerifySignatures, config.Logging)
 	if err != nil {
diff --git a/beacon-chain/core/state/transition_test.go b/beacon-chain/core/state/transition_test.go
index b1711d787387..55d8d38ffd1b 100644
--- a/beacon-chain/core/state/transition_test.go
+++ b/beacon-chain/core/state/transition_test.go
@@ -262,9 +262,9 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 		blockRoots = append(blockRoots, []byte{byte(i)})
 	}
 	beaconState.LatestBlockRoots = blockRoots
-	beaconState.LatestCrosslinks = []*pb.Crosslink{
+	beaconState.CurrentCrosslinks = []*pb.Crosslink{
 		{
-			CrosslinkDataRootHash32: []byte{1},
+			DataRoot: []byte{1},
 		},
 	}
 	blockAtt := &pb.Attestation{
@@ -376,9 +376,9 @@ func TestProcessBlock_PassesProcessingConditions(t *testing.T) {
 		blockRoots = append(blockRoots, []byte{byte(i)})
 	}
 	beaconState.LatestBlockRoots = blockRoots
-	beaconState.LatestCrosslinks = []*pb.Crosslink{
+	beaconState.CurrentCrosslinks = []*pb.Crosslink{
 		{
-			CrosslinkDataRootHash32: []byte{1},
+			DataRoot: []byte{1},
 		},
 	}
 	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
diff --git a/beacon-chain/operations/service_test.go b/beacon-chain/operations/service_test.go
index 9877da27e47b..560e09c330ab 100644
--- a/beacon-chain/operations/service_test.go
+++ b/beacon-chain/operations/service_test.go
@@ -138,9 +138,9 @@ func TestRetrieveAttestations_OK(t *testing.T) {
 	if err := beaconDB.SaveState(context.Background(), &pb.BeaconState{
 		Slot:        64,
 		LatestBlock: &pb.BeaconBlock{Slot: 0},
-		LatestCrosslinks: []*pb.Crosslink{{
-			Epoch:                   0,
-			CrosslinkDataRootHash32: params.BeaconConfig().ZeroHash[:]}}}); err != nil {
+		CurrentCrosslinks: []*pb.Crosslink{{
+			Epoch:    0,
+			DataRoot: params.BeaconConfig().ZeroHash[:]}}}); err != nil {
 		t.Fatal(err)
 	}
 	// Test we can retrieve attestations from slot1 - slot61.
@@ -176,9 +176,9 @@ func TestRetrieveAttestations_PruneInvalidAtts(t *testing.T) {
 	// At slot 200 only attestations up to from slot 137 to 139 are valid attestations.
 	if err := beaconDB.SaveState(context.Background(), &pb.BeaconState{
 		Slot: 200,
-		LatestCrosslinks: []*pb.Crosslink{{
-			Epoch:                   2,
-			CrosslinkDataRootHash32: params.BeaconConfig().ZeroHash[:]}}}); err != nil {
+		CurrentCrosslinks: []*pb.Crosslink{{
+			Epoch:    2,
+			DataRoot: params.BeaconConfig().ZeroHash[:]}}}); err != nil {
 		t.Fatal(err)
 	}
 	attestations, err := service.PendingAttestations(context.Background())
@@ -218,9 +218,9 @@ func TestRemoveProcessedAttestations_Ok(t *testing.T) {
 	}
 	if err := db.SaveState(context.Background(), &pb.BeaconState{
 		Slot: 15,
-		LatestCrosslinks: []*pb.Crosslink{{
-			Epoch:                   0,
-			CrosslinkDataRootHash32: params.BeaconConfig().ZeroHash[:]}}}); err != nil {
+		CurrentCrosslinks: []*pb.Crosslink{{
+			Epoch:    0,
+			DataRoot: params.BeaconConfig().ZeroHash[:]}}}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -298,9 +298,9 @@ func TestReceiveBlkRemoveOps_Ok(t *testing.T) {
 
 	if err := db.SaveState(context.Background(), &pb.BeaconState{
 		Slot: 15,
-		LatestCrosslinks: []*pb.Crosslink{{
-			Epoch:                   0,
-			CrosslinkDataRootHash32: params.BeaconConfig().ZeroHash[:]}}}); err != nil {
+		CurrentCrosslinks: []*pb.Crosslink{{
+			Epoch:    0,
+			DataRoot: params.BeaconConfig().ZeroHash[:]}}}); err != nil {
 		t.Fatal(err)
 	}
 
diff --git a/beacon-chain/rpc/attester_server.go b/beacon-chain/rpc/attester_server.go
index 6e7fd66a3d03..57155882ffc6 100644
--- a/beacon-chain/rpc/attester_server.go
+++ b/beacon-chain/rpc/attester_server.go
@@ -137,7 +137,7 @@ func (as *AttesterServer) AttestationDataAtSlot(ctx context.Context, req *pb.Att
 		EpochBoundaryRootHash32:  epochBoundaryRoot,
 		JustifiedEpoch:           headState.CurrentJustifiedEpoch,
 		JustifiedBlockRootHash32: justifiedBlockRoot,
-		LatestCrosslink:          headState.LatestCrosslinks[req.Shard],
+		LatestCrosslink:          headState.CurrentCrosslinks[req.Shard],
 	}
 	if err := as.cache.Put(ctx, req, res); err != nil {
 		return nil, err
diff --git a/beacon-chain/rpc/attester_server_test.go b/beacon-chain/rpc/attester_server_test.go
index 82d90052bb3c..8db8b5ef59b6 100644
--- a/beacon-chain/rpc/attester_server_test.go
+++ b/beacon-chain/rpc/attester_server_test.go
@@ -84,9 +84,9 @@ func TestAttestationDataAtSlot_OK(t *testing.T) {
 		Slot:                  3*params.BeaconConfig().SlotsPerEpoch + 1,
 		CurrentJustifiedEpoch: 2 + 0,
 		LatestBlockRoots:      make([][]byte, params.BeaconConfig().LatestBlockRootsLength),
-		LatestCrosslinks: []*pbp2p.Crosslink{
+		CurrentCrosslinks: []*pbp2p.Crosslink{
 			{
-				CrosslinkDataRootHash32: []byte("A"),
+				DataRoot: []byte("A"),
 			},
 		},
 		CurrentJustifiedRoot: justifiedBlockRoot[:],
@@ -130,7 +130,7 @@ func TestAttestationDataAtSlot_OK(t *testing.T) {
 		JustifiedEpoch:           2 + 0,
 		JustifiedBlockRootHash32: justifiedBlockRoot[:],
 		LatestCrosslink: &pbp2p.Crosslink{
-			CrosslinkDataRootHash32: []byte("A"),
+			DataRoot: []byte("A"),
 		},
 	}
 
@@ -181,9 +181,9 @@ func TestAttestationDataAtSlot_handlesFarAwayJustifiedEpoch(t *testing.T) {
 		Slot:                  10000,
 		CurrentJustifiedEpoch: helpers.SlotToEpoch(1500),
 		LatestBlockRoots:      make([][]byte, params.BeaconConfig().LatestBlockRootsLength),
-		LatestCrosslinks: []*pbp2p.Crosslink{
+		CurrentCrosslinks: []*pbp2p.Crosslink{
 			{
-				CrosslinkDataRootHash32: []byte("A"),
+				DataRoot: []byte("A"),
 			},
 		},
 		CurrentJustifiedRoot: justifiedBlockRoot[:],
@@ -227,7 +227,7 @@ func TestAttestationDataAtSlot_handlesFarAwayJustifiedEpoch(t *testing.T) {
 		JustifiedEpoch:           helpers.SlotToEpoch(1500),
 		JustifiedBlockRootHash32: justifiedBlockRoot[:],
 		LatestCrosslink: &pbp2p.Crosslink{
-			CrosslinkDataRootHash32: []byte("A"),
+			DataRoot: []byte("A"),
 		},
 	}
 
diff --git a/beacon-chain/rpc/proposer_server_test.go b/beacon-chain/rpc/proposer_server_test.go
index 5d82a5efc0aa..5a786d00db15 100644
--- a/beacon-chain/rpc/proposer_server_test.go
+++ b/beacon-chain/rpc/proposer_server_test.go
@@ -146,7 +146,7 @@ func TestPendingAttestations_FiltersWithinInclusionDelay(t *testing.T) {
 	beaconState := &pbp2p.BeaconState{
 		Slot:              stateSlot,
 		ValidatorRegistry: validators,
-		LatestCrosslinks: []*pbp2p.Crosslink{{
+		CurrentCrosslinks: []*pbp2p.Crosslink{{
 			Epoch:    1,
 			DataRoot: params.BeaconConfig().ZeroHash[:],
 		}},
@@ -218,7 +218,7 @@ func TestPendingAttestations_FiltersExpiredAttestations(t *testing.T) {
 	) - 1
 
 	expectedEpoch := uint64(100)
-	crosslink := &pbp2p.Crosslink{Epoch: 9, CrosslinkDataRootHash32: params.BeaconConfig().ZeroHash[:]}
+	crosslink := &pbp2p.Crosslink{Epoch: 9, DataRoot: params.BeaconConfig().ZeroHash[:]}
 	encoded, err := ssz.TreeHash(crosslink)
 	if err != nil {
 		t.Fatal(err)
@@ -315,8 +315,8 @@ func TestPendingAttestations_FiltersExpiredAttestations(t *testing.T) {
 		CurrentJustifiedEpoch:  expectedEpoch,
 		PreviousJustifiedEpoch: expectedEpoch,
 		CurrentCrosslinks: []*pbp2p.Crosslink{{
-			Epoch:                   9,
-			CrosslinkDataRootHash32: params.BeaconConfig().ZeroHash[:],
+			Epoch:    9,
+			DataRoot: params.BeaconConfig().ZeroHash[:],
 		}},
 		LatestRandaoMixes:      make([][]byte, params.BeaconConfig().LatestRandaoMixesLength),
 		LatestActiveIndexRoots: make([][]byte, params.BeaconConfig().LatestActiveIndexRootsLength),
diff --git a/proto/beacon/p2p/v1/messages.pb.go b/proto/beacon/p2p/v1/messages.pb.go
index 5669332e47db..eda983bbc3a0 100755
--- a/proto/beacon/p2p/v1/messages.pb.go
+++ b/proto/beacon/p2p/v1/messages.pb.go
@@ -5,10 +5,9 @@ package ethereum_beacon_p2p_v1
 
 import (
 	fmt "fmt"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
-
-	proto "github.com/gogo/protobuf/proto"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/proto/beacon/p2p/v1/types.pb.go b/proto/beacon/p2p/v1/types.pb.go
index 8e1c762c8213..b26d67599028 100755
--- a/proto/beacon/p2p/v1/types.pb.go
+++ b/proto/beacon/p2p/v1/types.pb.go
@@ -5,11 +5,10 @@ package ethereum_beacon_p2p_v1
 
 import (
 	fmt "fmt"
-	io "io"
-	math "math"
-
 	proto "github.com/gogo/protobuf/proto"
 	_ "github.com/prysmaticlabs/prysm/proto/common"
+	io "io"
+	math "math"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -52,47 +51,37 @@ func (Validator_StatusFlags) EnumDescriptor() ([]byte, []int) {
 }
 
 type BeaconState struct {
-	GenesisTime                  uint64                `protobuf:"varint,1001,opt,name=genesis_time,json=genesisTime,proto3" json:"genesis_time,omitempty"`
-	Fork                         *Fork                 `protobuf:"bytes,1002,opt,name=fork,proto3" json:"fork,omitempty"`
-	Slot                         uint64                `protobuf:"varint,1003,opt,name=slot,proto3" json:"slot,omitempty"`
-	ValidatorRegistry            []*Validator          `protobuf:"bytes,2001,rep,name=validator_registry,json=validatorRegistry,proto3" json:"validator_registry,omitempty"`
-	Balances                     []uint64              `protobuf:"varint,2002,rep,packed,name=balances,proto3" json:"balances,omitempty"`
-	LatestRandaoMixes            [][]byte              `protobuf:"bytes,3001,rep,name=latest_randao_mixes,json=latestRandaoMixes,proto3" json:"latest_randao_mixes,omitempty"`
-	LatestStartShard             uint64                `protobuf:"varint,3002,opt,name=latest_start_shard,json=latestStartShard,proto3" json:"latest_start_shard,omitempty"`
-	PreviousEpochAttestations    []*PendingAttestation `protobuf:"bytes,4001,rep,name=previous_epoch_attestations,json=previousEpochAttestations,proto3" json:"previous_epoch_attestations,omitempty"`
-	CurrentEpochAttestations     []*PendingAttestation `protobuf:"bytes,4002,rep,name=current_epoch_attestations,json=currentEpochAttestations,proto3" json:"current_epoch_attestations,omitempty"`
-	PreviousJustifiedEpoch       uint64                `protobuf:"varint,4003,opt,name=previous_justified_epoch,json=previousJustifiedEpoch,proto3" json:"previous_justified_epoch,omitempty"`
-	CurrentJustifiedEpoch        uint64                `protobuf:"varint,4004,opt,name=current_justified_epoch,json=currentJustifiedEpoch,proto3" json:"current_justified_epoch,omitempty"`
-	PreviousJustifiedRoot        []byte                `protobuf:"bytes,4005,opt,name=previous_justified_root,json=previousJustifiedRoot,proto3" json:"previous_justified_root,omitempty"`
-	CurrentJustifiedRoot         []byte                `protobuf:"bytes,4006,opt,name=current_justified_root,json=currentJustifiedRoot,proto3" json:"current_justified_root,omitempty"`
-	JustificationBitfield        uint64                `protobuf:"varint,4007,opt,name=justification_bitfield,json=justificationBitfield,proto3" json:"justification_bitfield,omitempty"`
-	FinalizedEpoch               uint64                `protobuf:"varint,4008,opt,name=finalized_epoch,json=finalizedEpoch,proto3" json:"finalized_epoch,omitempty"`
-	FinalizedRoot                []byte                `protobuf:"bytes,4009,opt,name=finalized_root,json=finalizedRoot,proto3" json:"finalized_root,omitempty"`
-	CurrentCrosslinks            []*Crosslink          `protobuf:"bytes,5001,rep,name=current_crosslinks,json=currentCrosslinks,proto3" json:"current_crosslinks,omitempty"`
-	PreviousCrosslinks           []*Crosslink          `protobuf:"bytes,5002,rep,name=previous_crosslinks,json=previousCrosslinks,proto3" json:"previous_crosslinks,omitempty"`
-	LatestBlockRoots             [][]byte              `protobuf:"bytes,5003,rep,name=latest_block_roots,json=latestBlockRoots,proto3" json:"latest_block_roots,omitempty"`
-	LatestStateRoots             [][]byte              `protobuf:"bytes,5004,rep,name=latest_state_roots,json=latestStateRoots,proto3" json:"latest_state_roots,omitempty"`
-	LatestActiveIndexRoots       [][]byte              `protobuf:"bytes,5005,rep,name=latest_active_index_roots,json=latestActiveIndexRoots,proto3" json:"latest_active_index_roots,omitempty"`
-	LatestSlashedBalances        []uint64              `protobuf:"varint,5006,rep,packed,name=latest_slashed_balances,json=latestSlashedBalances,proto3" json:"latest_slashed_balances,omitempty"`
-	LatestBlockHeader            *BeaconBlockHeader    `protobuf:"bytes,5007,opt,name=latest_block_header,json=latestBlockHeader,proto3" json:"latest_block_header,omitempty"`
-	HistoricalRoots              [][]byte              `protobuf:"bytes,5008,rep,name=historical_roots,json=historicalRoots,proto3" json:"historical_roots,omitempty"`
-	LatestEth1Data               *Eth1Data             `protobuf:"bytes,6001,opt,name=latest_eth1_data,json=latestEth1Data,proto3" json:"latest_eth1_data,omitempty"`
-	Eth1DataVotes                []*Eth1Data           `protobuf:"bytes,6002,rep,name=eth1_data_votes,json=eth1DataVotes,proto3" json:"eth1_data_votes,omitempty"`
-	DepositIndex                 uint64                `protobuf:"varint,6003,opt,name=deposit_index,json=depositIndex,proto3" json:"deposit_index,omitempty"`
-	ValidatorRegistryUpdateEpoch uint64                `protobuf:"varint,8001,opt,name=validator_registry_update_epoch,json=validatorRegistryUpdateEpoch,proto3" json:"validator_registry_update_epoch,omitempty"` // Deprecated: Do not use.
-	PreviousShufflingStartShard  uint64                `protobuf:"varint,8003,opt,name=previous_shuffling_start_shard,json=previousShufflingStartShard,proto3" json:"previous_shuffling_start_shard,omitempty"`    // Deprecated: Do not use.
-	CurrentShufflingStartShard   uint64                `protobuf:"varint,8004,opt,name=current_shuffling_start_shard,json=currentShufflingStartShard,proto3" json:"current_shuffling_start_shard,omitempty"`       // Deprecated: Do not use.
-	PreviousShufflingEpoch       uint64                `protobuf:"varint,8005,opt,name=previous_shuffling_epoch,json=previousShufflingEpoch,proto3" json:"previous_shuffling_epoch,omitempty"`                     // Deprecated: Do not use.
-	CurrentShufflingEpoch        uint64                `protobuf:"varint,8006,opt,name=current_shuffling_epoch,json=currentShufflingEpoch,proto3" json:"current_shuffling_epoch,omitempty"`                        // Deprecated: Do not use.
-	PreviousShufflingSeedHash32  []byte                `protobuf:"bytes,8007,opt,name=previous_shuffling_seed_hash32,json=previousShufflingSeedHash32,proto3" json:"previous_shuffling_seed_hash32,omitempty"`     // Deprecated: Do not use.
-	CurrentShufflingSeedHash32   []byte                `protobuf:"bytes,8008,opt,name=current_shuffling_seed_hash32,json=currentShufflingSeedHash32,proto3" json:"current_shuffling_seed_hash32,omitempty"`        // Deprecated: Do not use.
-	BatchedBlockRootHash32S      [][]byte              `protobuf:"bytes,8013,rep,name=batched_block_root_hash32s,json=batchedBlockRootHash32s,proto3" json:"batched_block_root_hash32s,omitempty"`                 // Deprecated: Do not use.
-	LatestCrosslinks             []*Crosslink          `protobuf:"bytes,8014,rep,name=latest_crosslinks,json=latestCrosslinks,proto3" json:"latest_crosslinks,omitempty"`                                          // Deprecated: Do not use.
-	LatestAttestations           []*PendingAttestation `protobuf:"bytes,8015,rep,name=latest_attestations,json=latestAttestations,proto3" json:"latest_attestations,omitempty"`                                    // Deprecated: Do not use.
-	LatestBlock                  *BeaconBlock          `protobuf:"bytes,8016,opt,name=latest_block,json=latestBlock,proto3" json:"latest_block,omitempty"`                                                         // Deprecated: Do not use.
-	XXX_NoUnkeyedLiteral         struct{}              `json:"-"`
-	XXX_unrecognized             []byte                `json:"-"`
-	XXX_sizecache                int32                 `json:"-"`
+	GenesisTime               uint64                `protobuf:"varint,1001,opt,name=genesis_time,json=genesisTime,proto3" json:"genesis_time,omitempty"`
+	Fork                      *Fork                 `protobuf:"bytes,1002,opt,name=fork,proto3" json:"fork,omitempty"`
+	Slot                      uint64                `protobuf:"varint,1003,opt,name=slot,proto3" json:"slot,omitempty"`
+	ValidatorRegistry         []*Validator          `protobuf:"bytes,2001,rep,name=validator_registry,json=validatorRegistry,proto3" json:"validator_registry,omitempty"`
+	Balances                  []uint64              `protobuf:"varint,2002,rep,packed,name=balances,proto3" json:"balances,omitempty"`
+	LatestRandaoMixes         [][]byte              `protobuf:"bytes,3001,rep,name=latest_randao_mixes,json=latestRandaoMixes,proto3" json:"latest_randao_mixes,omitempty"`
+	LatestStartShard          uint64                `protobuf:"varint,3002,opt,name=latest_start_shard,json=latestStartShard,proto3" json:"latest_start_shard,omitempty"`
+	PreviousEpochAttestations []*PendingAttestation `protobuf:"bytes,4001,rep,name=previous_epoch_attestations,json=previousEpochAttestations,proto3" json:"previous_epoch_attestations,omitempty"`
+	CurrentEpochAttestations  []*PendingAttestation `protobuf:"bytes,4002,rep,name=current_epoch_attestations,json=currentEpochAttestations,proto3" json:"current_epoch_attestations,omitempty"`
+	PreviousJustifiedEpoch    uint64                `protobuf:"varint,4003,opt,name=previous_justified_epoch,json=previousJustifiedEpoch,proto3" json:"previous_justified_epoch,omitempty"`
+	CurrentJustifiedEpoch     uint64                `protobuf:"varint,4004,opt,name=current_justified_epoch,json=currentJustifiedEpoch,proto3" json:"current_justified_epoch,omitempty"`
+	PreviousJustifiedRoot     []byte                `protobuf:"bytes,4005,opt,name=previous_justified_root,json=previousJustifiedRoot,proto3" json:"previous_justified_root,omitempty"`
+	CurrentJustifiedRoot      []byte                `protobuf:"bytes,4006,opt,name=current_justified_root,json=currentJustifiedRoot,proto3" json:"current_justified_root,omitempty"`
+	JustificationBitfield     uint64                `protobuf:"varint,4007,opt,name=justification_bitfield,json=justificationBitfield,proto3" json:"justification_bitfield,omitempty"`
+	FinalizedEpoch            uint64                `protobuf:"varint,4008,opt,name=finalized_epoch,json=finalizedEpoch,proto3" json:"finalized_epoch,omitempty"`
+	FinalizedRoot             []byte                `protobuf:"bytes,4009,opt,name=finalized_root,json=finalizedRoot,proto3" json:"finalized_root,omitempty"`
+	CurrentCrosslinks         []*Crosslink          `protobuf:"bytes,5001,rep,name=current_crosslinks,json=currentCrosslinks,proto3" json:"current_crosslinks,omitempty"`
+	PreviousCrosslinks        []*Crosslink          `protobuf:"bytes,5002,rep,name=previous_crosslinks,json=previousCrosslinks,proto3" json:"previous_crosslinks,omitempty"`
+	LatestBlockRoots          [][]byte              `protobuf:"bytes,5003,rep,name=latest_block_roots,json=latestBlockRoots,proto3" json:"latest_block_roots,omitempty"`
+	LatestStateRoots          [][]byte              `protobuf:"bytes,5004,rep,name=latest_state_roots,json=latestStateRoots,proto3" json:"latest_state_roots,omitempty"`
+	LatestActiveIndexRoots    [][]byte              `protobuf:"bytes,5005,rep,name=latest_active_index_roots,json=latestActiveIndexRoots,proto3" json:"latest_active_index_roots,omitempty"`
+	LatestSlashedBalances     []uint64              `protobuf:"varint,5006,rep,packed,name=latest_slashed_balances,json=latestSlashedBalances,proto3" json:"latest_slashed_balances,omitempty"`
+	LatestBlockHeader         *BeaconBlockHeader    `protobuf:"bytes,5007,opt,name=latest_block_header,json=latestBlockHeader,proto3" json:"latest_block_header,omitempty"`
+	HistoricalRoots           [][]byte              `protobuf:"bytes,5008,rep,name=historical_roots,json=historicalRoots,proto3" json:"historical_roots,omitempty"`
+	LatestEth1Data            *Eth1Data             `protobuf:"bytes,6001,opt,name=latest_eth1_data,json=latestEth1Data,proto3" json:"latest_eth1_data,omitempty"`
+	Eth1DataVotes             []*Eth1Data           `protobuf:"bytes,6002,rep,name=eth1_data_votes,json=eth1DataVotes,proto3" json:"eth1_data_votes,omitempty"`
+	DepositIndex              uint64                `protobuf:"varint,6003,opt,name=deposit_index,json=depositIndex,proto3" json:"deposit_index,omitempty"`
+	LatestBlock               *BeaconBlock          `protobuf:"bytes,8016,opt,name=latest_block,json=latestBlock,proto3" json:"latest_block,omitempty"`
+	XXX_NoUnkeyedLiteral      struct{}              `json:"-"`
+	XXX_unrecognized          []byte                `json:"-"`
+	XXX_sizecache             int32                 `json:"-"`
 }
 
 func (m *BeaconState) Reset()         { *m = BeaconState{} }
@@ -317,87 +306,6 @@ func (m *BeaconState) GetDepositIndex() uint64 {
 	return 0
 }
 
-// Deprecated: Do not use.
-func (m *BeaconState) GetValidatorRegistryUpdateEpoch() uint64 {
-	if m != nil {
-		return m.ValidatorRegistryUpdateEpoch
-	}
-	return 0
-}
-
-// Deprecated: Do not use.
-func (m *BeaconState) GetPreviousShufflingStartShard() uint64 {
-	if m != nil {
-		return m.PreviousShufflingStartShard
-	}
-	return 0
-}
-
-// Deprecated: Do not use.
-func (m *BeaconState) GetCurrentShufflingStartShard() uint64 {
-	if m != nil {
-		return m.CurrentShufflingStartShard
-	}
-	return 0
-}
-
-// Deprecated: Do not use.
-func (m *BeaconState) GetPreviousShufflingEpoch() uint64 {
-	if m != nil {
-		return m.PreviousShufflingEpoch
-	}
-	return 0
-}
-
-// Deprecated: Do not use.
-func (m *BeaconState) GetCurrentShufflingEpoch() uint64 {
-	if m != nil {
-		return m.CurrentShufflingEpoch
-	}
-	return 0
-}
-
-// Deprecated: Do not use.
-func (m *BeaconState) GetPreviousShufflingSeedHash32() []byte {
-	if m != nil {
-		return m.PreviousShufflingSeedHash32
-	}
-	return nil
-}
-
-// Deprecated: Do not use.
-func (m *BeaconState) GetCurrentShufflingSeedHash32() []byte {
-	if m != nil {
-		return m.CurrentShufflingSeedHash32
-	}
-	return nil
-}
-
-// Deprecated: Do not use.
-func (m *BeaconState) GetBatchedBlockRootHash32S() [][]byte {
-	if m != nil {
-		return m.BatchedBlockRootHash32S
-	}
-	return nil
-}
-
-// Deprecated: Do not use.
-func (m *BeaconState) GetLatestCrosslinks() []*Crosslink {
-	if m != nil {
-		return m.LatestCrosslinks
-	}
-	return nil
-}
-
-// Deprecated: Do not use.
-func (m *BeaconState) GetLatestAttestations() []*PendingAttestation {
-	if m != nil {
-		return m.LatestAttestations
-	}
-	return nil
-}
-
-// Deprecated: Do not use.
 func (m *BeaconState) GetLatestBlock() *BeaconBlock {
 	if m != nil {
 		return m.LatestBlock
@@ -2348,174 +2256,162 @@ func init() {
 func init() { proto.RegisterFile("proto/beacon/p2p/v1/types.proto", fileDescriptor_e719e7d82cfa7b0d) }
 
 var fileDescriptor_e719e7d82cfa7b0d = []byte{
-	// 2668 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0x5b, 0x73, 0x23, 0x47,
-	0xf5, 0xff, 0xeb, 0x62, 0x5b, 0x3a, 0x92, 0x2d, 0xa9, 0x7d, 0x9b, 0x78, 0x2f, 0xde, 0x68, 0x93,
-	0xbf, 0xbd, 0x9b, 0xac, 0x1d, 0x29, 0x15, 0x52, 0x24, 0xc4, 0x89, 0xbd, 0x76, 0xb2, 0x4e, 0x42,
-	0x20, 0x63, 0x67, 0x97, 0xe2, 0x65, 0x18, 0x69, 0x5a, 0xd2, 0xac, 0xc7, 0x33, 0x62, 0x7a, 0xe4,
-	0xac, 0x29, 0x9e, 0x78, 0x23, 0x5c, 0x8b, 0x6f, 0x40, 0xb8, 0x17, 0x55, 0x3c, 0xf1, 0x02, 0x55,
-	0x3c, 0x50, 0x40, 0x08, 0x0f, 0x40, 0xa0, 0x0a, 0x9e, 0xa9, 0xad, 0xa2, 0x8a, 0x84, 0xf0, 0x00,
-	0x7c, 0x00, 0xa8, 0xee, 0xd3, 0xd3, 0x73, 0x91, 0x64, 0x7b, 0x37, 0xe1, 0xcd, 0x73, 0x6e, 0x7d,
-	0x4e, 0x77, 0x9f, 0xdf, 0x39, 0xa7, 0x65, 0x58, 0xee, 0xfb, 0x5e, 0xe0, 0xad, 0xb7, 0xa8, 0xd9,
-	0xf6, 0xdc, 0xf5, 0x7e, 0xb3, 0xbf, 0x7e, 0xd4, 0x58, 0x0f, 0x8e, 0xfb, 0x94, 0xad, 0x09, 0x0e,
-	0x59, 0xa0, 0x41, 0x8f, 0xfa, 0x74, 0x70, 0xb8, 0x86, 0x32, 0x6b, 0xfd, 0x66, 0x7f, 0xed, 0xa8,
-	0xb1, 0x74, 0x0e, 0x15, 0xdb, 0xde, 0xe1, 0xa1, 0xe7, 0xae, 0x1f, 0x52, 0xc6, 0xcc, 0x6e, 0xa8,
-	0x54, 0xff, 0xc2, 0x2c, 0x94, 0xb6, 0x84, 0xf8, 0x5e, 0x60, 0x06, 0x94, 0xd4, 0xa1, 0xdc, 0xa5,
-	0x2e, 0x65, 0x36, 0x33, 0x02, 0xfb, 0x90, 0x6a, 0xef, 0x4e, 0x5d, 0xca, 0xac, 0xe6, 0xf5, 0x92,
-	0x24, 0xee, 0xdb, 0x87, 0x94, 0x34, 0x20, 0xdf, 0xf1, 0xfc, 0x03, 0xed, 0x3d, 0xce, 0x2b, 0x35,
-	0xcf, 0xaf, 0x8d, 0x5e, 0x78, 0xed, 0x79, 0xcf, 0x3f, 0xd0, 0x85, 0x28, 0x99, 0x85, 0x3c, 0x73,
-	0xbc, 0x40, 0xfb, 0x3b, 0x9a, 0x13, 0x1f, 0xe4, 0x55, 0x20, 0x47, 0xa6, 0x63, 0x5b, 0x66, 0xe0,
-	0xf9, 0x86, 0x4f, 0xbb, 0x36, 0x0b, 0xfc, 0x63, 0xed, 0x0f, 0x95, 0x4b, 0xb9, 0xd5, 0x52, 0xf3,
-	0xc1, 0x71, 0x56, 0x6f, 0x86, 0x2a, 0x7a, 0x4d, 0x69, 0xeb, 0x52, 0x99, 0x9c, 0x83, 0x42, 0xcb,
-	0x74, 0x4c, 0xb7, 0x4d, 0x99, 0xf6, 0x47, 0x6e, 0x28, 0xaf, 0x2b, 0x02, 0x59, 0x87, 0x59, 0xc7,
-	0x0c, 0x28, 0x0b, 0x0c, 0xdf, 0x74, 0x2d, 0xd3, 0x33, 0x0e, 0xed, 0x3b, 0x94, 0x69, 0x3f, 0x59,
-	0xbc, 0x94, 0x5b, 0x2d, 0xeb, 0x35, 0xe4, 0xe9, 0x82, 0xf5, 0x71, 0xce, 0x21, 0xd7, 0x80, 0x48,
-	0x05, 0x16, 0x98, 0x7e, 0x60, 0xb0, 0x9e, 0xe9, 0x5b, 0xda, 0x4f, 0x17, 0x45, 0x0c, 0x55, 0x64,
-	0xed, 0x71, 0xce, 0x1e, 0x67, 0x90, 0x03, 0x38, 0xd7, 0xf7, 0xe9, 0x91, 0xed, 0x0d, 0x98, 0x41,
-	0xfb, 0x5e, 0xbb, 0x67, 0x98, 0x01, 0x17, 0x31, 0x03, 0xdb, 0x73, 0x99, 0xf6, 0xcd, 0x65, 0x11,
-	0xd8, 0xd5, 0x71, 0x81, 0x7d, 0x92, 0xba, 0x96, 0xed, 0x76, 0x37, 0x23, 0x1d, 0xfd, 0x81, 0xd0,
-	0xde, 0x0e, 0x37, 0x17, 0xe3, 0x30, 0x62, 0xc3, 0x52, 0x7b, 0xe0, 0xfb, 0xd4, 0x0d, 0x46, 0xad,
-	0xf5, 0xe6, 0xbd, 0xaf, 0xa5, 0x49, 0x73, 0xc3, 0x4b, 0x7d, 0x14, 0x34, 0x15, 0xd7, 0xed, 0x01,
-	0x0b, 0xec, 0x8e, 0x4d, 0x2d, 0x5c, 0x55, 0xfb, 0xd6, 0xb2, 0xd8, 0x8c, 0x85, 0x50, 0xe0, 0xc5,
-	0x90, 0x2f, 0xcc, 0x90, 0x27, 0x61, 0x31, 0xf4, 0x32, 0xad, 0xf9, 0x6d, 0xd4, 0x9c, 0x97, 0xfc,
-	0x61, 0xc5, 0x11, 0x6b, 0xfa, 0x9e, 0x17, 0x68, 0xdf, 0xe1, 0x8a, 0x65, 0x7d, 0x7e, 0x68, 0x49,
-	0xdd, 0xf3, 0x02, 0xf2, 0x04, 0x2c, 0x0c, 0xaf, 0x28, 0xf4, 0xbe, 0x8b, 0x7a, 0x73, 0xe9, 0x05,
-	0x85, 0xda, 0x47, 0x60, 0x41, 0x8a, 0xb7, 0x45, 0xd4, 0x46, 0xcb, 0x0e, 0x3a, 0x36, 0x75, 0x2c,
-	0xed, 0x7b, 0xd2, 0xcf, 0x04, 0x7b, 0x4b, 0x72, 0xc9, 0x2a, 0x54, 0x3a, 0xb6, 0x6b, 0x3a, 0xf6,
-	0xe7, 0x54, 0x60, 0xdf, 0x47, 0x85, 0x19, 0x45, 0xc7, 0x88, 0xfe, 0x1f, 0x22, 0x0a, 0x3a, 0xf4,
-	0x03, 0x74, 0x68, 0x5a, 0x91, 0x85, 0x27, 0xaf, 0x02, 0x09, 0x03, 0x68, 0xfb, 0x1e, 0x63, 0x8e,
-	0xed, 0x1e, 0x30, 0xed, 0x8b, 0x2b, 0x27, 0x67, 0xc5, 0xf5, 0x50, 0x54, 0xaf, 0x49, 0x6d, 0x45,
-	0x61, 0x64, 0x0f, 0x66, 0xd5, 0x66, 0xc6, 0x6c, 0xbe, 0x71, 0x66, 0x9b, 0x24, 0x54, 0x8f, 0x19,
-	0x8d, 0x92, 0xa3, 0xe5, 0x78, 0xed, 0x03, 0x11, 0x12, 0xd3, 0xbe, 0xb4, 0x22, 0x92, 0x49, 0x26,
-	0xc7, 0x16, 0xe7, 0xf0, 0xa8, 0x52, 0xb9, 0x14, 0x50, 0x29, 0xfe, 0xe5, 0x84, 0xb8, 0x80, 0x20,
-	0x14, 0x7f, 0x0a, 0x1e, 0x90, 0xe2, 0x66, 0x3b, 0xb0, 0x8f, 0xa8, 0x61, 0xbb, 0x16, 0xbd, 0x23,
-	0xb5, 0xbe, 0x82, 0x5a, 0x0b, 0x28, 0xb1, 0x29, 0x04, 0x76, 0x39, 0x1f, 0x75, 0x9f, 0x84, 0xc5,
-	0x70, 0x29, 0xc7, 0x64, 0x3d, 0x6a, 0x19, 0x0a, 0x13, 0xbe, 0xba, 0x22, 0x30, 0x61, 0x5e, 0xae,
-	0x87, 0xec, 0xad, 0x10, 0x20, 0x3e, 0xad, 0x00, 0x02, 0x43, 0xea, 0x51, 0xd3, 0xa2, 0xbe, 0xf6,
-	0xb5, 0x15, 0x81, 0x73, 0x57, 0xc6, 0xed, 0x13, 0xe2, 0xa7, 0x88, 0xf5, 0x86, 0xd0, 0x08, 0xb1,
-	0x24, 0x46, 0x22, 0x57, 0xa1, 0xda, 0xb3, 0x59, 0xe0, 0xf9, 0x76, 0xdb, 0x74, 0x64, 0x1c, 0x5f,
-	0xc7, 0x38, 0x2a, 0x11, 0x03, 0x03, 0x78, 0x09, 0xe4, 0x86, 0x18, 0x34, 0xe8, 0x35, 0x0c, 0xcb,
-	0x0c, 0x4c, 0xed, 0x9f, 0x6b, 0xc2, 0x89, 0x4b, 0xe3, 0x9c, 0xd8, 0x09, 0x7a, 0x8d, 0x6d, 0x33,
-	0x30, 0xf5, 0x19, 0x54, 0x0d, 0xbf, 0xc9, 0x2e, 0x54, 0x94, 0x15, 0xe3, 0xc8, 0x0b, 0x28, 0xd3,
-	0xfe, 0xb5, 0x26, 0x0e, 0xfe, 0x74, 0x5b, 0xd3, 0x54, 0xfe, 0x75, 0x93, 0xeb, 0x91, 0x87, 0x60,
-	0xda, 0xa2, 0x7d, 0x8f, 0xd9, 0x01, 0x1e, 0x87, 0xf6, 0xef, 0x35, 0x71, 0xd5, 0xcb, 0x92, 0x2a,
-	0xce, 0x80, 0xbc, 0x08, 0xcb, 0xc3, 0xb0, 0x6e, 0x0c, 0xfa, 0x16, 0x3f, 0x76, 0x4c, 0x91, 0x9f,
-	0x6f, 0x70, 0xbd, 0xad, 0xac, 0x96, 0xd1, 0xcf, 0x0f, 0x81, 0xf8, 0x6b, 0x42, 0x12, 0x93, 0xe6,
-	0x06, 0x5c, 0x54, 0x37, 0x97, 0xf5, 0x06, 0x9d, 0x8e, 0x63, 0xbb, 0xdd, 0x04, 0x1a, 0xff, 0x22,
-	0x32, 0xa5, 0xd0, 0x77, 0x2f, 0x94, 0x8c, 0x81, 0xf3, 0xf3, 0x70, 0x21, 0x4c, 0xab, 0xd1, 0x86,
-	0x7e, 0x19, 0x19, 0x0a, 0x91, 0x75, 0x94, 0x9d, 0x67, 0x62, 0x60, 0x18, 0x19, 0xc2, 0xb0, 0x7e,
-	0x15, 0x99, 0x58, 0x18, 0xf2, 0x05, 0x03, 0x7a, 0x3a, 0x02, 0xc4, 0xb4, 0xf6, 0x5b, 0x91, 0xf6,
-	0x7c, 0xda, 0x81, 0x13, 0x77, 0x83, 0x52, 0xcb, 0xe8, 0x99, 0xac, 0xf7, 0x78, 0x53, 0xfb, 0x35,
-	0xb7, 0x51, 0x1e, 0xb7, 0x1b, 0x94, 0x5a, 0x37, 0x84, 0xdc, 0x98, 0xdd, 0x88, 0x19, 0x7a, 0x3b,
-	0x32, 0x34, 0xbc, 0x1b, 0x91, 0x9d, 0xe7, 0x60, 0xa9, 0x65, 0x06, 0x6d, 0x91, 0x63, 0x0a, 0x05,
-	0xa4, 0x0d, 0xa6, 0xfd, 0x76, 0x83, 0xdf, 0x6f, 0x61, 0x64, 0x51, 0x8a, 0x29, 0x44, 0x40, 0x03,
-	0x1c, 0x9b, 0x64, 0xb2, 0xc4, 0x91, 0xe9, 0x77, 0x1b, 0x67, 0x44, 0x26, 0x61, 0x5b, 0x26, 0x4b,
-	0x0c, 0x9b, 0x3e, 0xa3, 0x12, 0x39, 0x51, 0x15, 0x7f, 0xbf, 0x71, 0xaf, 0x55, 0x51, 0xd8, 0x97,
-	0xc0, 0x95, 0xa8, 0x89, 0x2f, 0x41, 0x39, 0x0e, 0x15, 0xda, 0x3b, 0x1b, 0x22, 0x3d, 0x2f, 0x9f,
-	0x01, 0x23, 0x84, 0xcd, 0x52, 0x0c, 0x21, 0xea, 0x7d, 0xc8, 0xf3, 0x5e, 0x89, 0x5c, 0x81, 0xaa,
-	0x3a, 0xdf, 0x23, 0xea, 0x33, 0xdb, 0x73, 0xb5, 0x8c, 0xa8, 0x11, 0x95, 0x90, 0x7e, 0x13, 0xc9,
-	0x64, 0x05, 0x2a, 0xe1, 0x01, 0x86, 0x92, 0x59, 0x21, 0x39, 0x23, 0xc9, 0xa1, 0xe0, 0x1c, 0x4c,
-	0xe0, 0xf5, 0xca, 0x89, 0x54, 0xc5, 0x8f, 0xfa, 0x8f, 0xb2, 0x40, 0x86, 0xa3, 0x25, 0x0d, 0x98,
-	0x33, 0xbb, 0x5d, 0x9f, 0x76, 0x53, 0x35, 0x10, 0x9d, 0x98, 0x8d, 0xf1, 0x54, 0x01, 0x7c, 0x1a,
-	0xf2, 0x02, 0x9f, 0xb2, 0x22, 0xfe, 0x95, 0x71, 0xf1, 0xc7, 0x56, 0x11, 0xc8, 0x22, 0x94, 0xc8,
-	0x15, 0x98, 0xb1, 0xdd, 0xb6, 0x33, 0xe0, 0x9e, 0x1a, 0xa2, 0x41, 0xcc, 0xa9, 0x1c, 0x98, 0x56,
-	0x9c, 0x3d, 0xde, 0x2c, 0x5e, 0x83, 0x6a, 0x7b, 0xc0, 0x02, 0xcf, 0x3a, 0x8e, 0xdc, 0xca, 0xab,
-	0x3b, 0x5a, 0x91, 0x3c, 0xe5, 0xd6, 0x0a, 0x54, 0x22, 0xcb, 0x16, 0x75, 0xcc, 0x63, 0x6d, 0x02,
-	0xcb, 0xb2, 0x22, 0x6f, 0x73, 0x2a, 0x79, 0x18, 0x66, 0xfa, 0xbe, 0xd7, 0xf7, 0x18, 0xf5, 0x25,
-	0xa8, 0x4d, 0x0a, 0xb9, 0xe9, 0x90, 0x2a, 0x40, 0xad, 0xfe, 0x56, 0x06, 0x4a, 0xf1, 0x9d, 0x0a,
-	0xc3, 0xce, 0xdc, 0x4f, 0xd8, 0xe3, 0xb6, 0x39, 0x3b, 0x7e, 0x9b, 0xaf, 0x8c, 0x08, 0x3f, 0x87,
-	0x57, 0x23, 0x1d, 0xfa, 0x79, 0x28, 0x32, 0xbb, 0xeb, 0x9a, 0xc1, 0xc0, 0xa7, 0xb8, 0x45, 0x7a,
-	0x44, 0xa8, 0xff, 0x63, 0x02, 0x2a, 0x29, 0xaf, 0xc8, 0x82, 0xec, 0xce, 0x33, 0x6a, 0xf3, 0xb1,
-	0x41, 0xbf, 0x0a, 0x35, 0x0c, 0x27, 0x96, 0xdc, 0xd2, 0xc9, 0x4a, 0x2b, 0xba, 0xd0, 0xa2, 0x6d,
-	0x79, 0x10, 0xca, 0xcc, 0x1b, 0xf8, 0xed, 0x10, 0xe2, 0xf1, 0xba, 0x95, 0x90, 0x86, 0xf0, 0xb5,
-	0x0c, 0xf2, 0x13, 0x0d, 0xa1, 0x6b, 0x80, 0xa4, 0xd0, 0x46, 0x60, 0xfa, 0x5d, 0x2a, 0x5b, 0x5a,
-	0x79, 0x62, 0x25, 0xa4, 0x29, 0x1b, 0x52, 0x44, 0xd8, 0x98, 0x44, 0x1b, 0x48, 0x12, 0x36, 0x34,
-	0x98, 0x40, 0x3c, 0x9f, 0x52, 0xc1, 0x20, 0x81, 0x3c, 0x15, 0x6b, 0x29, 0x15, 0xd6, 0xa0, 0x99,
-	0x82, 0xba, 0x48, 0xf3, 0x43, 0x9d, 0x8e, 0xb0, 0xda, 0x84, 0xd9, 0x48, 0x45, 0x54, 0x52, 0xa1,
-	0x57, 0x54, 0x7a, 0x35, 0xc5, 0x16, 0xe7, 0xcc, 0x75, 0x9e, 0x85, 0xa2, 0x22, 0x6a, 0x20, 0xee,
-	0xc9, 0x19, 0x5a, 0xad, 0x48, 0x87, 0x83, 0x2b, 0xb6, 0xf6, 0x2d, 0x6f, 0xe0, 0x5a, 0xa6, 0x7f,
-	0x1c, 0x47, 0x57, 0xed, 0x6f, 0x53, 0x6a, 0xf1, 0x45, 0x21, 0xb6, 0x25, 0xa5, 0x22, 0x74, 0x25,
-	0xaf, 0xaa, 0x46, 0x22, 0xf2, 0xe4, 0xdd, 0xa9, 0x33, 0xba, 0x82, 0x89, 0x95, 0xc2, 0x56, 0xf2,
-	0x28, 0x54, 0xd2, 0x9d, 0xfc, 0x7b, 0xd1, 0x56, 0xcf, 0xdc, 0x4e, 0xb6, 0xf1, 0x5b, 0x70, 0x2e,
-	0x92, 0x1e, 0xaa, 0x10, 0x38, 0x0e, 0x62, 0x0c, 0x9a, 0x92, 0x4b, 0x95, 0x08, 0xf2, 0x31, 0xd0,
-	0x86, 0x6e, 0x61, 0x68, 0xe0, 0xfd, 0xc8, 0xc0, 0x7c, 0xea, 0x46, 0xa2, 0x76, 0xbd, 0x0b, 0xb5,
-	0xd8, 0x75, 0xdf, 0x17, 0x17, 0x85, 0x90, 0xf8, 0x85, 0x97, 0x97, 0xfd, 0x02, 0xc0, 0xd0, 0x2d,
-	0x2f, 0xb6, 0xd4, 0xfd, 0x5e, 0x86, 0x52, 0xdf, 0x14, 0x78, 0x2b, 0xf8, 0x98, 0x7b, 0x80, 0x24,
-	0x2e, 0x50, 0xff, 0x3c, 0x9c, 0x4f, 0xe5, 0xd5, 0xa6, 0x6b, 0x5d, 0x57, 0xb9, 0xf9, 0xc1, 0x10,
-	0x63, 0x19, 0x4a, 0xb1, 0xf4, 0x17, 0xde, 0x15, 0x74, 0x88, 0x32, 0xbf, 0xfe, 0xa7, 0x0c, 0x10,
-	0x81, 0x54, 0xd4, 0x4a, 0x02, 0xfa, 0x7c, 0x4c, 0xcf, 0x78, 0x8c, 0x43, 0x9c, 0xcd, 0x1b, 0xe1,
-	0x8c, 0xe8, 0x83, 0x49, 0x64, 0xe1, 0xb1, 0x5d, 0xe4, 0xa4, 0x55, 0x1a, 0x4a, 0x25, 0x9b, 0x56,
-	0x69, 0x84, 0x2a, 0x61, 0x68, 0xb9, 0xfb, 0x09, 0xed, 0x64, 0xb8, 0xfa, 0x61, 0x1e, 0x8a, 0x6a,
-	0xe2, 0x27, 0x0b, 0x30, 0xd9, 0x1f, 0xb4, 0x0e, 0xe8, 0xb1, 0xac, 0x48, 0xf2, 0x8b, 0x0f, 0x7d,
-	0xaf, 0xdb, 0x41, 0xcf, 0xf2, 0xcd, 0xd7, 0x4d, 0xc7, 0x68, 0xfb, 0xd4, 0xa2, 0x6e, 0x60, 0x9b,
-	0x0e, 0x93, 0xe7, 0x38, 0x1f, 0x71, 0xaf, 0x47, 0x4c, 0xf2, 0x1c, 0x9c, 0x17, 0xd3, 0x05, 0xc2,
-	0x30, 0x75, 0xec, 0xae, 0xdd, 0xb2, 0x1d, 0x3b, 0x38, 0x4e, 0x60, 0xd8, 0x52, 0x24, 0xb3, 0x13,
-	0x89, 0xe0, 0xfd, 0xbe, 0x02, 0xd5, 0xb8, 0x05, 0xa1, 0x95, 0x17, 0x5a, 0x95, 0x98, 0x96, 0x10,
-	0xbd, 0x00, 0x40, 0xef, 0xd8, 0x49, 0x68, 0x2b, 0x72, 0x0a, 0xb2, 0xaf, 0x01, 0x51, 0x4e, 0xb6,
-	0x9c, 0x10, 0x45, 0xb1, 0x16, 0xd5, 0xe2, 0x1c, 0x14, 0xd7, 0x60, 0x4a, 0x0e, 0x37, 0x02, 0xe8,
-	0x0a, 0x7a, 0xf8, 0x49, 0x1e, 0x81, 0x1a, 0xed, 0x74, 0x28, 0x4e, 0x4d, 0x72, 0xf0, 0x11, 0x00,
-	0x97, 0xd7, 0xab, 0x8a, 0x21, 0x47, 0x1e, 0xb2, 0x0a, 0xd3, 0xe1, 0x8c, 0x34, 0x94, 0xcb, 0x65,
-	0xc9, 0xc1, 0x05, 0x5f, 0x83, 0x32, 0x3f, 0xbb, 0x01, 0x33, 0x3a, 0x8e, 0xd9, 0x65, 0x98, 0xba,
-	0x33, 0xcd, 0x6b, 0xa7, 0x3e, 0xd3, 0xac, 0xed, 0x09, 0xb5, 0xe7, 0xb9, 0x16, 0xb6, 0x3e, 0x2c,
-	0x22, 0xd4, 0x5f, 0x86, 0x52, 0x8c, 0x4f, 0x2a, 0x30, 0xb5, 0xfb, 0xca, 0xee, 0xfe, 0xee, 0xe6,
-	0xcb, 0xd5, 0xff, 0x5b, 0xca, 0x16, 0x32, 0x64, 0x01, 0x66, 0x90, 0xb0, 0xbf, 0xb3, 0x6d, 0xec,
-	0x7c, 0x6a, 0x77, 0xbf, 0x9a, 0x11, 0xf4, 0x39, 0x28, 0xdf, 0xda, 0xdd, 0xbf, 0xb1, 0xad, 0x6f,
-	0xde, 0xda, 0xdc, 0x7a, 0x79, 0xa7, 0x9a, 0xe5, 0xd4, 0xba, 0x03, 0x8b, 0xa2, 0x4b, 0xd7, 0xa9,
-	0xc9, 0xf8, 0x1d, 0x3a, 0xe4, 0xc9, 0x49, 0xdb, 0x9e, 0x2f, 0x1a, 0x82, 0x68, 0x2a, 0xc1, 0x42,
-	0x8f, 0xd9, 0x3f, 0xa3, 0xc8, 0x38, 0xbe, 0xcc, 0x85, 0x05, 0x24, 0x8b, 0x0d, 0x13, 0x16, 0x8f,
-	0x10, 0x31, 0x72, 0x11, 0x62, 0xd4, 0xff, 0x93, 0x81, 0x62, 0x04, 0x8c, 0x4a, 0x2f, 0x13, 0xd7,
-	0x53, 0xed, 0x57, 0x36, 0xd6, 0x7e, 0x9d, 0x0a, 0x26, 0xe4, 0x1c, 0x14, 0xa3, 0x2a, 0x83, 0x49,
-	0x51, 0xb0, 0xc2, 0xc2, 0xf2, 0x42, 0x6c, 0x0c, 0x48, 0x16, 0xb2, 0x10, 0x16, 0x27, 0x86, 0xa7,
-	0x80, 0x44, 0x3d, 0x93, 0xc8, 0xfa, 0x2c, 0x2c, 0x8d, 0xa8, 0x6a, 0xa1, 0x91, 0xc9, 0xa8, 0xbe,
-	0x0c, 0x15, 0x37, 0x09, 0xae, 0x6f, 0x66, 0xa0, 0x36, 0x34, 0xfd, 0x8e, 0x44, 0xd7, 0x54, 0xc4,
-	0xd9, 0xa1, 0x88, 0x2f, 0x00, 0x44, 0x0f, 0x03, 0x72, 0x47, 0x8a, 0x2c, 0x7c, 0x10, 0xe0, 0x1b,
-	0xd2, 0xe2, 0x90, 0x14, 0xdf, 0x10, 0x4e, 0x10, 0xcc, 0x04, 0x84, 0x4c, 0xa4, 0x21, 0xe4, 0xcf,
-	0xd9, 0xf0, 0x89, 0x53, 0x38, 0x39, 0xd2, 0xbd, 0x35, 0xa8, 0x49, 0xf7, 0xd2, 0x35, 0x00, 0xab,
-	0x20, 0x32, 0xa3, 0x6e, 0xe7, 0x14, 0x6f, 0x9f, 0x86, 0x3c, 0x77, 0x4e, 0x38, 0x7a, 0x02, 0x20,
-	0xc6, 0x87, 0x02, 0x1e, 0x8b, 0x50, 0x3a, 0x39, 0x9a, 0xf4, 0x46, 0x4e, 0x0e, 0x6d, 0xe4, 0x43,
-	0x30, 0x2d, 0x9f, 0x37, 0x7d, 0x7a, 0x44, 0x4d, 0x47, 0x16, 0x59, 0xbd, 0x8c, 0x54, 0x5d, 0x10,
-	0xc9, 0x16, 0x14, 0xa3, 0xb7, 0x85, 0xf7, 0xa7, 0xce, 0xf6, 0xb6, 0x20, 0xf6, 0xa2, 0x10, 0xbe,
-	0x09, 0xd4, 0x7f, 0x96, 0x87, 0x4a, 0x2a, 0x04, 0x72, 0x39, 0xbd, 0x7a, 0x66, 0xc4, 0xe2, 0xcf,
-	0xc4, 0x17, 0xcf, 0x9e, 0xf1, 0x5d, 0x43, 0xad, 0x4b, 0x5e, 0x80, 0x72, 0x62, 0xac, 0xcb, 0x89,
-	0xa9, 0xee, 0xf2, 0x19, 0xca, 0x8e, 0x9e, 0x50, 0x24, 0xb7, 0x80, 0xa8, 0xde, 0x5f, 0x80, 0x9d,
-	0xed, 0x76, 0x99, 0x96, 0x17, 0xe6, 0x56, 0xc7, 0x0e, 0x89, 0x52, 0x63, 0x4f, 0x2a, 0xe8, 0xb5,
-	0x7e, 0x8a, 0x22, 0x0c, 0xe3, 0x42, 0x09, 0xc3, 0x13, 0x27, 0x1b, 0xde, 0x94, 0x1a, 0x91, 0x61,
-	0x33, 0x45, 0xe1, 0x95, 0xb6, 0x20, 0xdf, 0x5a, 0x98, 0x36, 0x29, 0xcc, 0x2d, 0x8f, 0x33, 0xb7,
-	0x8d, 0x72, 0xba, 0x52, 0x20, 0xaf, 0x40, 0xe5, 0xc8, 0x73, 0x06, 0x6e, 0xc0, 0x5b, 0x49, 0x5e,
-	0x79, 0x98, 0x36, 0x25, 0x6c, 0x3c, 0x3c, 0x16, 0xc4, 0x43, 0xf1, 0x9d, 0x3b, 0x76, 0xa0, 0xcf,
-	0x1c, 0xc5, 0x3f, 0x19, 0xd9, 0x80, 0x62, 0xe0, 0x9b, 0x2e, 0xeb, 0x50, 0x9f, 0x69, 0x85, 0x93,
-	0x9f, 0x94, 0xf6, 0xa5, 0xa0, 0x1e, 0xa9, 0xd4, 0x6f, 0x03, 0xc1, 0xcd, 0x34, 0x9d, 0x3d, 0xbb,
-	0xeb, 0x52, 0x4b, 0x9c, 0xee, 0xa8, 0xf4, 0x1c, 0x8d, 0xc9, 0x7c, 0x3c, 0x19, 0xea, 0x08, 0xe5,
-	0x50, 0xd4, 0x4a, 0xb5, 0x81, 0xbf, 0xc9, 0xc0, 0x9c, 0xd8, 0x46, 0x5e, 0x42, 0xe3, 0x1d, 0xd2,
-	0x23, 0x50, 0x4b, 0xd4, 0x85, 0x58, 0x77, 0x54, 0x8d, 0x57, 0x06, 0xd1, 0xe8, 0x8c, 0x9a, 0xc2,
-	0xb2, 0xa3, 0xa7, 0xb0, 0xff, 0x61, 0x4f, 0xf4, 0x8d, 0x0c, 0x94, 0xe4, 0xe9, 0xca, 0xf1, 0xed,
-	0x43, 0xed, 0x8a, 0x16, 0x60, 0xd2, 0x3c, 0xf4, 0x06, 0x6e, 0x58, 0xec, 0xe4, 0xd7, 0x29, 0x4e,
-	0xfd, 0x35, 0x07, 0xd5, 0x74, 0x6a, 0x8c, 0x18, 0xae, 0x33, 0x23, 0x86, 0x6b, 0xb2, 0x0d, 0x05,
-	0x7c, 0x6a, 0x35, 0x1a, 0x12, 0x0e, 0xee, 0xe1, 0xad, 0x75, 0x0a, 0x55, 0x1b, 0x31, 0x2b, 0x4d,
-	0xb9, 0xeb, 0xf7, 0x6e, 0xa5, 0x49, 0x6e, 0x41, 0xa5, 0x2f, 0x2f, 0x25, 0x96, 0xc4, 0x46, 0x38,
-	0x31, 0x5d, 0x3d, 0x19, 0x11, 0xe2, 0x97, 0x18, 0x1f, 0x30, 0x42, 0x3b, 0x9c, 0xd2, 0x20, 0x4f,
-	0xc0, 0x9c, 0x32, 0xac, 0xb6, 0xcd, 0x68, 0x60, 0xc7, 0x85, 0x65, 0x86, 0xf4, 0x63, 0x96, 0x04,
-	0xbf, 0x31, 0xec, 0x8f, 0x9c, 0x9a, 0x3e, 0xa0, 0x3f, 0xcd, 0x31, 0xfe, 0x24, 0x46, 0xaa, 0x61,
-	0x7f, 0x9a, 0xf5, 0x37, 0x72, 0x50, 0x4d, 0x23, 0x15, 0xf9, 0x04, 0x4c, 0xc7, 0x80, 0xd5, 0x68,
-	0xc8, 0x21, 0x67, 0xac, 0x87, 0xc3, 0x93, 0x4a, 0x02, 0x99, 0x1b, 0x69, 0x83, 0x4d, 0x79, 0x2d,
-	0xee, 0xd7, 0x60, 0x93, 0xd8, 0xb0, 0xc8, 0xc2, 0xf4, 0x37, 0x92, 0xbe, 0xca, 0xe3, 0x7d, 0x74,
-	0x9c, 0xed, 0x51, 0xb0, 0x81, 0x13, 0x27, 0x1b, 0xc1, 0x69, 0x8c, 0x5f, 0xaa, 0x19, 0xfe, 0x62,
-	0xfa, 0x21, 0x2d, 0xd5, 0xac, 0xbb, 0x30, 0x25, 0x81, 0x80, 0x43, 0x64, 0xdf, 0xf7, 0xbc, 0x8e,
-	0xc0, 0xae, 0xb2, 0x8e, 0x1f, 0x9c, 0x8a, 0x79, 0x27, 0x81, 0x53, 0x7c, 0x90, 0x27, 0x13, 0xd8,
-	0x74, 0xf9, 0x94, 0x0a, 0x12, 0xe1, 0x52, 0xdd, 0x81, 0xe9, 0x44, 0x49, 0x88, 0xda, 0xdb, 0x4c,
-	0xbc, 0xbd, 0x1d, 0xd1, 0x6b, 0x67, 0x47, 0xf6, 0xda, 0x09, 0x48, 0xc9, 0xa5, 0x21, 0xe5, 0xc7,
-	0x19, 0x28, 0x84, 0x75, 0x83, 0xa3, 0x12, 0xa3, 0xae, 0x45, 0x7d, 0xb9, 0x94, 0xfc, 0xe2, 0x26,
-	0x7c, 0xda, 0xb6, 0xfb, 0x36, 0x75, 0x03, 0xb9, 0x4a, 0x44, 0x18, 0x8b, 0x65, 0x55, 0xc8, 0x75,
-	0x28, 0x95, 0xa3, 0x1a, 0xff, 0x53, 0x95, 0x9d, 0x89, 0x58, 0xd9, 0x89, 0x80, 0x75, 0x32, 0x01,
-	0xac, 0x09, 0xb7, 0xa7, 0xd2, 0x6e, 0x7f, 0x16, 0x0a, 0xea, 0xc7, 0x97, 0x07, 0x21, 0xfc, 0x6d,
-	0x04, 0xdb, 0x35, 0x04, 0xe8, 0x92, 0xa4, 0x89, 0x7e, 0xed, 0x72, 0xf4, 0xa3, 0x4a, 0x5b, 0x78,
-	0x9a, 0x4d, 0xfc, 0xa6, 0x72, 0x5d, 0xf8, 0x9b, 0x7c, 0x9c, 0xc8, 0xa5, 0x1e, 0x27, 0xea, 0x0e,
-	0x94, 0x77, 0x62, 0xbf, 0xd4, 0x24, 0x1b, 0xac, 0xcc, 0x3d, 0x37, 0x58, 0x17, 0x00, 0x8e, 0xbc,
-	0x80, 0x26, 0xfc, 0x29, 0x72, 0x8a, 0x70, 0xa6, 0xbe, 0x07, 0x95, 0x1b, 0xea, 0x17, 0xab, 0x2d,
-	0x33, 0xc0, 0x81, 0x26, 0xfe, 0x2b, 0x20, 0xde, 0x41, 0x68, 0x45, 0x3f, 0xff, 0x2d, 0x43, 0x29,
-	0xfe, 0xbb, 0x5f, 0x16, 0x05, 0x54, 0xc7, 0xcc, 0xb6, 0xca, 0x6f, 0xdf, 0xbd, 0x98, 0x79, 0xe7,
-	0xee, 0xc5, 0xcc, 0x5f, 0xee, 0x5e, 0xcc, 0xb4, 0x26, 0xc5, 0x7f, 0x27, 0x3c, 0xfe, 0xdf, 0x00,
-	0x00, 0x00, 0xff, 0xff, 0x00, 0x63, 0xa4, 0x99, 0xf5, 0x20, 0x00, 0x00,
+	// 2476 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0x4b, 0x73, 0x23, 0x57,
+	0xf5, 0xff, 0xb7, 0x24, 0xdb, 0xd2, 0x91, 0x6c, 0x49, 0x77, 0xfc, 0xe8, 0xd8, 0x33, 0xe3, 0x89,
+	0x26, 0xf9, 0xdb, 0x33, 0xc9, 0xc8, 0x91, 0x52, 0x21, 0x45, 0x02, 0x49, 0xac, 0xb1, 0x93, 0x31,
+	0x0c, 0x81, 0x69, 0x9b, 0x19, 0x8a, 0x4d, 0x57, 0x4b, 0xba, 0x96, 0x7a, 0xdc, 0xee, 0x16, 0x7d,
+	0x5b, 0xca, 0x98, 0xe2, 0x0b, 0x10, 0x9e, 0xc5, 0x8e, 0x25, 0xe1, 0x5d, 0x54, 0xb1, 0x62, 0x03,
+	0x55, 0x6c, 0x29, 0xd8, 0x05, 0xaa, 0x60, 0x4d, 0x4d, 0x15, 0x55, 0xe4, 0xc1, 0x02, 0xf8, 0x00,
+	0x50, 0xf7, 0xdc, 0xdb, 0xb7, 0x1f, 0x92, 0x6c, 0xcf, 0x24, 0xec, 0xd4, 0xe7, 0x7d, 0xee, 0xe3,
+	0x77, 0xce, 0xb9, 0x82, 0xf5, 0x81, 0xef, 0x05, 0xde, 0x56, 0x9b, 0x5a, 0x1d, 0xcf, 0xdd, 0x1a,
+	0x34, 0x07, 0x5b, 0xa3, 0xc6, 0x56, 0x70, 0x32, 0xa0, 0xac, 0x8e, 0x1c, 0xb2, 0x4c, 0x83, 0x3e,
+	0xf5, 0xe9, 0xf0, 0xb8, 0x2e, 0x64, 0xea, 0x83, 0xe6, 0xa0, 0x3e, 0x6a, 0xac, 0xae, 0x09, 0xc5,
+	0x8e, 0x77, 0x7c, 0xec, 0xb9, 0x5b, 0xc7, 0x94, 0x31, 0xab, 0x17, 0x2a, 0xd5, 0xbe, 0x3f, 0x0f,
+	0xc5, 0x16, 0x8a, 0xef, 0x07, 0x56, 0x40, 0x49, 0x0d, 0x4a, 0x3d, 0xea, 0x52, 0x66, 0x33, 0x33,
+	0xb0, 0x8f, 0xa9, 0xfe, 0xde, 0xdc, 0x15, 0x6d, 0x33, 0x67, 0x14, 0x25, 0xf1, 0xc0, 0x3e, 0xa6,
+	0xa4, 0x01, 0xb9, 0x43, 0xcf, 0x3f, 0xd2, 0xdf, 0xe7, 0xbc, 0x62, 0xf3, 0x62, 0x7d, 0xb2, 0xe3,
+	0xfa, 0xeb, 0x9e, 0x7f, 0x64, 0xa0, 0x28, 0xb9, 0x00, 0x39, 0xe6, 0x78, 0x81, 0xfe, 0x81, 0x30,
+	0x87, 0x1f, 0xe4, 0x0e, 0x90, 0x91, 0xe5, 0xd8, 0x5d, 0x2b, 0xf0, 0x7c, 0xd3, 0xa7, 0x3d, 0x9b,
+	0x05, 0xfe, 0x89, 0xfe, 0xc7, 0xf2, 0x95, 0xec, 0x66, 0xb1, 0xf9, 0xe4, 0x34, 0xab, 0x77, 0x43,
+	0x15, 0xa3, 0xaa, 0xb4, 0x0d, 0xa9, 0x4c, 0xd6, 0x20, 0xdf, 0xb6, 0x1c, 0xcb, 0xed, 0x50, 0xa6,
+	0xff, 0x89, 0x1b, 0xca, 0x19, 0x8a, 0x40, 0xb6, 0xe0, 0x82, 0x63, 0x05, 0x94, 0x05, 0xa6, 0x6f,
+	0xb9, 0x5d, 0xcb, 0x33, 0x8f, 0xed, 0x07, 0x94, 0xe9, 0xbf, 0x5e, 0xb9, 0x92, 0xdd, 0x2c, 0x19,
+	0x55, 0xc1, 0x33, 0x90, 0xf5, 0x39, 0xce, 0x21, 0x37, 0x80, 0x48, 0x05, 0x16, 0x58, 0x7e, 0x60,
+	0xb2, 0xbe, 0xe5, 0x77, 0xf5, 0xdf, 0xac, 0x60, 0x0e, 0x15, 0xc1, 0xda, 0xe7, 0x9c, 0x7d, 0xce,
+	0x20, 0x47, 0xb0, 0x36, 0xf0, 0xe9, 0xc8, 0xf6, 0x86, 0xcc, 0xa4, 0x03, 0xaf, 0xd3, 0x37, 0xad,
+	0x80, 0x8b, 0x58, 0x81, 0xed, 0xb9, 0x4c, 0xff, 0xc1, 0x3a, 0x26, 0x76, 0x7d, 0x5a, 0x62, 0x5f,
+	0xa0, 0x6e, 0xd7, 0x76, 0x7b, 0xdb, 0x91, 0x8e, 0xf1, 0x44, 0x68, 0x6f, 0x97, 0x9b, 0x8b, 0x71,
+	0x18, 0xb1, 0x61, 0xb5, 0x33, 0xf4, 0x7d, 0xea, 0x06, 0x93, 0x7c, 0xbd, 0xf3, 0xe8, 0xbe, 0x74,
+	0x69, 0x6e, 0xdc, 0xd5, 0x27, 0x41, 0x57, 0x79, 0xdd, 0x1f, 0xb2, 0xc0, 0x3e, 0xb4, 0x69, 0x57,
+	0x78, 0xd5, 0x7f, 0xb8, 0x8e, 0x8b, 0xb1, 0x1c, 0x0a, 0x7c, 0x26, 0xe4, 0xa3, 0x19, 0xf2, 0x22,
+	0xac, 0x84, 0x51, 0xa6, 0x35, 0x7f, 0x24, 0x34, 0x97, 0x24, 0x7f, 0x5c, 0x71, 0x82, 0x4f, 0xdf,
+	0xf3, 0x02, 0xfd, 0xc7, 0x5c, 0xb1, 0x64, 0x2c, 0x8d, 0xb9, 0x34, 0x3c, 0x2f, 0x20, 0x2f, 0xc0,
+	0xf2, 0xb8, 0x47, 0xd4, 0xfb, 0x89, 0xd0, 0x5b, 0x4c, 0x3b, 0x44, 0xb5, 0x4f, 0xc0, 0xb2, 0x14,
+	0xef, 0x60, 0xd6, 0x66, 0xdb, 0x0e, 0x0e, 0x6d, 0xea, 0x74, 0xf5, 0x9f, 0xca, 0x38, 0x13, 0xec,
+	0x96, 0xe4, 0x92, 0x4d, 0x28, 0x1f, 0xda, 0xae, 0xe5, 0xd8, 0x5f, 0x55, 0x89, 0xfd, 0x4c, 0x28,
+	0x2c, 0x28, 0xba, 0xc8, 0xe8, 0xff, 0x21, 0xa2, 0x88, 0x80, 0x7e, 0x2e, 0x02, 0x9a, 0x57, 0x64,
+	0x8c, 0xe4, 0x0e, 0x90, 0x30, 0x81, 0x8e, 0xef, 0x31, 0xe6, 0xd8, 0xee, 0x11, 0xd3, 0xbf, 0xbe,
+	0x71, 0xfa, 0xad, 0xb8, 0x19, 0x8a, 0x1a, 0x55, 0xa9, 0xad, 0x28, 0x8c, 0xec, 0xc3, 0x05, 0xb5,
+	0x98, 0x31, 0x9b, 0x6f, 0x9f, 0xdb, 0x26, 0x09, 0xd5, 0x63, 0x46, 0xa3, 0xcb, 0xd1, 0x76, 0xbc,
+	0xce, 0x11, 0xa6, 0xc4, 0xf4, 0x6f, 0x6c, 0xe0, 0x65, 0x92, 0x97, 0xa3, 0xc5, 0x39, 0x3c, 0xab,
+	0xd4, 0x5d, 0x0a, 0xa8, 0x14, 0xff, 0x66, 0x42, 0x1c, 0x21, 0x48, 0x88, 0xbf, 0x04, 0x4f, 0x48,
+	0x71, 0xab, 0x13, 0xd8, 0x23, 0x6a, 0xda, 0x6e, 0x97, 0x3e, 0x90, 0x5a, 0xdf, 0x12, 0x5a, 0xcb,
+	0x42, 0x62, 0x1b, 0x05, 0xf6, 0x38, 0x5f, 0xe8, 0xbe, 0x08, 0x2b, 0xa1, 0x2b, 0xc7, 0x62, 0x7d,
+	0xda, 0x35, 0x15, 0x26, 0x7c, 0x7b, 0x03, 0x31, 0x61, 0x49, 0xfa, 0x13, 0xec, 0x56, 0x08, 0x10,
+	0x5f, 0x56, 0x00, 0x21, 0x52, 0xea, 0x53, 0xab, 0x4b, 0x7d, 0xfd, 0x3b, 0x1b, 0x88, 0x73, 0xd7,
+	0xa6, 0xad, 0x93, 0xc0, 0x4f, 0xcc, 0xf5, 0x16, 0x6a, 0x84, 0x58, 0x12, 0x23, 0x91, 0xeb, 0x50,
+	0xe9, 0xdb, 0x2c, 0xf0, 0x7c, 0xbb, 0x63, 0x39, 0x32, 0x8f, 0xef, 0x8a, 0x3c, 0xca, 0x11, 0x43,
+	0x24, 0xf0, 0x59, 0x90, 0x0b, 0x62, 0xd2, 0xa0, 0xdf, 0x30, 0xbb, 0x56, 0x60, 0xe9, 0xff, 0xac,
+	0x63, 0x10, 0x57, 0xa6, 0x05, 0xb1, 0x1b, 0xf4, 0x1b, 0x3b, 0x56, 0x60, 0x19, 0x0b, 0x42, 0x35,
+	0xfc, 0x26, 0x7b, 0x50, 0x56, 0x56, 0xcc, 0x91, 0x17, 0x50, 0xa6, 0xff, 0xab, 0x8e, 0x1b, 0x7f,
+	0xb6, 0xad, 0x79, 0x2a, 0x7f, 0xdd, 0xe5, 0x7a, 0xe4, 0x29, 0x98, 0xef, 0xd2, 0x81, 0xc7, 0xec,
+	0x40, 0x6c, 0x87, 0xfe, 0xef, 0x3a, 0x1e, 0xf5, 0x92, 0xa4, 0xe2, 0x1e, 0x90, 0x37, 0xa0, 0x14,
+	0x5f, 0x45, 0xfd, 0xdd, 0x57, 0x30, 0xf2, 0xab, 0xe7, 0x58, 0x3e, 0xa3, 0x18, 0x5b, 0xb8, 0xda,
+	0x00, 0x72, 0xbc, 0x84, 0x90, 0x6b, 0x50, 0x51, 0xc7, 0x77, 0x44, 0x7d, 0x66, 0x7b, 0xae, 0xae,
+	0xe1, 0xd5, 0x29, 0x87, 0xf4, 0xbb, 0x82, 0x4c, 0x36, 0xa0, 0x1c, 0x5e, 0x9e, 0x50, 0x32, 0x83,
+	0x92, 0x0b, 0x92, 0x1c, 0x0a, 0x2e, 0xc2, 0x8c, 0xb8, 0xad, 0x59, 0xcc, 0x40, 0x7c, 0xd4, 0x7e,
+	0x99, 0x01, 0x32, 0x0e, 0x8d, 0xa4, 0x01, 0x8b, 0x56, 0xaf, 0xe7, 0xd3, 0x5e, 0x0a, 0x1a, 0x44,
+	0x10, 0x17, 0x62, 0x3c, 0x85, 0x0b, 0x2f, 0x43, 0x0e, 0xb7, 0x2d, 0x83, 0xb9, 0x6f, 0x4c, 0xcb,
+	0x3d, 0xe6, 0x05, 0x17, 0x1c, 0x95, 0xc8, 0x35, 0x58, 0xb0, 0xdd, 0x8e, 0x33, 0xe4, 0x91, 0x9a,
+	0x58, 0x37, 0x31, 0xca, 0x56, 0x46, 0xd7, 0x8c, 0x79, 0xc5, 0xd9, 0xe7, 0x35, 0xf4, 0x06, 0x54,
+	0x3a, 0x43, 0x16, 0x78, 0xdd, 0x93, 0x28, 0xac, 0x1c, 0x0f, 0x0b, 0x85, 0xcb, 0x92, 0xa7, 0xc2,
+	0xda, 0x80, 0x72, 0x64, 0xb9, 0x4b, 0x1d, 0xeb, 0x44, 0x9f, 0x11, 0x68, 0xa5, 0xc8, 0x3b, 0x9c,
+	0x4a, 0x9e, 0x86, 0x85, 0x81, 0xef, 0x0d, 0x3c, 0x46, 0x7d, 0xb9, 0xd7, 0xb3, 0x28, 0x37, 0x1f,
+	0x52, 0x71, 0xaf, 0x6b, 0xbf, 0xd3, 0xa0, 0x18, 0x5f, 0xa9, 0x30, 0x6d, 0xed, 0x71, 0xd2, 0x9e,
+	0xb6, 0xcc, 0x99, 0xe9, 0xcb, 0x7c, 0x6d, 0x42, 0xfa, 0x59, 0x71, 0x34, 0xd2, 0xa9, 0x5f, 0x84,
+	0x02, 0xb3, 0x7b, 0xae, 0x15, 0x0c, 0x7d, 0x2a, 0x96, 0xc8, 0x88, 0x08, 0xb5, 0x7f, 0xcc, 0x40,
+	0x39, 0x15, 0x15, 0x59, 0x96, 0x4d, 0x8b, 0xa6, 0x16, 0x5f, 0xf4, 0x2d, 0xd7, 0xa1, 0x2a, 0xd2,
+	0x89, 0x21, 0x9f, 0x0c, 0xb2, 0xdc, 0x8e, 0x1d, 0x66, 0x8e, 0xe6, 0x4f, 0x42, 0x89, 0x79, 0x43,
+	0xbf, 0x43, 0xcd, 0xf8, 0x71, 0x2b, 0x0a, 0x9a, 0x28, 0x0c, 0xeb, 0x20, 0x3f, 0x85, 0x21, 0x11,
+	0x1a, 0x08, 0x52, 0x68, 0x23, 0xb0, 0xfc, 0x1e, 0x95, 0x95, 0x5e, 0xee, 0x58, 0x51, 0xd0, 0x94,
+	0x0d, 0x29, 0x82, 0x36, 0x66, 0x85, 0x0d, 0x41, 0x42, 0x1b, 0x3a, 0xcc, 0x88, 0xee, 0x65, 0x4e,
+	0x25, 0x23, 0x08, 0xe4, 0xa5, 0x58, 0xa5, 0x55, 0xc5, 0x41, 0x98, 0xc9, 0xab, 0x83, 0xb4, 0x34,
+	0x56, 0x00, 0xd0, 0x6a, 0x13, 0x2e, 0x44, 0x2a, 0x08, 0x30, 0xa8, 0x57, 0x50, 0x7a, 0x55, 0xc5,
+	0xc6, 0x7d, 0xe6, 0x3a, 0xaf, 0x42, 0x41, 0x11, 0x75, 0xc0, 0x73, 0x72, 0x8e, 0x0a, 0x14, 0xe9,
+	0x90, 0xd7, 0x60, 0x55, 0x74, 0x3c, 0x6d, 0x6f, 0xe8, 0x76, 0x2d, 0xff, 0x04, 0x9d, 0x9a, 0x7d,
+	0x8b, 0xf5, 0x9f, 0x6f, 0xea, 0x7f, 0x9f, 0x53, 0xce, 0x57, 0x50, 0xac, 0x25, 0xa5, 0xb8, 0xf3,
+	0x5b, 0x28, 0x43, 0xee, 0x28, 0x7c, 0x8d, 0x22, 0x79, 0x6f, 0xee, 0x9c, 0xa1, 0x88, 0x8b, 0x25,
+	0xf4, 0x15, 0x91, 0x3c, 0x0b, 0xe5, 0x74, 0x83, 0xf3, 0x7e, 0xb4, 0xd4, 0x0b, 0xf7, 0x93, 0xdd,
+	0x4d, 0x0b, 0xd6, 0x22, 0xe9, 0xe8, 0x10, 0x85, 0x39, 0x7c, 0x10, 0xe5, 0xa0, 0x2b, 0x39, 0x75,
+	0xa6, 0x64, 0x12, 0x9f, 0x02, 0x7d, 0xec, 0x14, 0x86, 0x06, 0x3e, 0x8c, 0x0c, 0x2c, 0xa5, 0x4e,
+	0xa4, 0xd0, 0xae, 0xf5, 0xa0, 0x1a, 0x3b, 0xee, 0x07, 0x78, 0x50, 0x08, 0x89, 0x1f, 0x78, 0x79,
+	0xd8, 0x2f, 0x01, 0x8c, 0x9d, 0xf2, 0x42, 0x5b, 0x9d, 0xef, 0x75, 0x28, 0x0e, 0x2c, 0xc4, 0x5b,
+	0xe4, 0x8b, 0xbb, 0x07, 0x82, 0xc4, 0x05, 0x6a, 0x5f, 0x83, 0x8b, 0xa9, 0x7b, 0xb5, 0xed, 0x76,
+	0x6f, 0xaa, 0xbb, 0xf9, 0xd1, 0x10, 0x63, 0x1d, 0x8a, 0xb1, 0xeb, 0x8f, 0xd1, 0xe5, 0x0d, 0x88,
+	0x6e, 0x7e, 0xed, 0xcf, 0x1a, 0x10, 0x44, 0x2a, 0xda, 0x4d, 0x02, 0xfa, 0x52, 0x4c, 0xcf, 0x7c,
+	0x8e, 0x43, 0x9c, 0xcd, 0xfb, 0x03, 0x0d, 0xdb, 0x03, 0x12, 0x59, 0x78, 0x6e, 0x4f, 0x70, 0xd2,
+	0x2a, 0x0d, 0xa5, 0x92, 0x49, 0xab, 0x34, 0x42, 0x95, 0x30, 0xb5, 0xec, 0xe3, 0xa4, 0x76, 0x3a,
+	0x5c, 0xfd, 0x22, 0x07, 0x05, 0x35, 0x08, 0x91, 0x65, 0x98, 0x1d, 0x0c, 0xdb, 0x47, 0xf4, 0x44,
+	0x56, 0x24, 0xf9, 0xc5, 0x7b, 0xe1, 0xb7, 0xec, 0xa0, 0xdf, 0xf5, 0xad, 0xb7, 0x2c, 0xc7, 0xec,
+	0xf8, 0xb4, 0x4b, 0xdd, 0xc0, 0xb6, 0x1c, 0x26, 0xf7, 0x71, 0x29, 0xe2, 0xde, 0x8c, 0x98, 0xe4,
+	0x35, 0xb8, 0x88, 0x4d, 0x97, 0x80, 0x61, 0xea, 0xd8, 0x3d, 0xbb, 0x6d, 0x3b, 0x76, 0x70, 0x92,
+	0xc0, 0xb0, 0xd5, 0x48, 0x66, 0x37, 0x12, 0x11, 0xe7, 0xfb, 0x1a, 0x54, 0xe2, 0x16, 0x50, 0x2b,
+	0x87, 0x5a, 0xe5, 0x98, 0x16, 0x8a, 0x5e, 0x02, 0xa0, 0x0f, 0xec, 0x24, 0xb4, 0x15, 0x38, 0x45,
+	0xb0, 0x6f, 0x00, 0x51, 0x41, 0xb6, 0x9d, 0x10, 0x45, 0x45, 0x2d, 0xaa, 0xc6, 0x39, 0x42, 0x5c,
+	0x87, 0x39, 0xd9, 0xf3, 0x21, 0xd0, 0xe5, 0x8d, 0xf0, 0x93, 0x3c, 0x03, 0x55, 0x7a, 0x78, 0x48,
+	0x45, 0x33, 0x29, 0xfb, 0x41, 0x04, 0xb8, 0x9c, 0x51, 0x51, 0x0c, 0xd9, 0x09, 0x92, 0x4d, 0x98,
+	0x0f, 0x5b, 0xc7, 0xb1, 0xbb, 0x5c, 0x92, 0x1c, 0xe1, 0xf0, 0x8b, 0x50, 0xe2, 0x7b, 0x37, 0x64,
+	0xe6, 0xa1, 0x63, 0xf5, 0x98, 0xb8, 0xba, 0x0b, 0xcd, 0x1b, 0x67, 0x4e, 0xaf, 0xf5, 0x7d, 0x54,
+	0x7b, 0x9d, 0x6b, 0xa1, 0xdd, 0x22, 0x8b, 0x08, 0xb5, 0xdb, 0x50, 0x8c, 0xf1, 0x49, 0x19, 0xe6,
+	0xf6, 0xde, 0xdc, 0x3b, 0xd8, 0xdb, 0xbe, 0x5d, 0xf9, 0xbf, 0xd5, 0x4c, 0x5e, 0x23, 0xcb, 0xb0,
+	0x20, 0x08, 0x07, 0xbb, 0x3b, 0xe6, 0xee, 0x97, 0xf6, 0x0e, 0x2a, 0x1a, 0xd2, 0x17, 0xa1, 0x74,
+	0x6f, 0xef, 0xe0, 0xd6, 0x8e, 0xb1, 0x7d, 0x6f, 0xbb, 0x75, 0x7b, 0xb7, 0x92, 0xe1, 0xd4, 0x9a,
+	0x03, 0x2b, 0x38, 0xa1, 0x1a, 0xd4, 0x62, 0xfc, 0x0c, 0x1d, 0xf3, 0xcb, 0x49, 0x3b, 0x9e, 0x8f,
+	0x0d, 0x41, 0x34, 0x83, 0x8b, 0x42, 0x2f, 0x6e, 0xff, 0x82, 0x22, 0x8b, 0xae, 0x6e, 0x31, 0x2c,
+	0x20, 0x19, 0xd1, 0x30, 0x89, 0xe2, 0x11, 0x22, 0x46, 0x36, 0x42, 0x8c, 0xda, 0x7f, 0x34, 0x28,
+	0x44, 0xc0, 0xa8, 0xf4, 0xb4, 0xb8, 0x9e, 0x6a, 0xbf, 0x32, 0xb1, 0xf6, 0xeb, 0x4c, 0x30, 0x21,
+	0x6b, 0x50, 0x88, 0xaa, 0x8c, 0xb8, 0x14, 0xf9, 0x6e, 0x58, 0x58, 0xde, 0x80, 0xcb, 0x53, 0x0a,
+	0x59, 0x08, 0x8b, 0x33, 0x0a, 0x15, 0xd7, 0x26, 0xd6, 0x33, 0x89, 0xac, 0xaf, 0xc2, 0xea, 0x84,
+	0xaa, 0x16, 0x1a, 0x99, 0x8d, 0xea, 0xcb, 0x58, 0x71, 0x93, 0xe0, 0xfa, 0x8e, 0x06, 0xd5, 0xb1,
+	0xa1, 0x60, 0x22, 0xba, 0xa6, 0x32, 0xce, 0x8c, 0x65, 0x7c, 0x09, 0x20, 0x9a, 0x97, 0xe4, 0x8a,
+	0x14, 0x58, 0x38, 0x27, 0xf1, 0x05, 0x69, 0x73, 0x48, 0x8a, 0x2f, 0x08, 0x27, 0x20, 0x33, 0x01,
+	0x21, 0x33, 0x69, 0x08, 0xf9, 0x4b, 0x26, 0x7c, 0xf9, 0xc1, 0x20, 0x27, 0x86, 0x57, 0x87, 0xaa,
+	0x0c, 0x2f, 0x5d, 0x03, 0x44, 0x15, 0x14, 0xcc, 0xa8, 0xdb, 0x39, 0x23, 0xda, 0x97, 0x21, 0xc7,
+	0x83, 0xc3, 0x40, 0x4f, 0x01, 0xc4, 0x58, 0x54, 0x2d, 0x9e, 0x0b, 0x2a, 0x9d, 0x9e, 0x4d, 0x7a,
+	0x21, 0x67, 0xc7, 0x16, 0xf2, 0x29, 0x98, 0x97, 0xaf, 0x3e, 0x3e, 0x1d, 0x51, 0xcb, 0x91, 0x45,
+	0xd6, 0x28, 0x09, 0xaa, 0x81, 0x44, 0xd2, 0x82, 0x42, 0x34, 0x72, 0x7d, 0x38, 0x77, 0xbe, 0x91,
+	0x0b, 0xd7, 0x22, 0x1f, 0x8e, 0x4a, 0xb5, 0xdf, 0xe6, 0xa0, 0x9c, 0x4a, 0x81, 0x5c, 0x4d, 0x7b,
+	0xd7, 0x26, 0x38, 0xff, 0x74, 0xdc, 0x79, 0xe6, 0x9c, 0xe3, 0x9e, 0xf2, 0xcb, 0xe7, 0xae, 0xc4,
+	0x1b, 0x50, 0x16, 0x87, 0xbc, 0xab, 0xe7, 0x28, 0x3b, 0x46, 0x42, 0x91, 0xdc, 0x03, 0xa2, 0x7a,
+	0x7f, 0x04, 0x3b, 0xdb, 0xed, 0x31, 0x3d, 0x87, 0xe6, 0x36, 0xa7, 0xbe, 0x28, 0x49, 0x8d, 0x7d,
+	0xa9, 0x60, 0x54, 0x07, 0x29, 0x0a, 0x1a, 0x16, 0x8e, 0x12, 0x86, 0x67, 0x4e, 0x37, 0xbc, 0x2d,
+	0x35, 0x22, 0xc3, 0x56, 0x8a, 0xc2, 0x2b, 0x6d, 0x5e, 0x8e, 0xa0, 0x4c, 0x9f, 0x45, 0x73, 0xeb,
+	0xd3, 0xcc, 0xed, 0x08, 0x39, 0x43, 0x29, 0x90, 0x37, 0xa1, 0x3c, 0xf2, 0x9c, 0xa1, 0x1b, 0xf0,
+	0x56, 0x92, 0x57, 0x1e, 0xa6, 0xcf, 0xa1, 0x8d, 0xa7, 0xa7, 0x82, 0x78, 0x28, 0xbe, 0xfb, 0xc0,
+	0x0e, 0x8c, 0x85, 0x51, 0xfc, 0x93, 0x91, 0x57, 0xa0, 0x10, 0xf8, 0x96, 0xcb, 0x0e, 0xa9, 0xcf,
+	0xf4, 0xfc, 0xe9, 0x93, 0xf6, 0x81, 0x14, 0x34, 0x22, 0x95, 0xda, 0x7d, 0x20, 0x62, 0x31, 0x2d,
+	0x67, 0xdf, 0xee, 0xb9, 0xb4, 0x8b, 0xbb, 0x3b, 0xe9, 0x7a, 0x4e, 0xc6, 0x64, 0x3e, 0x9e, 0x8c,
+	0x75, 0x84, 0x72, 0x28, 0x6a, 0xa7, 0xda, 0xc0, 0x3f, 0x68, 0xb0, 0x88, 0xcb, 0xc8, 0x4b, 0x68,
+	0xbc, 0x43, 0x7a, 0x06, 0xaa, 0x89, 0xba, 0x10, 0xeb, 0x8e, 0x2a, 0xf1, 0xca, 0x80, 0x8d, 0xce,
+	0xa4, 0x29, 0x2c, 0x33, 0x79, 0x0a, 0xfb, 0x1f, 0xf6, 0x44, 0xdf, 0xd3, 0xa0, 0x28, 0x77, 0x57,
+	0x8e, 0x6f, 0x1f, 0x6b, 0x57, 0xb4, 0x0c, 0xb3, 0xd6, 0xb1, 0x37, 0x74, 0xc3, 0x62, 0x27, 0xbf,
+	0xce, 0x08, 0xea, 0x6f, 0x59, 0xa8, 0xa4, 0xaf, 0xc6, 0x84, 0xe1, 0x5a, 0x9b, 0x30, 0x5c, 0x93,
+	0x1d, 0xc8, 0x8b, 0x17, 0x28, 0xb3, 0x21, 0xe1, 0xe0, 0x11, 0x9e, 0xa0, 0xe6, 0x84, 0x6a, 0x23,
+	0x66, 0xa5, 0x29, 0x57, 0xfd, 0xd1, 0xad, 0x34, 0xc9, 0x3d, 0x28, 0x0f, 0xe4, 0xa1, 0x14, 0x25,
+	0xb1, 0x11, 0x4e, 0x4c, 0xd7, 0x4f, 0x47, 0x84, 0xf8, 0x21, 0x16, 0x0f, 0x18, 0xa1, 0x1d, 0x4e,
+	0x69, 0x90, 0x17, 0x60, 0x51, 0x19, 0x56, 0xcb, 0x66, 0x36, 0x44, 0xc7, 0x25, 0xca, 0x0c, 0x19,
+	0xc4, 0x2c, 0x21, 0xbf, 0x31, 0x1e, 0x8f, 0x9c, 0x9a, 0x3e, 0x62, 0x3c, 0xcd, 0x29, 0xf1, 0x24,
+	0x46, 0xaa, 0xf1, 0x78, 0x9a, 0xb5, 0xb7, 0xb3, 0x50, 0x49, 0x23, 0x15, 0xf9, 0x3c, 0xcc, 0xc7,
+	0x80, 0xd5, 0x6c, 0xc8, 0x21, 0x67, 0x6a, 0x84, 0xe3, 0x93, 0x4a, 0x02, 0x99, 0x1b, 0x69, 0x83,
+	0x4d, 0x79, 0x2c, 0x1e, 0xd7, 0x60, 0x93, 0xd8, 0xb0, 0xc2, 0xc2, 0xeb, 0x6f, 0x26, 0x63, 0x95,
+	0xdb, 0xfb, 0xec, 0x34, 0xdb, 0x93, 0x60, 0x43, 0x4c, 0x9c, 0x6c, 0x02, 0xa7, 0x31, 0xdd, 0x55,
+	0x33, 0xfc, 0x23, 0xe9, 0x63, 0x72, 0xd5, 0xac, 0xb9, 0x30, 0x27, 0x81, 0x80, 0x43, 0xe4, 0xc0,
+	0xf7, 0xbc, 0x43, 0xc4, 0xae, 0x92, 0x21, 0x3e, 0x38, 0x55, 0xdc, 0x3b, 0x09, 0x9c, 0xf8, 0x41,
+	0x5e, 0x4c, 0x60, 0xd3, 0xd5, 0x33, 0x2a, 0x48, 0x84, 0x4b, 0x35, 0x07, 0xe6, 0x13, 0x25, 0x21,
+	0x6a, 0x6f, 0xb5, 0x78, 0x7b, 0x3b, 0xa1, 0xd7, 0xce, 0x4c, 0xec, 0xb5, 0x13, 0x90, 0x92, 0x4d,
+	0x43, 0xca, 0xaf, 0x34, 0xc8, 0x87, 0x75, 0x83, 0xa3, 0x12, 0xa3, 0x6e, 0x97, 0xfa, 0xd2, 0x95,
+	0xfc, 0xe2, 0x26, 0x7c, 0xda, 0xb1, 0x07, 0x36, 0x75, 0x03, 0xe9, 0x25, 0x22, 0x4c, 0xc5, 0xb2,
+	0x0a, 0x64, 0x0f, 0x29, 0x95, 0xa3, 0x1a, 0xff, 0xa9, 0xca, 0xce, 0x4c, 0xac, 0xec, 0x44, 0xc0,
+	0x3a, 0x9b, 0x00, 0xd6, 0x44, 0xd8, 0x73, 0xe9, 0xb0, 0xbf, 0x02, 0x79, 0xf5, 0x26, 0xfd, 0x24,
+	0x84, 0x4f, 0xc6, 0xa2, 0x5d, 0x13, 0x00, 0x5d, 0x94, 0x34, 0xec, 0xd7, 0xae, 0x46, 0x6f, 0xcd,
+	0x1d, 0x8c, 0x34, 0x93, 0x78, 0x6a, 0xbe, 0x89, 0xf1, 0x26, 0x1f, 0x27, 0xb2, 0xa9, 0xc7, 0x89,
+	0x9a, 0x03, 0xa5, 0xdd, 0xd8, 0x03, 0x76, 0xb2, 0xc1, 0xd2, 0x1e, 0xb9, 0xc1, 0xba, 0x04, 0x30,
+	0xf2, 0x02, 0x9a, 0x88, 0xa7, 0xc0, 0x29, 0x18, 0x4c, 0x6d, 0x1f, 0xca, 0xb7, 0xd4, 0x43, 0x7e,
+	0xcb, 0x0a, 0xc4, 0x40, 0x13, 0xff, 0x73, 0x44, 0x9c, 0x41, 0x68, 0x47, 0xff, 0x8a, 0xac, 0x43,
+	0x31, 0xfe, 0x77, 0x48, 0x46, 0x08, 0xa8, 0x8e, 0x99, 0xb5, 0x4a, 0xbf, 0x7f, 0x78, 0x59, 0x7b,
+	0xf7, 0xe1, 0x65, 0xed, 0xaf, 0x0f, 0x2f, 0x6b, 0xed, 0x59, 0xfc, 0xd3, 0xf6, 0xf9, 0xff, 0x06,
+	0x00, 0x00, 0xff, 0xff, 0x4b, 0xdd, 0xf5, 0x05, 0x0c, 0x1e, 0x00, 0x00,
 }
 
 func (m *BeaconState) Marshal() (dAtA []byte, err error) {
@@ -2865,115 +2761,6 @@ func (m *BeaconState) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintTypes(dAtA, i, uint64(m.DepositIndex))
 	}
-	if m.ValidatorRegistryUpdateEpoch != 0 {
-		dAtA[i] = 0x88
-		i++
-		dAtA[i] = 0xf4
-		i++
-		dAtA[i] = 0x3
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.ValidatorRegistryUpdateEpoch))
-	}
-	if m.PreviousShufflingStartShard != 0 {
-		dAtA[i] = 0x98
-		i++
-		dAtA[i] = 0xf4
-		i++
-		dAtA[i] = 0x3
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.PreviousShufflingStartShard))
-	}
-	if m.CurrentShufflingStartShard != 0 {
-		dAtA[i] = 0xa0
-		i++
-		dAtA[i] = 0xf4
-		i++
-		dAtA[i] = 0x3
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.CurrentShufflingStartShard))
-	}
-	if m.PreviousShufflingEpoch != 0 {
-		dAtA[i] = 0xa8
-		i++
-		dAtA[i] = 0xf4
-		i++
-		dAtA[i] = 0x3
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.PreviousShufflingEpoch))
-	}
-	if m.CurrentShufflingEpoch != 0 {
-		dAtA[i] = 0xb0
-		i++
-		dAtA[i] = 0xf4
-		i++
-		dAtA[i] = 0x3
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(m.CurrentShufflingEpoch))
-	}
-	if len(m.PreviousShufflingSeedHash32) > 0 {
-		dAtA[i] = 0xba
-		i++
-		dAtA[i] = 0xf4
-		i++
-		dAtA[i] = 0x3
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.PreviousShufflingSeedHash32)))
-		i += copy(dAtA[i:], m.PreviousShufflingSeedHash32)
-	}
-	if len(m.CurrentShufflingSeedHash32) > 0 {
-		dAtA[i] = 0xc2
-		i++
-		dAtA[i] = 0xf4
-		i++
-		dAtA[i] = 0x3
-		i++
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.CurrentShufflingSeedHash32)))
-		i += copy(dAtA[i:], m.CurrentShufflingSeedHash32)
-	}
-	if len(m.BatchedBlockRootHash32S) > 0 {
-		for _, b := range m.BatchedBlockRootHash32S {
-			dAtA[i] = 0xea
-			i++
-			dAtA[i] = 0xf4
-			i++
-			dAtA[i] = 0x3
-			i++
-			i = encodeVarintTypes(dAtA, i, uint64(len(b)))
-			i += copy(dAtA[i:], b)
-		}
-	}
-	if len(m.LatestCrosslinks) > 0 {
-		for _, msg := range m.LatestCrosslinks {
-			dAtA[i] = 0xf2
-			i++
-			dAtA[i] = 0xf4
-			i++
-			dAtA[i] = 0x3
-			i++
-			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
-	if len(m.LatestAttestations) > 0 {
-		for _, msg := range m.LatestAttestations {
-			dAtA[i] = 0xfa
-			i++
-			dAtA[i] = 0xf4
-			i++
-			dAtA[i] = 0x3
-			i++
-			i = encodeVarintTypes(dAtA, i, uint64(msg.Size()))
-			n, err := msg.MarshalTo(dAtA[i:])
-			if err != nil {
-				return 0, err
-			}
-			i += n
-		}
-	}
 	if m.LatestBlock != nil {
 		dAtA[i] = 0x82
 		i++
@@ -4510,47 +4297,6 @@ func (m *BeaconState) Size() (n int) {
 	if m.DepositIndex != 0 {
 		n += 3 + sovTypes(uint64(m.DepositIndex))
 	}
-	if m.ValidatorRegistryUpdateEpoch != 0 {
-		n += 3 + sovTypes(uint64(m.ValidatorRegistryUpdateEpoch))
-	}
-	if m.PreviousShufflingStartShard != 0 {
-		n += 3 + sovTypes(uint64(m.PreviousShufflingStartShard))
-	}
-	if m.CurrentShufflingStartShard != 0 {
-		n += 3 + sovTypes(uint64(m.CurrentShufflingStartShard))
-	}
-	if m.PreviousShufflingEpoch != 0 {
-		n += 3 + sovTypes(uint64(m.PreviousShufflingEpoch))
-	}
-	if m.CurrentShufflingEpoch != 0 {
-		n += 3 + sovTypes(uint64(m.CurrentShufflingEpoch))
-	}
-	l = len(m.PreviousShufflingSeedHash32)
-	if l > 0 {
-		n += 3 + l + sovTypes(uint64(l))
-	}
-	l = len(m.CurrentShufflingSeedHash32)
-	if l > 0 {
-		n += 3 + l + sovTypes(uint64(l))
-	}
-	if len(m.BatchedBlockRootHash32S) > 0 {
-		for _, b := range m.BatchedBlockRootHash32S {
-			l = len(b)
-			n += 3 + l + sovTypes(uint64(l))
-		}
-	}
-	if len(m.LatestCrosslinks) > 0 {
-		for _, e := range m.LatestCrosslinks {
-			l = e.Size()
-			n += 3 + l + sovTypes(uint64(l))
-		}
-	}
-	if len(m.LatestAttestations) > 0 {
-		for _, e := range m.LatestAttestations {
-			l = e.Size()
-			n += 3 + l + sovTypes(uint64(l))
-		}
-	}
 	if m.LatestBlock != nil {
 		l = m.LatestBlock.Size()
 		n += 3 + l + sovTypes(uint64(l))
@@ -6232,269 +5978,6 @@ func (m *BeaconState) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-		case 8001:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorRegistryUpdateEpoch", wireType)
-			}
-			m.ValidatorRegistryUpdateEpoch = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ValidatorRegistryUpdateEpoch |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 8003:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PreviousShufflingStartShard", wireType)
-			}
-			m.PreviousShufflingStartShard = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.PreviousShufflingStartShard |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 8004:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CurrentShufflingStartShard", wireType)
-			}
-			m.CurrentShufflingStartShard = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.CurrentShufflingStartShard |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 8005:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PreviousShufflingEpoch", wireType)
-			}
-			m.PreviousShufflingEpoch = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.PreviousShufflingEpoch |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 8006:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CurrentShufflingEpoch", wireType)
-			}
-			m.CurrentShufflingEpoch = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.CurrentShufflingEpoch |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 8007:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PreviousShufflingSeedHash32", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.PreviousShufflingSeedHash32 = append(m.PreviousShufflingSeedHash32[:0], dAtA[iNdEx:postIndex]...)
-			if m.PreviousShufflingSeedHash32 == nil {
-				m.PreviousShufflingSeedHash32 = []byte{}
-			}
-			iNdEx = postIndex
-		case 8008:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CurrentShufflingSeedHash32", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.CurrentShufflingSeedHash32 = append(m.CurrentShufflingSeedHash32[:0], dAtA[iNdEx:postIndex]...)
-			if m.CurrentShufflingSeedHash32 == nil {
-				m.CurrentShufflingSeedHash32 = []byte{}
-			}
-			iNdEx = postIndex
-		case 8013:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BatchedBlockRootHash32S", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.BatchedBlockRootHash32S = append(m.BatchedBlockRootHash32S, make([]byte, postIndex-iNdEx))
-			copy(m.BatchedBlockRootHash32S[len(m.BatchedBlockRootHash32S)-1], dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 8014:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LatestCrosslinks", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.LatestCrosslinks = append(m.LatestCrosslinks, &Crosslink{})
-			if err := m.LatestCrosslinks[len(m.LatestCrosslinks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 8015:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LatestAttestations", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.LatestAttestations = append(m.LatestAttestations, &PendingAttestation{})
-			if err := m.LatestAttestations[len(m.LatestAttestations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 8016:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field LatestBlock", wireType)
diff --git a/proto/beacon/p2p/v1/types.proto b/proto/beacon/p2p/v1/types.proto
index 226b47922e98..0f4cf389657e 100644
--- a/proto/beacon/p2p/v1/types.proto
+++ b/proto/beacon/p2p/v1/types.proto
@@ -45,18 +45,8 @@ message BeaconState {
   repeated Eth1Data eth1_data_votes = 6002;
   uint64 deposit_index = 6003;
 
-  // Deprecated [8001-9000]
-  uint64 validator_registry_update_epoch = 8001 [deprecated=true];
-  uint64 previous_shuffling_start_shard = 8003 [deprecated=true];
-  uint64 current_shuffling_start_shard = 8004 [deprecated=true];
-  uint64 previous_shuffling_epoch = 8005 [deprecated=true];
-  uint64 current_shuffling_epoch = 8006 [deprecated=true];
-  bytes previous_shuffling_seed_hash32 = 8007 [deprecated=true];
-  bytes current_shuffling_seed_hash32 = 8008 [deprecated=true];
-  repeated bytes batched_block_root_hash32s = 8013 [deprecated=true];
-  repeated Crosslink latest_crosslinks = 8014 [deprecated=true];
-  repeated PendingAttestation latest_attestations = 8015 [deprecated=true];
-  BeaconBlock latest_block = 8016 [deprecated=true];
+  // Prysm customized field [8001-9000]
+  BeaconBlock latest_block = 8016;
 }
 
 message Fork {
diff --git a/proto/beacon/rpc/v1/services.pb.go b/proto/beacon/rpc/v1/services.pb.go
index 8f5394fdd345..2c13dafe7b2c 100755
--- a/proto/beacon/rpc/v1/services.pb.go
+++ b/proto/beacon/rpc/v1/services.pb.go
@@ -7,13 +7,12 @@ import (
 	context "context"
 	encoding_binary "encoding/binary"
 	fmt "fmt"
-	io "io"
-	math "math"
-
 	proto "github.com/gogo/protobuf/proto"
 	types "github.com/gogo/protobuf/types"
 	v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	grpc "google.golang.org/grpc"
+	io "io"
+	math "math"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/proto/sharding/p2p/v1/messages.pb.go b/proto/sharding/p2p/v1/messages.pb.go
index 61228b93def4..ba268c5f4bac 100644
--- a/proto/sharding/p2p/v1/messages.pb.go
+++ b/proto/sharding/p2p/v1/messages.pb.go
@@ -5,10 +5,9 @@ package ethereum_sharding_p2p_v1
 
 import (
 	fmt "fmt"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
-
-	proto "github.com/gogo/protobuf/proto"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.