// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: emissions/v9/genesis.proto

package types

import (
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	github_com_allora_network_allora_chain_math "github.com/allora-network/allora-chain/math"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// GenesisState is the state that must be provided at genesis.
type GenesisState struct {
	/// PARAMS
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
	/// WHITELISTS
	CoreTeamAddresses []string `protobuf:"bytes,2,rep,name=core_team_addresses,json=coreTeamAddresses,proto3" json:"core_team_addresses,omitempty"`
	/// TOPIC
	// the next topic id to be used, equal to the number of topics that have been
	// created
	NextTopicId uint64 `protobuf:"varint,3,opt,name=next_topic_id,json=nextTopicId,proto3" json:"next_topic_id,omitempty"`
	// every topic that has been created indexed by their topicId starting from 1
	// (0 is reserved for the root network)
	Topics       []*TopicIdAndTopic `protobuf:"bytes,4,rep,name=topics,proto3" json:"topics,omitempty"`
	ActiveTopics []uint64           `protobuf:"varint,5,rep,packed,name=active_topics,json=activeTopics,proto3" json:"active_topics,omitempty"`
	// every topic that has been churned and ready to be rewarded i.e. reputer
	// losses have been committed
	RewardableTopics []uint64 `protobuf:"varint,6,rep,packed,name=rewardable_topics,json=rewardableTopics,proto3" json:"rewardable_topics,omitempty"`
	// for a topic, what is every worker node that has registered to it?
	TopicWorkers []*TopicAndActorId `protobuf:"bytes,7,rep,name=topic_workers,json=topicWorkers,proto3" json:"topic_workers,omitempty"`
	// for a topic, what is every reputer node that has registered to it?
	TopicReputers []*TopicAndActorId `protobuf:"bytes,8,rep,name=topic_reputers,json=topicReputers,proto3" json:"topic_reputers,omitempty"`
	// map of (topic) -> nonce/block height
	TopicRewardNonce []*TopicIdAndBlockHeight `protobuf:"bytes,9,rep,name=topic_reward_nonce,json=topicRewardNonce,proto3" json:"topic_reward_nonce,omitempty"`
	/// SCORES
	// ALSO SEE 61, 62, 63 below
	// map of (topic, block_height, worker) -> score
	InfererScoresByBlock []*TopicIdBlockHeightScores `protobuf:"bytes,10,rep,name=inferer_scores_by_block,json=infererScoresByBlock,proto3" json:"inferer_scores_by_block,omitempty"`
	// map of (topic, block_height, worker) -> score
	ForecasterScoresByBlock []*TopicIdBlockHeightScores `protobuf:"bytes,11,rep,name=forecaster_scores_by_block,json=forecasterScoresByBlock,proto3" json:"forecaster_scores_by_block,omitempty"`
	// map of (topic, block_height, reputer) -> score
	ReputerScoresByBlock []*TopicIdBlockHeightScores `protobuf:"bytes,12,rep,name=reputer_scores_by_block,json=reputerScoresByBlock,proto3" json:"reputer_scores_by_block,omitempty"`
	// SEE 13, 14, 15 reserved; see the top of GenesisState
	// map of (topic, reputer) -> listening coefficient
	ReputerListeningCoefficient []*TopicIdActorIdListeningCoefficient `protobuf:"bytes,16,rep,name=reputer_listening_coefficient,json=reputerListeningCoefficient,proto3" json:"reputer_listening_coefficient,omitempty"`
	// map of (topic, reputer) -> previous reward (used for EMA)
	PreviousReputerRewardFraction []*TopicIdActorIdDec `protobuf:"bytes,17,rep,name=previous_reputer_reward_fraction,json=previousReputerRewardFraction,proto3" json:"previous_reputer_reward_fraction,omitempty"`
	// map of (topic, worker) -> previous reward for inference (used for EMA)
	PreviousInferenceRewardFraction []*TopicIdActorIdDec `protobuf:"bytes,18,rep,name=previous_inference_reward_fraction,json=previousInferenceRewardFraction,proto3" json:"previous_inference_reward_fraction,omitempty"`
	// map of (topic, worker) -> previous reward for forecast (used for EMA)
	PreviousForecastRewardFraction []*TopicIdActorIdDec `protobuf:"bytes,19,rep,name=previous_forecast_reward_fraction,json=previousForecastRewardFraction,proto3" json:"previous_forecast_reward_fraction,omitempty"`
	// map of (topic, forecaster) -> ratio of forecaster score
	PreviousForecasterScoreRatio []*TopicIdAndDec `protobuf:"bytes,20,rep,name=previous_forecaster_score_ratio,json=previousForecasterScoreRatio,proto3" json:"previous_forecaster_score_ratio,omitempty"`
	// total sum stake of all stakers on the network
	TotalStake cosmossdk_io_math.Int `protobuf:"bytes,21,opt,name=total_stake,json=totalStake,proto3,customtype=cosmossdk.io/math.Int" json:"total_stake"`
	// for every topic, how much total stake does that topic have accumulated?
	TopicStake []*TopicIdAndInt `protobuf:"bytes,22,rep,name=topic_stake,json=topicStake,proto3" json:"topic_stake,omitempty"`
	// stake reputer placed in topic + delegate stake placed in them,
	// signalling their total authority on the topic
	// (topic Id, reputer) -> stake from reputer on self +
	// stakeFromDelegatorsUponReputer
	StakeReputerAuthority []*TopicIdActorIdInt `protobuf:"bytes,23,rep,name=stake_reputer_authority,json=stakeReputerAuthority,proto3" json:"stake_reputer_authority,omitempty"`
	// map of (topic id, delegator) -> total amount of stake in that topic placed
	// by that delegator
	StakeSumFromDelegator []*TopicIdActorIdInt `protobuf:"bytes,24,rep,name=stake_sum_from_delegator,json=stakeSumFromDelegator,proto3" json:"stake_sum_from_delegator,omitempty"`
	// map of (topic id, delegator, reputer) -> amount of stake that has been
	// placed by that delegator on that target
	DelegatedStakes []*TopicIdDelegatorReputerDelegatorInfo `protobuf:"bytes,25,rep,name=delegated_stakes,json=delegatedStakes,proto3" json:"delegated_stakes,omitempty"`
	// map of (topic id, reputer) -> total amount of stake that has been placed on
	// that reputer by delegators
	StakeFromDelegatorsUponReputer []*TopicIdActorIdInt `protobuf:"bytes,26,rep,name=stake_from_delegators_upon_reputer,json=stakeFromDelegatorsUponReputer,proto3" json:"stake_from_delegators_upon_reputer,omitempty"`
	// map of (topicId, reputer) -> share of delegate reward
	DelegateRewardPerShare []*TopicIdActorIdDec `protobuf:"bytes,27,rep,name=delegate_reward_per_share,json=delegateRewardPerShare,proto3" json:"delegate_reward_per_share,omitempty"`
	// stake removals are double indexed to avoid O(n) lookups when removing stake
	// map of (blockHeight, topic, reputer) -> removal information for that
	// reputer
	StakeRemovalsByBlock []*BlockHeightTopicIdReputerStakeRemovalInfo `protobuf:"bytes,28,rep,name=stake_removals_by_block,json=stakeRemovalsByBlock,proto3" json:"stake_removals_by_block,omitempty"`
	// key set of (reputer, topic, blockHeight) to existence of a removal in the
	// forwards map
	StakeRemovalsByActor []*ActorIdTopicIdBlockHeight `protobuf:"bytes,29,rep,name=stake_removals_by_actor,json=stakeRemovalsByActor,proto3" json:"stake_removals_by_actor,omitempty"`
	// delegate stake removals are double indexed to avoid O(n) lookups when
	// removing stake map of (blockHeight, topic, delegator, reputer staked upon)
	// -> (list of reputers delegated upon and info) to have stake removed at that
	// block
	DelegateStakeRemovalsByBlock []*BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo `protobuf:"bytes,30,rep,name=delegate_stake_removals_by_block,json=delegateStakeRemovalsByBlock,proto3" json:"delegate_stake_removals_by_block,omitempty"`
	// key set of (delegator, reputer, topicId, blockHeight) to existence of a
	// removal in the forwards map
	DelegateStakeRemovalsByActor []*DelegatorReputerTopicIdBlockHeight `protobuf:"bytes,31,rep,name=delegate_stake_removals_by_actor,json=delegateStakeRemovalsByActor,proto3" json:"delegate_stake_removals_by_actor,omitempty"`
	/// MISC GLOBAL STATE
	// map of (topic, worker) -> inference
	Inferences []*TopicIdActorIdInference `protobuf:"bytes,32,rep,name=inferences,proto3" json:"inferences,omitempty"`
	// map of (topic, worker) -> forecast[]
	Forecasts []*TopicIdActorIdForecast `protobuf:"bytes,33,rep,name=forecasts,proto3" json:"forecasts,omitempty"`
	// map of worker id to node data about that worker
	Workers []*LibP2PKeyAndOffchainNode `protobuf:"bytes,34,rep,name=workers,proto3" json:"workers,omitempty"`
	// map of reputer id to node data about that reputer
	Reputers []*LibP2PKeyAndOffchainNode `protobuf:"bytes,35,rep,name=reputers,proto3" json:"reputers,omitempty"`
	// fee revenue collected by a topic over the course of the last reward cadence
	TopicFeeRevenue []*TopicIdAndInt `protobuf:"bytes,36,rep,name=topic_fee_revenue,json=topicFeeRevenue,proto3" json:"topic_fee_revenue,omitempty"`
	// store previous weights for exponential moving average in rewards calc
	PreviousTopicWeight []*TopicIdAndDec `protobuf:"bytes,37,rep,name=previous_topic_weight,json=previousTopicWeight,proto3" json:"previous_topic_weight,omitempty"`
	// map of (topic, block_height) -> Inference
	AllInferences []*TopicIdBlockHeightInferences `protobuf:"bytes,38,rep,name=all_inferences,json=allInferences,proto3" json:"all_inferences,omitempty"`
	// map of (topic, block_height) -> Forecast
	AllForecasts []*TopicIdBlockHeightForecasts `protobuf:"bytes,39,rep,name=all_forecasts,json=allForecasts,proto3" json:"all_forecasts,omitempty"`
	// map of (topic, block_height) -> ReputerValueBundles (1 per reputer active
	// at that time)
	AllLossBundles []*TopicIdBlockHeightReputerValueBundles `protobuf:"bytes,40,rep,name=all_loss_bundles,json=allLossBundles,proto3" json:"all_loss_bundles,omitempty"`
	// map of (topic, block_height) -> ValueBundle (1 network wide bundle per
	// timestep)
	NetworkLossBundles []*TopicIdBlockHeightValueBundles `protobuf:"bytes,41,rep,name=network_loss_bundles,json=networkLossBundles,proto3" json:"network_loss_bundles,omitempty"`
	// Percentage of all rewards, paid out to staked reputers, during the previous
	// reward cadence. Used by mint module
	PreviousPercentageRewardToStakedReputers github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,42,opt,name=previous_percentage_reward_to_staked_reputers,json=previousPercentageRewardToStakedReputers,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"previous_percentage_reward_to_staked_reputers"`
	// SEE 55, 56 below
	// map of (topic) -> unfulfilled nonces
	UnfulfilledWorkerNonces []*TopicIdAndNonces `protobuf:"bytes,43,rep,name=unfulfilled_worker_nonces,json=unfulfilledWorkerNonces,proto3" json:"unfulfilled_worker_nonces,omitempty"`
	// map of (topic) -> unfulfilled nonces
	UnfulfilledReputerNonces []*TopicIdAndReputerRequestNonces `protobuf:"bytes,44,rep,name=unfulfilled_reputer_nonces,json=unfulfilledReputerNonces,proto3" json:"unfulfilled_reputer_nonces,omitempty"`
	/// REGRETS
	// map of (topic, worker) -> regret of worker from comparing loss of worker
	// relative to loss of other inferers
	LatestInfererNetworkRegrets []*TopicIdActorIdTimeStampedValue `protobuf:"bytes,45,rep,name=latest_inferer_network_regrets,json=latestInfererNetworkRegrets,proto3" json:"latest_inferer_network_regrets,omitempty"`
	// map of (topic, worker) -> regret of worker from comparing loss of worker
	// relative to loss of other forecasters
	LatestForecasterNetworkRegrets []*TopicIdActorIdTimeStampedValue `protobuf:"bytes,46,rep,name=latest_forecaster_network_regrets,json=latestForecasterNetworkRegrets,proto3" json:"latest_forecaster_network_regrets,omitempty"`
	// map of (topic, forecaster, inferer) -> R^+_{ij_kk} regret of forecaster
	// loss from comparing one-in loss with all network inferer (3rd index)
	// regrets L_ij made under the regime of the one-in forecaster (2nd index)
	LatestOneInForecasterNetworkRegrets []*TopicIdActorIdActorIdTimeStampedValue `protobuf:"bytes,47,rep,name=latest_one_in_forecaster_network_regrets,json=latestOneInForecasterNetworkRegrets,proto3" json:"latest_one_in_forecaster_network_regrets,omitempty"`
	// the forecaster (2nd index) regrets made under the regime of the same
	// forecaster as a one-in forecaster
	LatestNaiveInfererNetworkRegrets               []*TopicIdActorIdTimeStampedValue        `protobuf:"bytes,48,rep,name=latest_naive_inferer_network_regrets,json=latestNaiveInfererNetworkRegrets,proto3" json:"latest_naive_inferer_network_regrets,omitempty"`
	LatestOneOutInfererInfererNetworkRegrets       []*TopicIdActorIdActorIdTimeStampedValue `protobuf:"bytes,49,rep,name=latest_one_out_inferer_inferer_network_regrets,json=latestOneOutInfererInfererNetworkRegrets,proto3" json:"latest_one_out_inferer_inferer_network_regrets,omitempty"`
	LatestOneOutInfererForecasterNetworkRegrets    []*TopicIdActorIdActorIdTimeStampedValue `protobuf:"bytes,50,rep,name=latest_one_out_inferer_forecaster_network_regrets,json=latestOneOutInfererForecasterNetworkRegrets,proto3" json:"latest_one_out_inferer_forecaster_network_regrets,omitempty"`
	LatestOneOutForecasterInfererNetworkRegrets    []*TopicIdActorIdActorIdTimeStampedValue `protobuf:"bytes,51,rep,name=latest_one_out_forecaster_inferer_network_regrets,json=latestOneOutForecasterInfererNetworkRegrets,proto3" json:"latest_one_out_forecaster_inferer_network_regrets,omitempty"`
	LatestOneOutForecasterForecasterNetworkRegrets []*TopicIdActorIdActorIdTimeStampedValue `protobuf:"bytes,52,rep,name=latest_one_out_forecaster_forecaster_network_regrets,json=latestOneOutForecasterForecasterNetworkRegrets,proto3" json:"latest_one_out_forecaster_forecaster_network_regrets,omitempty"`
	/// RECORD COMMITS
	TopicLastWorkerCommit  []*TopicIdTimestampedActorNonce `protobuf:"bytes,53,rep,name=topic_last_worker_commit,json=topicLastWorkerCommit,proto3" json:"topic_last_worker_commit,omitempty"`
	TopicLastReputerCommit []*TopicIdTimestampedActorNonce `protobuf:"bytes,54,rep,name=topic_last_reputer_commit,json=topicLastReputerCommit,proto3" json:"topic_last_reputer_commit,omitempty"`
	/// WINDOW
	// map of open worker nonce windows for topics on particular block heights
	OpenWorkerWindows []*BlockHeightAndTopicIds `protobuf:"bytes,55,rep,name=open_worker_windows,json=openWorkerWindows,proto3" json:"open_worker_windows,omitempty"`
	/// DRIPS
	// map of (topic) -> last dripped block
	LastDripBlock []*TopicIdAndBlockHeight `protobuf:"bytes,56,rep,name=last_drip_block,json=lastDripBlock,proto3" json:"last_drip_block,omitempty"`
	// ACTIVE TOPIC
	TopicToNextPossibleChurningBlock []*TopicIdAndBlockHeight        `protobuf:"bytes,57,rep,name=topic_to_next_possible_churning_block,json=topicToNextPossibleChurningBlock,proto3" json:"topic_to_next_possible_churning_block,omitempty"`
	BlockToActiveTopics              []*BlockHeightTopicIds          `protobuf:"bytes,58,rep,name=block_to_active_topics,json=blockToActiveTopics,proto3" json:"block_to_active_topics,omitempty"`
	BlockToLowestActiveTopicWeight   []*BlockHeightTopicIdWeightPair `protobuf:"bytes,59,rep,name=block_to_lowest_active_topic_weight,json=blockToLowestActiveTopicWeight,proto3" json:"block_to_lowest_active_topic_weight,omitempty"`
	/// EMA SCORES
	// map of (topic, block_height, worker) -> score
	InfererScoreEmas []*TopicIdActorIdScore `protobuf:"bytes,60,rep,name=inferer_score_emas,json=infererScoreEmas,proto3" json:"inferer_score_emas,omitempty"`
	// map of (topic, block_height, worker) -> score
	ForecasterScoreEmas []*TopicIdActorIdScore `protobuf:"bytes,61,rep,name=forecaster_score_emas,json=forecasterScoreEmas,proto3" json:"forecaster_score_emas,omitempty"`
	// map of (topic, block_height, reputer) -> score
	ReputerScoreEmas []*TopicIdActorIdScore `protobuf:"bytes,62,rep,name=reputer_score_emas,json=reputerScoreEmas,proto3" json:"reputer_score_emas,omitempty"`
	// EMA
	PreviousTopicQuantileInfererScoreEma    []*TopicIdAndDec `protobuf:"bytes,63,rep,name=previous_topic_quantile_inferer_score_ema,json=previousTopicQuantileInfererScoreEma,proto3" json:"previous_topic_quantile_inferer_score_ema,omitempty"`
	PreviousTopicQuantileForecasterScoreEma []*TopicIdAndDec `protobuf:"bytes,64,rep,name=previous_topic_quantile_forecaster_score_ema,json=previousTopicQuantileForecasterScoreEma,proto3" json:"previous_topic_quantile_forecaster_score_ema,omitempty"`
	PreviousTopicQuantileReputerScoreEma    []*TopicIdAndDec `protobuf:"bytes,65,rep,name=previous_topic_quantile_reputer_score_ema,json=previousTopicQuantileReputerScoreEma,proto3" json:"previous_topic_quantile_reputer_score_ema,omitempty"`
	// INCLUSIONS
	CountInfererInclusionsInTopicActiveSet    []*TopicIdActorIdUint64 `protobuf:"bytes,66,rep,name=count_inferer_inclusions_in_topic_active_set,json=countInfererInclusionsInTopicActiveSet,proto3" json:"count_inferer_inclusions_in_topic_active_set,omitempty"`
	CountForecasterInclusionsInTopicActiveSet []*TopicIdActorIdUint64 `protobuf:"bytes,67,rep,name=count_forecaster_inclusions_in_topic_active_set,json=countForecasterInclusionsInTopicActiveSet,proto3" json:"count_forecaster_inclusions_in_topic_active_set,omitempty"`
	// active inferers for each topic
	ActiveInferers []*TopicAndActorId `protobuf:"bytes,68,rep,name=active_inferers,json=activeInferers,proto3" json:"active_inferers,omitempty"`
	// active forecasters for each topic
	ActiveForecasters []*TopicAndActorId `protobuf:"bytes,69,rep,name=active_forecasters,json=activeForecasters,proto3" json:"active_forecasters,omitempty"`
	// lowest inferer score EMA for each topic
	LowestInfererScoreEma []*TopicIdActorIdScore `protobuf:"bytes,70,rep,name=lowest_inferer_score_ema,json=lowestInfererScoreEma,proto3" json:"lowest_inferer_score_ema,omitempty"`
	// lowest forecaster score EMA for each topic
	LowestForecasterScoreEma []*TopicIdActorIdScore `protobuf:"bytes,71,rep,name=lowest_forecaster_score_ema,json=lowestForecasterScoreEma,proto3" json:"lowest_forecaster_score_ema,omitempty"`
	// active reputers for each topic
	ActiveReputers []*TopicAndActorId `protobuf:"bytes,72,rep,name=active_reputers,json=activeReputers,proto3" json:"active_reputers,omitempty"`
	// lowest reputer score EMA for each topic
	LowestReputerScoreEma []*TopicIdActorIdScore `protobuf:"bytes,73,rep,name=lowest_reputer_score_ema,json=lowestReputerScoreEma,proto3" json:"lowest_reputer_score_ema,omitempty"`
	// map of (topic, reputer) -> reputer loss
	LossBundles []*TopicIdReputerReputerValueBundle `protobuf:"bytes,74,rep,name=loss_bundles,json=lossBundles,proto3" json:"loss_bundles,omitempty"`
	// total sum of topic weights
	TotalSumPreviousTopicWeights github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,75,opt,name=total_sum_previous_topic_weights,json=totalSumPreviousTopicWeights,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"total_sum_previous_topic_weights"`
	// reward emission on current block
	RewardCurrentBlockEmission   cosmossdk_io_math.Int `protobuf:"bytes,76,opt,name=reward_current_block_emission,json=rewardCurrentBlockEmission,proto3,customtype=cosmossdk.io/math.Int" json:"reward_current_block_emission"`
	WhitelistAdmins              []string              `protobuf:"bytes,77,rep,name=whitelist_admins,json=whitelistAdmins,proto3" json:"whitelist_admins,omitempty"`
	GlobalWhitelist              []string              `protobuf:"bytes,78,rep,name=global_whitelist,json=globalWhitelist,proto3" json:"global_whitelist,omitempty"`
	TopicCreatorWhitelist        []string              `protobuf:"bytes,79,rep,name=topic_creator_whitelist,json=topicCreatorWhitelist,proto3" json:"topic_creator_whitelist,omitempty"`
	TopicWorkerWhitelist         []*TopicAndActorId    `protobuf:"bytes,80,rep,name=topic_worker_whitelist,json=topicWorkerWhitelist,proto3" json:"topic_worker_whitelist,omitempty"`
	TopicReputerWhitelist        []*TopicAndActorId    `protobuf:"bytes,81,rep,name=topic_reputer_whitelist,json=topicReputerWhitelist,proto3" json:"topic_reputer_whitelist,omitempty"`
	TopicWorkerWhitelistEnabled  []uint64              `protobuf:"varint,82,rep,packed,name=topic_worker_whitelist_enabled,json=topicWorkerWhitelistEnabled,proto3" json:"topic_worker_whitelist_enabled,omitempty"`
	TopicReputerWhitelistEnabled []uint64              `protobuf:"varint,83,rep,packed,name=topic_reputer_whitelist_enabled,json=topicReputerWhitelistEnabled,proto3" json:"topic_reputer_whitelist_enabled,omitempty"`
	LastMedianInferences         []*TopicIdAndDec      `protobuf:"bytes,84,rep,name=last_median_inferences,json=lastMedianInferences,proto3" json:"last_median_inferences,omitempty"`
	MadInferences                []*TopicIdAndDec      `protobuf:"bytes,85,rep,name=mad_inferences,json=madInferences,proto3" json:"mad_inferences,omitempty"`
	// current inferer ema scores to apply per topic
	// map of topic -> inferer ema score
	InitialInfererEmaScore []*TopicIdAndDec `protobuf:"bytes,86,rep,name=initial_inferer_ema_score,json=initialInfererEmaScore,proto3" json:"initial_inferer_ema_score,omitempty"`
	// current forecaster ema scores to apply per topic
	// map of topic -> forecaster ema score
	InitialForecasterEmaScore []*TopicIdAndDec `protobuf:"bytes,87,rep,name=initial_forecaster_ema_score,json=initialForecasterEmaScore,proto3" json:"initial_forecaster_ema_score,omitempty"`
	// current reputer ema scores to apply per topic
	// map of topic -> reputer ema score
	InitialReputerEmaScore []*TopicIdAndDec `protobuf:"bytes,88,rep,name=initial_reputer_ema_score,json=initialReputerEmaScore,proto3" json:"initial_reputer_ema_score,omitempty"`
	GlobalWorkerWhitelist  []string         `protobuf:"bytes,89,rep,name=global_worker_whitelist,json=globalWorkerWhitelist,proto3" json:"global_worker_whitelist,omitempty"`
	GlobalReputerWhitelist []string         `protobuf:"bytes,90,rep,name=global_reputer_whitelist,json=globalReputerWhitelist,proto3" json:"global_reputer_whitelist,omitempty"`
	GlobalAdminWhitelist   []string         `protobuf:"bytes,91,rep,name=global_admin_whitelist,json=globalAdminWhitelist,proto3" json:"global_admin_whitelist,omitempty"`
	// REGRET STDNORM
	LatestRegretStdNorm []*TopicIdAndDec `protobuf:"bytes,92,rep,name=latest_regret_std_norm,json=latestRegretStdNorm,proto3" json:"latest_regret_std_norm,omitempty"`
	// WEIGHTS
	LatestInfererWeights    []*TopicIdActorIdDec `protobuf:"bytes,93,rep,name=latest_inferer_weights,json=latestInfererWeights,proto3" json:"latest_inferer_weights,omitempty"`
	LatestForecasterWeights []*TopicIdActorIdDec `protobuf:"bytes,94,rep,name=latest_forecaster_weights,json=latestForecasterWeights,proto3" json:"latest_forecaster_weights,omitempty"`
	// NETWORK INFERENCES
	NetworkInferences                 []*TopicIdBlockHeightValueBundles `protobuf:"bytes,95,rep,name=network_inferences,json=networkInferences,proto3" json:"network_inferences,omitempty"`
	OutlierResistantNetworkInferences []*TopicIdBlockHeightValueBundles `protobuf:"bytes,96,rep,name=outlier_resistant_network_inferences,json=outlierResistantNetworkInferences,proto3" json:"outlier_resistant_network_inferences,omitempty"`
	// MONTHLY REWARDS
	MonthlyReputerRewards cosmossdk_io_math.Int `protobuf:"bytes,97,opt,name=monthly_reputer_rewards,json=monthlyReputerRewards,proto3,customtype=cosmossdk.io/math.Int" json:"monthly_reputer_rewards"`
	MonthlyTopicRewards   cosmossdk_io_math.Int `protobuf:"bytes,98,opt,name=monthly_topic_rewards,json=monthlyTopicRewards,proto3,customtype=cosmossdk.io/math.Int" json:"monthly_topic_rewards"`
}

func (m *GenesisState) Reset()         { *m = GenesisState{} }
func (m *GenesisState) String() string { return proto.CompactTextString(m) }
func (*GenesisState) ProtoMessage()    {}
func (*GenesisState) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{0}
}
func (m *GenesisState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GenesisState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GenesisState.Merge(m, src)
}
func (m *GenesisState) XXX_Size() int {
	return m.Size()
}
func (m *GenesisState) XXX_DiscardUnknown() {
	xxx_messageInfo_GenesisState.DiscardUnknown(m)
}

var xxx_messageInfo_GenesisState proto.InternalMessageInfo

func (m *GenesisState) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

func (m *GenesisState) GetCoreTeamAddresses() []string {
	if m != nil {
		return m.CoreTeamAddresses
	}
	return nil
}

func (m *GenesisState) GetNextTopicId() uint64 {
	if m != nil {
		return m.NextTopicId
	}
	return 0
}

func (m *GenesisState) GetTopics() []*TopicIdAndTopic {
	if m != nil {
		return m.Topics
	}
	return nil
}

func (m *GenesisState) GetActiveTopics() []uint64 {
	if m != nil {
		return m.ActiveTopics
	}
	return nil
}

func (m *GenesisState) GetRewardableTopics() []uint64 {
	if m != nil {
		return m.RewardableTopics
	}
	return nil
}

func (m *GenesisState) GetTopicWorkers() []*TopicAndActorId {
	if m != nil {
		return m.TopicWorkers
	}
	return nil
}

func (m *GenesisState) GetTopicReputers() []*TopicAndActorId {
	if m != nil {
		return m.TopicReputers
	}
	return nil
}

func (m *GenesisState) GetTopicRewardNonce() []*TopicIdAndBlockHeight {
	if m != nil {
		return m.TopicRewardNonce
	}
	return nil
}

func (m *GenesisState) GetInfererScoresByBlock() []*TopicIdBlockHeightScores {
	if m != nil {
		return m.InfererScoresByBlock
	}
	return nil
}

func (m *GenesisState) GetForecasterScoresByBlock() []*TopicIdBlockHeightScores {
	if m != nil {
		return m.ForecasterScoresByBlock
	}
	return nil
}

func (m *GenesisState) GetReputerScoresByBlock() []*TopicIdBlockHeightScores {
	if m != nil {
		return m.ReputerScoresByBlock
	}
	return nil
}

func (m *GenesisState) GetReputerListeningCoefficient() []*TopicIdActorIdListeningCoefficient {
	if m != nil {
		return m.ReputerListeningCoefficient
	}
	return nil
}

func (m *GenesisState) GetPreviousReputerRewardFraction() []*TopicIdActorIdDec {
	if m != nil {
		return m.PreviousReputerRewardFraction
	}
	return nil
}

func (m *GenesisState) GetPreviousInferenceRewardFraction() []*TopicIdActorIdDec {
	if m != nil {
		return m.PreviousInferenceRewardFraction
	}
	return nil
}

func (m *GenesisState) GetPreviousForecastRewardFraction() []*TopicIdActorIdDec {
	if m != nil {
		return m.PreviousForecastRewardFraction
	}
	return nil
}

func (m *GenesisState) GetPreviousForecasterScoreRatio() []*TopicIdAndDec {
	if m != nil {
		return m.PreviousForecasterScoreRatio
	}
	return nil
}

func (m *GenesisState) GetTopicStake() []*TopicIdAndInt {
	if m != nil {
		return m.TopicStake
	}
	return nil
}

func (m *GenesisState) GetStakeReputerAuthority() []*TopicIdActorIdInt {
	if m != nil {
		return m.StakeReputerAuthority
	}
	return nil
}

func (m *GenesisState) GetStakeSumFromDelegator() []*TopicIdActorIdInt {
	if m != nil {
		return m.StakeSumFromDelegator
	}
	return nil
}

func (m *GenesisState) GetDelegatedStakes() []*TopicIdDelegatorReputerDelegatorInfo {
	if m != nil {
		return m.DelegatedStakes
	}
	return nil
}

func (m *GenesisState) GetStakeFromDelegatorsUponReputer() []*TopicIdActorIdInt {
	if m != nil {
		return m.StakeFromDelegatorsUponReputer
	}
	return nil
}

func (m *GenesisState) GetDelegateRewardPerShare() []*TopicIdActorIdDec {
	if m != nil {
		return m.DelegateRewardPerShare
	}
	return nil
}

func (m *GenesisState) GetStakeRemovalsByBlock() []*BlockHeightTopicIdReputerStakeRemovalInfo {
	if m != nil {
		return m.StakeRemovalsByBlock
	}
	return nil
}

func (m *GenesisState) GetStakeRemovalsByActor() []*ActorIdTopicIdBlockHeight {
	if m != nil {
		return m.StakeRemovalsByActor
	}
	return nil
}

func (m *GenesisState) GetDelegateStakeRemovalsByBlock() []*BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo {
	if m != nil {
		return m.DelegateStakeRemovalsByBlock
	}
	return nil
}

func (m *GenesisState) GetDelegateStakeRemovalsByActor() []*DelegatorReputerTopicIdBlockHeight {
	if m != nil {
		return m.DelegateStakeRemovalsByActor
	}
	return nil
}

func (m *GenesisState) GetInferences() []*TopicIdActorIdInference {
	if m != nil {
		return m.Inferences
	}
	return nil
}

func (m *GenesisState) GetForecasts() []*TopicIdActorIdForecast {
	if m != nil {
		return m.Forecasts
	}
	return nil
}

func (m *GenesisState) GetWorkers() []*LibP2PKeyAndOffchainNode {
	if m != nil {
		return m.Workers
	}
	return nil
}

func (m *GenesisState) GetReputers() []*LibP2PKeyAndOffchainNode {
	if m != nil {
		return m.Reputers
	}
	return nil
}

func (m *GenesisState) GetTopicFeeRevenue() []*TopicIdAndInt {
	if m != nil {
		return m.TopicFeeRevenue
	}
	return nil
}

func (m *GenesisState) GetPreviousTopicWeight() []*TopicIdAndDec {
	if m != nil {
		return m.PreviousTopicWeight
	}
	return nil
}

func (m *GenesisState) GetAllInferences() []*TopicIdBlockHeightInferences {
	if m != nil {
		return m.AllInferences
	}
	return nil
}

func (m *GenesisState) GetAllForecasts() []*TopicIdBlockHeightForecasts {
	if m != nil {
		return m.AllForecasts
	}
	return nil
}

func (m *GenesisState) GetAllLossBundles() []*TopicIdBlockHeightReputerValueBundles {
	if m != nil {
		return m.AllLossBundles
	}
	return nil
}

func (m *GenesisState) GetNetworkLossBundles() []*TopicIdBlockHeightValueBundles {
	if m != nil {
		return m.NetworkLossBundles
	}
	return nil
}

func (m *GenesisState) GetUnfulfilledWorkerNonces() []*TopicIdAndNonces {
	if m != nil {
		return m.UnfulfilledWorkerNonces
	}
	return nil
}

func (m *GenesisState) GetUnfulfilledReputerNonces() []*TopicIdAndReputerRequestNonces {
	if m != nil {
		return m.UnfulfilledReputerNonces
	}
	return nil
}

func (m *GenesisState) GetLatestInfererNetworkRegrets() []*TopicIdActorIdTimeStampedValue {
	if m != nil {
		return m.LatestInfererNetworkRegrets
	}
	return nil
}

func (m *GenesisState) GetLatestForecasterNetworkRegrets() []*TopicIdActorIdTimeStampedValue {
	if m != nil {
		return m.LatestForecasterNetworkRegrets
	}
	return nil
}

func (m *GenesisState) GetLatestOneInForecasterNetworkRegrets() []*TopicIdActorIdActorIdTimeStampedValue {
	if m != nil {
		return m.LatestOneInForecasterNetworkRegrets
	}
	return nil
}

func (m *GenesisState) GetLatestNaiveInfererNetworkRegrets() []*TopicIdActorIdTimeStampedValue {
	if m != nil {
		return m.LatestNaiveInfererNetworkRegrets
	}
	return nil
}

func (m *GenesisState) GetLatestOneOutInfererInfererNetworkRegrets() []*TopicIdActorIdActorIdTimeStampedValue {
	if m != nil {
		return m.LatestOneOutInfererInfererNetworkRegrets
	}
	return nil
}

func (m *GenesisState) GetLatestOneOutInfererForecasterNetworkRegrets() []*TopicIdActorIdActorIdTimeStampedValue {
	if m != nil {
		return m.LatestOneOutInfererForecasterNetworkRegrets
	}
	return nil
}

func (m *GenesisState) GetLatestOneOutForecasterInfererNetworkRegrets() []*TopicIdActorIdActorIdTimeStampedValue {
	if m != nil {
		return m.LatestOneOutForecasterInfererNetworkRegrets
	}
	return nil
}

func (m *GenesisState) GetLatestOneOutForecasterForecasterNetworkRegrets() []*TopicIdActorIdActorIdTimeStampedValue {
	if m != nil {
		return m.LatestOneOutForecasterForecasterNetworkRegrets
	}
	return nil
}

func (m *GenesisState) GetTopicLastWorkerCommit() []*TopicIdTimestampedActorNonce {
	if m != nil {
		return m.TopicLastWorkerCommit
	}
	return nil
}

func (m *GenesisState) GetTopicLastReputerCommit() []*TopicIdTimestampedActorNonce {
	if m != nil {
		return m.TopicLastReputerCommit
	}
	return nil
}

func (m *GenesisState) GetOpenWorkerWindows() []*BlockHeightAndTopicIds {
	if m != nil {
		return m.OpenWorkerWindows
	}
	return nil
}

func (m *GenesisState) GetLastDripBlock() []*TopicIdAndBlockHeight {
	if m != nil {
		return m.LastDripBlock
	}
	return nil
}

func (m *GenesisState) GetTopicToNextPossibleChurningBlock() []*TopicIdAndBlockHeight {
	if m != nil {
		return m.TopicToNextPossibleChurningBlock
	}
	return nil
}

func (m *GenesisState) GetBlockToActiveTopics() []*BlockHeightTopicIds {
	if m != nil {
		return m.BlockToActiveTopics
	}
	return nil
}

func (m *GenesisState) GetBlockToLowestActiveTopicWeight() []*BlockHeightTopicIdWeightPair {
	if m != nil {
		return m.BlockToLowestActiveTopicWeight
	}
	return nil
}

func (m *GenesisState) GetInfererScoreEmas() []*TopicIdActorIdScore {
	if m != nil {
		return m.InfererScoreEmas
	}
	return nil
}

func (m *GenesisState) GetForecasterScoreEmas() []*TopicIdActorIdScore {
	if m != nil {
		return m.ForecasterScoreEmas
	}
	return nil
}

func (m *GenesisState) GetReputerScoreEmas() []*TopicIdActorIdScore {
	if m != nil {
		return m.ReputerScoreEmas
	}
	return nil
}

func (m *GenesisState) GetPreviousTopicQuantileInfererScoreEma() []*TopicIdAndDec {
	if m != nil {
		return m.PreviousTopicQuantileInfererScoreEma
	}
	return nil
}

func (m *GenesisState) GetPreviousTopicQuantileForecasterScoreEma() []*TopicIdAndDec {
	if m != nil {
		return m.PreviousTopicQuantileForecasterScoreEma
	}
	return nil
}

func (m *GenesisState) GetPreviousTopicQuantileReputerScoreEma() []*TopicIdAndDec {
	if m != nil {
		return m.PreviousTopicQuantileReputerScoreEma
	}
	return nil
}

func (m *GenesisState) GetCountInfererInclusionsInTopicActiveSet() []*TopicIdActorIdUint64 {
	if m != nil {
		return m.CountInfererInclusionsInTopicActiveSet
	}
	return nil
}

func (m *GenesisState) GetCountForecasterInclusionsInTopicActiveSet() []*TopicIdActorIdUint64 {
	if m != nil {
		return m.CountForecasterInclusionsInTopicActiveSet
	}
	return nil
}

func (m *GenesisState) GetActiveInferers() []*TopicAndActorId {
	if m != nil {
		return m.ActiveInferers
	}
	return nil
}

func (m *GenesisState) GetActiveForecasters() []*TopicAndActorId {
	if m != nil {
		return m.ActiveForecasters
	}
	return nil
}

func (m *GenesisState) GetLowestInfererScoreEma() []*TopicIdActorIdScore {
	if m != nil {
		return m.LowestInfererScoreEma
	}
	return nil
}

func (m *GenesisState) GetLowestForecasterScoreEma() []*TopicIdActorIdScore {
	if m != nil {
		return m.LowestForecasterScoreEma
	}
	return nil
}

func (m *GenesisState) GetActiveReputers() []*TopicAndActorId {
	if m != nil {
		return m.ActiveReputers
	}
	return nil
}

func (m *GenesisState) GetLowestReputerScoreEma() []*TopicIdActorIdScore {
	if m != nil {
		return m.LowestReputerScoreEma
	}
	return nil
}

func (m *GenesisState) GetLossBundles() []*TopicIdReputerReputerValueBundle {
	if m != nil {
		return m.LossBundles
	}
	return nil
}

func (m *GenesisState) GetWhitelistAdmins() []string {
	if m != nil {
		return m.WhitelistAdmins
	}
	return nil
}

func (m *GenesisState) GetGlobalWhitelist() []string {
	if m != nil {
		return m.GlobalWhitelist
	}
	return nil
}

func (m *GenesisState) GetTopicCreatorWhitelist() []string {
	if m != nil {
		return m.TopicCreatorWhitelist
	}
	return nil
}

func (m *GenesisState) GetTopicWorkerWhitelist() []*TopicAndActorId {
	if m != nil {
		return m.TopicWorkerWhitelist
	}
	return nil
}

func (m *GenesisState) GetTopicReputerWhitelist() []*TopicAndActorId {
	if m != nil {
		return m.TopicReputerWhitelist
	}
	return nil
}

func (m *GenesisState) GetTopicWorkerWhitelistEnabled() []uint64 {
	if m != nil {
		return m.TopicWorkerWhitelistEnabled
	}
	return nil
}

func (m *GenesisState) GetTopicReputerWhitelistEnabled() []uint64 {
	if m != nil {
		return m.TopicReputerWhitelistEnabled
	}
	return nil
}

func (m *GenesisState) GetLastMedianInferences() []*TopicIdAndDec {
	if m != nil {
		return m.LastMedianInferences
	}
	return nil
}

func (m *GenesisState) GetMadInferences() []*TopicIdAndDec {
	if m != nil {
		return m.MadInferences
	}
	return nil
}

func (m *GenesisState) GetInitialInfererEmaScore() []*TopicIdAndDec {
	if m != nil {
		return m.InitialInfererEmaScore
	}
	return nil
}

func (m *GenesisState) GetInitialForecasterEmaScore() []*TopicIdAndDec {
	if m != nil {
		return m.InitialForecasterEmaScore
	}
	return nil
}

func (m *GenesisState) GetInitialReputerEmaScore() []*TopicIdAndDec {
	if m != nil {
		return m.InitialReputerEmaScore
	}
	return nil
}

func (m *GenesisState) GetGlobalWorkerWhitelist() []string {
	if m != nil {
		return m.GlobalWorkerWhitelist
	}
	return nil
}

func (m *GenesisState) GetGlobalReputerWhitelist() []string {
	if m != nil {
		return m.GlobalReputerWhitelist
	}
	return nil
}

func (m *GenesisState) GetGlobalAdminWhitelist() []string {
	if m != nil {
		return m.GlobalAdminWhitelist
	}
	return nil
}

func (m *GenesisState) GetLatestRegretStdNorm() []*TopicIdAndDec {
	if m != nil {
		return m.LatestRegretStdNorm
	}
	return nil
}

func (m *GenesisState) GetLatestInfererWeights() []*TopicIdActorIdDec {
	if m != nil {
		return m.LatestInfererWeights
	}
	return nil
}

func (m *GenesisState) GetLatestForecasterWeights() []*TopicIdActorIdDec {
	if m != nil {
		return m.LatestForecasterWeights
	}
	return nil
}

func (m *GenesisState) GetNetworkInferences() []*TopicIdBlockHeightValueBundles {
	if m != nil {
		return m.NetworkInferences
	}
	return nil
}

func (m *GenesisState) GetOutlierResistantNetworkInferences() []*TopicIdBlockHeightValueBundles {
	if m != nil {
		return m.OutlierResistantNetworkInferences
	}
	return nil
}

type TopicIdAndTopic struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Topic   *Topic `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
}

func (m *TopicIdAndTopic) Reset()         { *m = TopicIdAndTopic{} }
func (m *TopicIdAndTopic) String() string { return proto.CompactTextString(m) }
func (*TopicIdAndTopic) ProtoMessage()    {}
func (*TopicIdAndTopic) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{1}
}
func (m *TopicIdAndTopic) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdAndTopic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdAndTopic.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdAndTopic) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdAndTopic.Merge(m, src)
}
func (m *TopicIdAndTopic) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdAndTopic) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdAndTopic.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdAndTopic proto.InternalMessageInfo

func (m *TopicIdAndTopic) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdAndTopic) GetTopic() *Topic {
	if m != nil {
		return m.Topic
	}
	return nil
}

type TopicAndActorId struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
}

func (m *TopicAndActorId) Reset()         { *m = TopicAndActorId{} }
func (m *TopicAndActorId) String() string { return proto.CompactTextString(m) }
func (*TopicAndActorId) ProtoMessage()    {}
func (*TopicAndActorId) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{2}
}
func (m *TopicAndActorId) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicAndActorId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicAndActorId.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicAndActorId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicAndActorId.Merge(m, src)
}
func (m *TopicAndActorId) XXX_Size() int {
	return m.Size()
}
func (m *TopicAndActorId) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicAndActorId.DiscardUnknown(m)
}

var xxx_messageInfo_TopicAndActorId proto.InternalMessageInfo

func (m *TopicAndActorId) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicAndActorId) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

type TopicIdAndBlockHeight struct {
	TopicId     uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64  `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
}

func (m *TopicIdAndBlockHeight) Reset()         { *m = TopicIdAndBlockHeight{} }
func (m *TopicIdAndBlockHeight) String() string { return proto.CompactTextString(m) }
func (*TopicIdAndBlockHeight) ProtoMessage()    {}
func (*TopicIdAndBlockHeight) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{3}
}
func (m *TopicIdAndBlockHeight) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdAndBlockHeight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdAndBlockHeight.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdAndBlockHeight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdAndBlockHeight.Merge(m, src)
}
func (m *TopicIdAndBlockHeight) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdAndBlockHeight) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdAndBlockHeight.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdAndBlockHeight proto.InternalMessageInfo

func (m *TopicIdAndBlockHeight) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdAndBlockHeight) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

type BlockHeightAndTopicIds struct {
	BlockHeight int64    `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	TopicIds    []uint64 `protobuf:"varint,2,rep,packed,name=topic_ids,json=topicIds,proto3" json:"topic_ids,omitempty"`
}

func (m *BlockHeightAndTopicIds) Reset()         { *m = BlockHeightAndTopicIds{} }
func (m *BlockHeightAndTopicIds) String() string { return proto.CompactTextString(m) }
func (*BlockHeightAndTopicIds) ProtoMessage()    {}
func (*BlockHeightAndTopicIds) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{4}
}
func (m *BlockHeightAndTopicIds) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockHeightAndTopicIds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockHeightAndTopicIds.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockHeightAndTopicIds) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockHeightAndTopicIds.Merge(m, src)
}
func (m *BlockHeightAndTopicIds) XXX_Size() int {
	return m.Size()
}
func (m *BlockHeightAndTopicIds) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockHeightAndTopicIds.DiscardUnknown(m)
}

var xxx_messageInfo_BlockHeightAndTopicIds proto.InternalMessageInfo

func (m *BlockHeightAndTopicIds) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *BlockHeightAndTopicIds) GetTopicIds() []uint64 {
	if m != nil {
		return m.TopicIds
	}
	return nil
}

type TopicIdBlockHeightScores struct {
	TopicId     uint64  `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64   `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Scores      *Scores `protobuf:"bytes,3,opt,name=scores,proto3" json:"scores,omitempty"`
}

func (m *TopicIdBlockHeightScores) Reset()         { *m = TopicIdBlockHeightScores{} }
func (m *TopicIdBlockHeightScores) String() string { return proto.CompactTextString(m) }
func (*TopicIdBlockHeightScores) ProtoMessage()    {}
func (*TopicIdBlockHeightScores) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{5}
}
func (m *TopicIdBlockHeightScores) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdBlockHeightScores) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdBlockHeightScores.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdBlockHeightScores) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdBlockHeightScores.Merge(m, src)
}
func (m *TopicIdBlockHeightScores) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdBlockHeightScores) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdBlockHeightScores.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdBlockHeightScores proto.InternalMessageInfo

func (m *TopicIdBlockHeightScores) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdBlockHeightScores) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *TopicIdBlockHeightScores) GetScores() *Scores {
	if m != nil {
		return m.Scores
	}
	return nil
}

type TopicIdActorIdScore struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
	Score   *Score `protobuf:"bytes,3,opt,name=score,proto3" json:"score,omitempty"`
}

func (m *TopicIdActorIdScore) Reset()         { *m = TopicIdActorIdScore{} }
func (m *TopicIdActorIdScore) String() string { return proto.CompactTextString(m) }
func (*TopicIdActorIdScore) ProtoMessage()    {}
func (*TopicIdActorIdScore) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{6}
}
func (m *TopicIdActorIdScore) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdActorIdScore) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdActorIdScore.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdActorIdScore) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdActorIdScore.Merge(m, src)
}
func (m *TopicIdActorIdScore) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdActorIdScore) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdActorIdScore.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdActorIdScore proto.InternalMessageInfo

func (m *TopicIdActorIdScore) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdActorIdScore) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

func (m *TopicIdActorIdScore) GetScore() *Score {
	if m != nil {
		return m.Score
	}
	return nil
}

type TopicIdActorIdUint64 struct {
	TopicId uint64 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
	Uint64  uint64 `protobuf:"varint,3,opt,name=uint64,proto3" json:"uint64,omitempty"`
}

func (m *TopicIdActorIdUint64) Reset()         { *m = TopicIdActorIdUint64{} }
func (m *TopicIdActorIdUint64) String() string { return proto.CompactTextString(m) }
func (*TopicIdActorIdUint64) ProtoMessage()    {}
func (*TopicIdActorIdUint64) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{7}
}
func (m *TopicIdActorIdUint64) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdActorIdUint64) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdActorIdUint64.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdActorIdUint64) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdActorIdUint64.Merge(m, src)
}
func (m *TopicIdActorIdUint64) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdActorIdUint64) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdActorIdUint64.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdActorIdUint64 proto.InternalMessageInfo

func (m *TopicIdActorIdUint64) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdActorIdUint64) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

func (m *TopicIdActorIdUint64) GetUint64() uint64 {
	if m != nil {
		return m.Uint64
	}
	return 0
}

type TopicIdActorIdListeningCoefficient struct {
	TopicId              uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId              string                `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
	ListeningCoefficient *ListeningCoefficient `protobuf:"bytes,3,opt,name=listening_coefficient,json=listeningCoefficient,proto3" json:"listening_coefficient,omitempty"`
}

func (m *TopicIdActorIdListeningCoefficient) Reset()         { *m = TopicIdActorIdListeningCoefficient{} }
func (m *TopicIdActorIdListeningCoefficient) String() string { return proto.CompactTextString(m) }
func (*TopicIdActorIdListeningCoefficient) ProtoMessage()    {}
func (*TopicIdActorIdListeningCoefficient) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{8}
}
func (m *TopicIdActorIdListeningCoefficient) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdActorIdListeningCoefficient) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdActorIdListeningCoefficient.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdActorIdListeningCoefficient) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdActorIdListeningCoefficient.Merge(m, src)
}
func (m *TopicIdActorIdListeningCoefficient) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdActorIdListeningCoefficient) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdActorIdListeningCoefficient.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdActorIdListeningCoefficient proto.InternalMessageInfo

func (m *TopicIdActorIdListeningCoefficient) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdActorIdListeningCoefficient) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

func (m *TopicIdActorIdListeningCoefficient) GetListeningCoefficient() *ListeningCoefficient {
	if m != nil {
		return m.ListeningCoefficient
	}
	return nil
}

type TopicIdActorIdDec struct {
	TopicId uint64                                          `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId string                                          `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
	Dec     github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,3,opt,name=dec,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"dec"`
}

func (m *TopicIdActorIdDec) Reset()         { *m = TopicIdActorIdDec{} }
func (m *TopicIdActorIdDec) String() string { return proto.CompactTextString(m) }
func (*TopicIdActorIdDec) ProtoMessage()    {}
func (*TopicIdActorIdDec) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{9}
}
func (m *TopicIdActorIdDec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdActorIdDec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdActorIdDec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdActorIdDec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdActorIdDec.Merge(m, src)
}
func (m *TopicIdActorIdDec) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdActorIdDec) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdActorIdDec.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdActorIdDec proto.InternalMessageInfo

func (m *TopicIdActorIdDec) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdActorIdDec) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

type TopicIdAndInt struct {
	TopicId uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Int     cosmossdk_io_math.Int `protobuf:"bytes,2,opt,name=int,proto3,customtype=cosmossdk.io/math.Int" json:"int"`
}

func (m *TopicIdAndInt) Reset()         { *m = TopicIdAndInt{} }
func (m *TopicIdAndInt) String() string { return proto.CompactTextString(m) }
func (*TopicIdAndInt) ProtoMessage()    {}
func (*TopicIdAndInt) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{10}
}
func (m *TopicIdAndInt) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdAndInt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdAndInt.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdAndInt) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdAndInt.Merge(m, src)
}
func (m *TopicIdAndInt) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdAndInt) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdAndInt.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdAndInt proto.InternalMessageInfo

func (m *TopicIdAndInt) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type TopicIdActorIdInt struct {
	TopicId uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId string                `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
	Int     cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=int,proto3,customtype=cosmossdk.io/math.Int" json:"int"`
}

func (m *TopicIdActorIdInt) Reset()         { *m = TopicIdActorIdInt{} }
func (m *TopicIdActorIdInt) String() string { return proto.CompactTextString(m) }
func (*TopicIdActorIdInt) ProtoMessage()    {}
func (*TopicIdActorIdInt) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{11}
}
func (m *TopicIdActorIdInt) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdActorIdInt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdActorIdInt.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdActorIdInt) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdActorIdInt.Merge(m, src)
}
func (m *TopicIdActorIdInt) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdActorIdInt) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdActorIdInt.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdActorIdInt proto.InternalMessageInfo

func (m *TopicIdActorIdInt) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdActorIdInt) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

type TopicIdDelegatorReputerDelegatorInfo struct {
	TopicId       uint64         `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Delegator     string         `protobuf:"bytes,2,opt,name=delegator,proto3" json:"delegator,omitempty"`
	Reputer       string         `protobuf:"bytes,3,opt,name=reputer,proto3" json:"reputer,omitempty"`
	DelegatorInfo *DelegatorInfo `protobuf:"bytes,4,opt,name=delegator_info,json=delegatorInfo,proto3" json:"delegator_info,omitempty"`
}

func (m *TopicIdDelegatorReputerDelegatorInfo) Reset()         { *m = TopicIdDelegatorReputerDelegatorInfo{} }
func (m *TopicIdDelegatorReputerDelegatorInfo) String() string { return proto.CompactTextString(m) }
func (*TopicIdDelegatorReputerDelegatorInfo) ProtoMessage()    {}
func (*TopicIdDelegatorReputerDelegatorInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{12}
}
func (m *TopicIdDelegatorReputerDelegatorInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdDelegatorReputerDelegatorInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdDelegatorReputerDelegatorInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdDelegatorReputerDelegatorInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdDelegatorReputerDelegatorInfo.Merge(m, src)
}
func (m *TopicIdDelegatorReputerDelegatorInfo) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdDelegatorReputerDelegatorInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdDelegatorReputerDelegatorInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdDelegatorReputerDelegatorInfo proto.InternalMessageInfo

func (m *TopicIdDelegatorReputerDelegatorInfo) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdDelegatorReputerDelegatorInfo) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *TopicIdDelegatorReputerDelegatorInfo) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *TopicIdDelegatorReputerDelegatorInfo) GetDelegatorInfo() *DelegatorInfo {
	if m != nil {
		return m.DelegatorInfo
	}
	return nil
}

type BlockHeightTopicIdReputerStakeRemovalInfo struct {
	BlockHeight      int64             `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	TopicId          uint64            `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer          string            `protobuf:"bytes,3,opt,name=reputer,proto3" json:"reputer,omitempty"`
	StakeRemovalInfo *StakeRemovalInfo `protobuf:"bytes,4,opt,name=stake_removal_info,json=stakeRemovalInfo,proto3" json:"stake_removal_info,omitempty"`
}

func (m *BlockHeightTopicIdReputerStakeRemovalInfo) Reset() {
	*m = BlockHeightTopicIdReputerStakeRemovalInfo{}
}
func (m *BlockHeightTopicIdReputerStakeRemovalInfo) String() string {
	return proto.CompactTextString(m)
}
func (*BlockHeightTopicIdReputerStakeRemovalInfo) ProtoMessage() {}
func (*BlockHeightTopicIdReputerStakeRemovalInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{13}
}
func (m *BlockHeightTopicIdReputerStakeRemovalInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockHeightTopicIdReputerStakeRemovalInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockHeightTopicIdReputerStakeRemovalInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockHeightTopicIdReputerStakeRemovalInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockHeightTopicIdReputerStakeRemovalInfo.Merge(m, src)
}
func (m *BlockHeightTopicIdReputerStakeRemovalInfo) XXX_Size() int {
	return m.Size()
}
func (m *BlockHeightTopicIdReputerStakeRemovalInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockHeightTopicIdReputerStakeRemovalInfo.DiscardUnknown(m)
}

var xxx_messageInfo_BlockHeightTopicIdReputerStakeRemovalInfo proto.InternalMessageInfo

func (m *BlockHeightTopicIdReputerStakeRemovalInfo) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *BlockHeightTopicIdReputerStakeRemovalInfo) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *BlockHeightTopicIdReputerStakeRemovalInfo) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *BlockHeightTopicIdReputerStakeRemovalInfo) GetStakeRemovalInfo() *StakeRemovalInfo {
	if m != nil {
		return m.StakeRemovalInfo
	}
	return nil
}

type ActorIdTopicIdBlockHeight struct {
	ActorId     string `protobuf:"bytes,1,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
	TopicId     uint64 `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64  `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
}

func (m *ActorIdTopicIdBlockHeight) Reset()         { *m = ActorIdTopicIdBlockHeight{} }
func (m *ActorIdTopicIdBlockHeight) String() string { return proto.CompactTextString(m) }
func (*ActorIdTopicIdBlockHeight) ProtoMessage()    {}
func (*ActorIdTopicIdBlockHeight) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{14}
}
func (m *ActorIdTopicIdBlockHeight) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ActorIdTopicIdBlockHeight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ActorIdTopicIdBlockHeight.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ActorIdTopicIdBlockHeight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ActorIdTopicIdBlockHeight.Merge(m, src)
}
func (m *ActorIdTopicIdBlockHeight) XXX_Size() int {
	return m.Size()
}
func (m *ActorIdTopicIdBlockHeight) XXX_DiscardUnknown() {
	xxx_messageInfo_ActorIdTopicIdBlockHeight.DiscardUnknown(m)
}

var xxx_messageInfo_ActorIdTopicIdBlockHeight proto.InternalMessageInfo

func (m *ActorIdTopicIdBlockHeight) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

func (m *ActorIdTopicIdBlockHeight) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *ActorIdTopicIdBlockHeight) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

type BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo struct {
	BlockHeight              int64                     `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	TopicId                  uint64                    `protobuf:"varint,2,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Delegator                string                    `protobuf:"bytes,3,opt,name=delegator,proto3" json:"delegator,omitempty"`
	Reputer                  string                    `protobuf:"bytes,4,opt,name=reputer,proto3" json:"reputer,omitempty"`
	DelegateStakeRemovalInfo *DelegateStakeRemovalInfo `protobuf:"bytes,5,opt,name=delegate_stake_removal_info,json=delegateStakeRemovalInfo,proto3" json:"delegate_stake_removal_info,omitempty"`
}

func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) Reset() {
	*m = BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo{}
}
func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) String() string {
	return proto.CompactTextString(m)
}
func (*BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) ProtoMessage() {}
func (*BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{15}
}
func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo.Merge(m, src)
}
func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) XXX_Size() int {
	return m.Size()
}
func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo.DiscardUnknown(m)
}

var xxx_messageInfo_BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo proto.InternalMessageInfo

func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) GetDelegateStakeRemovalInfo() *DelegateStakeRemovalInfo {
	if m != nil {
		return m.DelegateStakeRemovalInfo
	}
	return nil
}

type DelegatorReputerTopicIdBlockHeight struct {
	Delegator   string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty"`
	Reputer     string `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	TopicId     uint64 `protobuf:"varint,3,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64  `protobuf:"varint,4,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
}

func (m *DelegatorReputerTopicIdBlockHeight) Reset()         { *m = DelegatorReputerTopicIdBlockHeight{} }
func (m *DelegatorReputerTopicIdBlockHeight) String() string { return proto.CompactTextString(m) }
func (*DelegatorReputerTopicIdBlockHeight) ProtoMessage()    {}
func (*DelegatorReputerTopicIdBlockHeight) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{16}
}
func (m *DelegatorReputerTopicIdBlockHeight) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DelegatorReputerTopicIdBlockHeight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DelegatorReputerTopicIdBlockHeight.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DelegatorReputerTopicIdBlockHeight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DelegatorReputerTopicIdBlockHeight.Merge(m, src)
}
func (m *DelegatorReputerTopicIdBlockHeight) XXX_Size() int {
	return m.Size()
}
func (m *DelegatorReputerTopicIdBlockHeight) XXX_DiscardUnknown() {
	xxx_messageInfo_DelegatorReputerTopicIdBlockHeight.DiscardUnknown(m)
}

var xxx_messageInfo_DelegatorReputerTopicIdBlockHeight proto.InternalMessageInfo

func (m *DelegatorReputerTopicIdBlockHeight) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *DelegatorReputerTopicIdBlockHeight) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *DelegatorReputerTopicIdBlockHeight) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *DelegatorReputerTopicIdBlockHeight) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

type TopicIdActorIdInference struct {
	TopicId   uint64     `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId   string     `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
	Inference *Inference `protobuf:"bytes,3,opt,name=inference,proto3" json:"inference,omitempty"`
}

func (m *TopicIdActorIdInference) Reset()         { *m = TopicIdActorIdInference{} }
func (m *TopicIdActorIdInference) String() string { return proto.CompactTextString(m) }
func (*TopicIdActorIdInference) ProtoMessage()    {}
func (*TopicIdActorIdInference) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{17}
}
func (m *TopicIdActorIdInference) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdActorIdInference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdActorIdInference.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdActorIdInference) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdActorIdInference.Merge(m, src)
}
func (m *TopicIdActorIdInference) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdActorIdInference) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdActorIdInference.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdActorIdInference proto.InternalMessageInfo

func (m *TopicIdActorIdInference) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdActorIdInference) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

func (m *TopicIdActorIdInference) GetInference() *Inference {
	if m != nil {
		return m.Inference
	}
	return nil
}

type TopicIdActorIdForecast struct {
	TopicId  uint64    `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId  string    `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
	Forecast *Forecast `protobuf:"bytes,3,opt,name=forecast,proto3" json:"forecast,omitempty"`
}

func (m *TopicIdActorIdForecast) Reset()         { *m = TopicIdActorIdForecast{} }
func (m *TopicIdActorIdForecast) String() string { return proto.CompactTextString(m) }
func (*TopicIdActorIdForecast) ProtoMessage()    {}
func (*TopicIdActorIdForecast) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{18}
}
func (m *TopicIdActorIdForecast) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdActorIdForecast) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdActorIdForecast.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdActorIdForecast) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdActorIdForecast.Merge(m, src)
}
func (m *TopicIdActorIdForecast) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdActorIdForecast) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdActorIdForecast.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdActorIdForecast proto.InternalMessageInfo

func (m *TopicIdActorIdForecast) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdActorIdForecast) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

func (m *TopicIdActorIdForecast) GetForecast() *Forecast {
	if m != nil {
		return m.Forecast
	}
	return nil
}

type LibP2PKeyAndOffchainNode struct {
	LibP2PKey    string        `protobuf:"bytes,1,opt,name=lib_p2p_key,json=libP2pKey,proto3" json:"lib_p2p_key,omitempty"`
	OffchainNode *OffchainNode `protobuf:"bytes,2,opt,name=offchain_node,json=offchainNode,proto3" json:"offchain_node,omitempty"`
}

func (m *LibP2PKeyAndOffchainNode) Reset()         { *m = LibP2PKeyAndOffchainNode{} }
func (m *LibP2PKeyAndOffchainNode) String() string { return proto.CompactTextString(m) }
func (*LibP2PKeyAndOffchainNode) ProtoMessage()    {}
func (*LibP2PKeyAndOffchainNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{19}
}
func (m *LibP2PKeyAndOffchainNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LibP2PKeyAndOffchainNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LibP2PKeyAndOffchainNode.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LibP2PKeyAndOffchainNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LibP2PKeyAndOffchainNode.Merge(m, src)
}
func (m *LibP2PKeyAndOffchainNode) XXX_Size() int {
	return m.Size()
}
func (m *LibP2PKeyAndOffchainNode) XXX_DiscardUnknown() {
	xxx_messageInfo_LibP2PKeyAndOffchainNode.DiscardUnknown(m)
}

var xxx_messageInfo_LibP2PKeyAndOffchainNode proto.InternalMessageInfo

func (m *LibP2PKeyAndOffchainNode) GetLibP2PKey() string {
	if m != nil {
		return m.LibP2PKey
	}
	return ""
}

func (m *LibP2PKeyAndOffchainNode) GetOffchainNode() *OffchainNode {
	if m != nil {
		return m.OffchainNode
	}
	return nil
}

type TopicIdAndDec struct {
	TopicId uint64                                          `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Dec     github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,2,opt,name=dec,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"dec"`
}

func (m *TopicIdAndDec) Reset()         { *m = TopicIdAndDec{} }
func (m *TopicIdAndDec) String() string { return proto.CompactTextString(m) }
func (*TopicIdAndDec) ProtoMessage()    {}
func (*TopicIdAndDec) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{20}
}
func (m *TopicIdAndDec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdAndDec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdAndDec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdAndDec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdAndDec.Merge(m, src)
}
func (m *TopicIdAndDec) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdAndDec) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdAndDec.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdAndDec proto.InternalMessageInfo

func (m *TopicIdAndDec) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

type TopicIdBlockHeightInferences struct {
	TopicId     uint64      `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64       `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Inferences  *Inferences `protobuf:"bytes,3,opt,name=inferences,proto3" json:"inferences,omitempty"`
}

func (m *TopicIdBlockHeightInferences) Reset()         { *m = TopicIdBlockHeightInferences{} }
func (m *TopicIdBlockHeightInferences) String() string { return proto.CompactTextString(m) }
func (*TopicIdBlockHeightInferences) ProtoMessage()    {}
func (*TopicIdBlockHeightInferences) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{21}
}
func (m *TopicIdBlockHeightInferences) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdBlockHeightInferences) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdBlockHeightInferences.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdBlockHeightInferences) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdBlockHeightInferences.Merge(m, src)
}
func (m *TopicIdBlockHeightInferences) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdBlockHeightInferences) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdBlockHeightInferences.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdBlockHeightInferences proto.InternalMessageInfo

func (m *TopicIdBlockHeightInferences) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdBlockHeightInferences) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *TopicIdBlockHeightInferences) GetInferences() *Inferences {
	if m != nil {
		return m.Inferences
	}
	return nil
}

type TopicIdBlockHeightForecasts struct {
	TopicId     uint64     `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64      `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	Forecasts   *Forecasts `protobuf:"bytes,3,opt,name=forecasts,proto3" json:"forecasts,omitempty"`
}

func (m *TopicIdBlockHeightForecasts) Reset()         { *m = TopicIdBlockHeightForecasts{} }
func (m *TopicIdBlockHeightForecasts) String() string { return proto.CompactTextString(m) }
func (*TopicIdBlockHeightForecasts) ProtoMessage()    {}
func (*TopicIdBlockHeightForecasts) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{22}
}
func (m *TopicIdBlockHeightForecasts) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdBlockHeightForecasts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdBlockHeightForecasts.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdBlockHeightForecasts) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdBlockHeightForecasts.Merge(m, src)
}
func (m *TopicIdBlockHeightForecasts) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdBlockHeightForecasts) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdBlockHeightForecasts.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdBlockHeightForecasts proto.InternalMessageInfo

func (m *TopicIdBlockHeightForecasts) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdBlockHeightForecasts) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *TopicIdBlockHeightForecasts) GetForecasts() *Forecasts {
	if m != nil {
		return m.Forecasts
	}
	return nil
}

type TopicIdBlockHeightReputerValueBundles struct {
	TopicId             uint64               `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight         int64                `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	ReputerValueBundles *ReputerValueBundles `protobuf:"bytes,3,opt,name=reputer_value_bundles,json=reputerValueBundles,proto3" json:"reputer_value_bundles,omitempty"`
}

func (m *TopicIdBlockHeightReputerValueBundles) Reset()         { *m = TopicIdBlockHeightReputerValueBundles{} }
func (m *TopicIdBlockHeightReputerValueBundles) String() string { return proto.CompactTextString(m) }
func (*TopicIdBlockHeightReputerValueBundles) ProtoMessage()    {}
func (*TopicIdBlockHeightReputerValueBundles) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{23}
}
func (m *TopicIdBlockHeightReputerValueBundles) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdBlockHeightReputerValueBundles) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdBlockHeightReputerValueBundles.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdBlockHeightReputerValueBundles) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdBlockHeightReputerValueBundles.Merge(m, src)
}
func (m *TopicIdBlockHeightReputerValueBundles) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdBlockHeightReputerValueBundles) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdBlockHeightReputerValueBundles.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdBlockHeightReputerValueBundles proto.InternalMessageInfo

func (m *TopicIdBlockHeightReputerValueBundles) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdBlockHeightReputerValueBundles) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *TopicIdBlockHeightReputerValueBundles) GetReputerValueBundles() *ReputerValueBundles {
	if m != nil {
		return m.ReputerValueBundles
	}
	return nil
}

type TopicIdBlockHeightValueBundles struct {
	TopicId     uint64       `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	BlockHeight int64        `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	ValueBundle *ValueBundle `protobuf:"bytes,3,opt,name=value_bundle,json=valueBundle,proto3" json:"value_bundle,omitempty"`
}

func (m *TopicIdBlockHeightValueBundles) Reset()         { *m = TopicIdBlockHeightValueBundles{} }
func (m *TopicIdBlockHeightValueBundles) String() string { return proto.CompactTextString(m) }
func (*TopicIdBlockHeightValueBundles) ProtoMessage()    {}
func (*TopicIdBlockHeightValueBundles) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{24}
}
func (m *TopicIdBlockHeightValueBundles) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdBlockHeightValueBundles) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdBlockHeightValueBundles.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdBlockHeightValueBundles) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdBlockHeightValueBundles.Merge(m, src)
}
func (m *TopicIdBlockHeightValueBundles) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdBlockHeightValueBundles) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdBlockHeightValueBundles.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdBlockHeightValueBundles proto.InternalMessageInfo

func (m *TopicIdBlockHeightValueBundles) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdBlockHeightValueBundles) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *TopicIdBlockHeightValueBundles) GetValueBundle() *ValueBundle {
	if m != nil {
		return m.ValueBundle
	}
	return nil
}

type TopicIdAndNonces struct {
	TopicId uint64  `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Nonces  *Nonces `protobuf:"bytes,2,opt,name=nonces,proto3" json:"nonces,omitempty"`
}

func (m *TopicIdAndNonces) Reset()         { *m = TopicIdAndNonces{} }
func (m *TopicIdAndNonces) String() string { return proto.CompactTextString(m) }
func (*TopicIdAndNonces) ProtoMessage()    {}
func (*TopicIdAndNonces) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{25}
}
func (m *TopicIdAndNonces) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdAndNonces) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdAndNonces.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdAndNonces) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdAndNonces.Merge(m, src)
}
func (m *TopicIdAndNonces) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdAndNonces) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdAndNonces.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdAndNonces proto.InternalMessageInfo

func (m *TopicIdAndNonces) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdAndNonces) GetNonces() *Nonces {
	if m != nil {
		return m.Nonces
	}
	return nil
}

type TopicIdAndReputerRequestNonces struct {
	TopicId              uint64                `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ReputerRequestNonces *ReputerRequestNonces `protobuf:"bytes,2,opt,name=reputer_request_nonces,json=reputerRequestNonces,proto3" json:"reputer_request_nonces,omitempty"`
}

func (m *TopicIdAndReputerRequestNonces) Reset()         { *m = TopicIdAndReputerRequestNonces{} }
func (m *TopicIdAndReputerRequestNonces) String() string { return proto.CompactTextString(m) }
func (*TopicIdAndReputerRequestNonces) ProtoMessage()    {}
func (*TopicIdAndReputerRequestNonces) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{26}
}
func (m *TopicIdAndReputerRequestNonces) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdAndReputerRequestNonces) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdAndReputerRequestNonces.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdAndReputerRequestNonces) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdAndReputerRequestNonces.Merge(m, src)
}
func (m *TopicIdAndReputerRequestNonces) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdAndReputerRequestNonces) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdAndReputerRequestNonces.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdAndReputerRequestNonces proto.InternalMessageInfo

func (m *TopicIdAndReputerRequestNonces) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdAndReputerRequestNonces) GetReputerRequestNonces() *ReputerRequestNonces {
	if m != nil {
		return m.ReputerRequestNonces
	}
	return nil
}

type TopicIdActorIdTimeStampedValue struct {
	TopicId          uint64            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId          string            `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
	TimestampedValue *TimestampedValue `protobuf:"bytes,3,opt,name=timestamped_value,json=timestampedValue,proto3" json:"timestamped_value,omitempty"`
}

func (m *TopicIdActorIdTimeStampedValue) Reset()         { *m = TopicIdActorIdTimeStampedValue{} }
func (m *TopicIdActorIdTimeStampedValue) String() string { return proto.CompactTextString(m) }
func (*TopicIdActorIdTimeStampedValue) ProtoMessage()    {}
func (*TopicIdActorIdTimeStampedValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{27}
}
func (m *TopicIdActorIdTimeStampedValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdActorIdTimeStampedValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdActorIdTimeStampedValue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdActorIdTimeStampedValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdActorIdTimeStampedValue.Merge(m, src)
}
func (m *TopicIdActorIdTimeStampedValue) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdActorIdTimeStampedValue) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdActorIdTimeStampedValue.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdActorIdTimeStampedValue proto.InternalMessageInfo

func (m *TopicIdActorIdTimeStampedValue) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdActorIdTimeStampedValue) GetActorId() string {
	if m != nil {
		return m.ActorId
	}
	return ""
}

func (m *TopicIdActorIdTimeStampedValue) GetTimestampedValue() *TimestampedValue {
	if m != nil {
		return m.TimestampedValue
	}
	return nil
}

type TopicIdActorIdActorIdTimeStampedValue struct {
	TopicId          uint64            `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	ActorId1         string            `protobuf:"bytes,2,opt,name=actor_id1,json=actorId1,proto3" json:"actor_id1,omitempty"`
	ActorId2         string            `protobuf:"bytes,3,opt,name=actor_id2,json=actorId2,proto3" json:"actor_id2,omitempty"`
	TimestampedValue *TimestampedValue `protobuf:"bytes,4,opt,name=timestamped_value,json=timestampedValue,proto3" json:"timestamped_value,omitempty"`
}

func (m *TopicIdActorIdActorIdTimeStampedValue) Reset()         { *m = TopicIdActorIdActorIdTimeStampedValue{} }
func (m *TopicIdActorIdActorIdTimeStampedValue) String() string { return proto.CompactTextString(m) }
func (*TopicIdActorIdActorIdTimeStampedValue) ProtoMessage()    {}
func (*TopicIdActorIdActorIdTimeStampedValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{28}
}
func (m *TopicIdActorIdActorIdTimeStampedValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdActorIdActorIdTimeStampedValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdActorIdActorIdTimeStampedValue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdActorIdActorIdTimeStampedValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdActorIdActorIdTimeStampedValue.Merge(m, src)
}
func (m *TopicIdActorIdActorIdTimeStampedValue) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdActorIdActorIdTimeStampedValue) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdActorIdActorIdTimeStampedValue.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdActorIdActorIdTimeStampedValue proto.InternalMessageInfo

func (m *TopicIdActorIdActorIdTimeStampedValue) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdActorIdActorIdTimeStampedValue) GetActorId1() string {
	if m != nil {
		return m.ActorId1
	}
	return ""
}

func (m *TopicIdActorIdActorIdTimeStampedValue) GetActorId2() string {
	if m != nil {
		return m.ActorId2
	}
	return ""
}

func (m *TopicIdActorIdActorIdTimeStampedValue) GetTimestampedValue() *TimestampedValue {
	if m != nil {
		return m.TimestampedValue
	}
	return nil
}

type TopicIdTimestampedActorNonce struct {
	TopicId               uint64                 `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	TimestampedActorNonce *TimestampedActorNonce `protobuf:"bytes,2,opt,name=timestamped_actor_nonce,json=timestampedActorNonce,proto3" json:"timestamped_actor_nonce,omitempty"`
}

func (m *TopicIdTimestampedActorNonce) Reset()         { *m = TopicIdTimestampedActorNonce{} }
func (m *TopicIdTimestampedActorNonce) String() string { return proto.CompactTextString(m) }
func (*TopicIdTimestampedActorNonce) ProtoMessage()    {}
func (*TopicIdTimestampedActorNonce) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{29}
}
func (m *TopicIdTimestampedActorNonce) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdTimestampedActorNonce) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdTimestampedActorNonce.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdTimestampedActorNonce) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdTimestampedActorNonce.Merge(m, src)
}
func (m *TopicIdTimestampedActorNonce) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdTimestampedActorNonce) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdTimestampedActorNonce.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdTimestampedActorNonce proto.InternalMessageInfo

func (m *TopicIdTimestampedActorNonce) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdTimestampedActorNonce) GetTimestampedActorNonce() *TimestampedActorNonce {
	if m != nil {
		return m.TimestampedActorNonce
	}
	return nil
}

type BlockHeightTopicIds struct {
	BlockHeight int64     `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	TopicIds    *TopicIds `protobuf:"bytes,2,opt,name=topic_ids,json=topicIds,proto3" json:"topic_ids,omitempty"`
}

func (m *BlockHeightTopicIds) Reset()         { *m = BlockHeightTopicIds{} }
func (m *BlockHeightTopicIds) String() string { return proto.CompactTextString(m) }
func (*BlockHeightTopicIds) ProtoMessage()    {}
func (*BlockHeightTopicIds) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{30}
}
func (m *BlockHeightTopicIds) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockHeightTopicIds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockHeightTopicIds.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockHeightTopicIds) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockHeightTopicIds.Merge(m, src)
}
func (m *BlockHeightTopicIds) XXX_Size() int {
	return m.Size()
}
func (m *BlockHeightTopicIds) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockHeightTopicIds.DiscardUnknown(m)
}

var xxx_messageInfo_BlockHeightTopicIds proto.InternalMessageInfo

func (m *BlockHeightTopicIds) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *BlockHeightTopicIds) GetTopicIds() *TopicIds {
	if m != nil {
		return m.TopicIds
	}
	return nil
}

type BlockHeightTopicIdWeightPair struct {
	BlockHeight int64              `protobuf:"varint,1,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
	TopicWeight *TopicIdWeightPair `protobuf:"bytes,2,opt,name=topic_weight,json=topicWeight,proto3" json:"topic_weight,omitempty"`
}

func (m *BlockHeightTopicIdWeightPair) Reset()         { *m = BlockHeightTopicIdWeightPair{} }
func (m *BlockHeightTopicIdWeightPair) String() string { return proto.CompactTextString(m) }
func (*BlockHeightTopicIdWeightPair) ProtoMessage()    {}
func (*BlockHeightTopicIdWeightPair) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{31}
}
func (m *BlockHeightTopicIdWeightPair) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockHeightTopicIdWeightPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockHeightTopicIdWeightPair.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockHeightTopicIdWeightPair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockHeightTopicIdWeightPair.Merge(m, src)
}
func (m *BlockHeightTopicIdWeightPair) XXX_Size() int {
	return m.Size()
}
func (m *BlockHeightTopicIdWeightPair) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockHeightTopicIdWeightPair.DiscardUnknown(m)
}

var xxx_messageInfo_BlockHeightTopicIdWeightPair proto.InternalMessageInfo

func (m *BlockHeightTopicIdWeightPair) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

func (m *BlockHeightTopicIdWeightPair) GetTopicWeight() *TopicIdWeightPair {
	if m != nil {
		return m.TopicWeight
	}
	return nil
}

type TopicIdReputerReputerValueBundle struct {
	TopicId            uint64              `protobuf:"varint,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	Reputer            string              `protobuf:"bytes,2,opt,name=reputer,proto3" json:"reputer,omitempty"`
	ReputerValueBundle *ReputerValueBundle `protobuf:"bytes,3,opt,name=reputer_value_bundle,json=reputerValueBundle,proto3" json:"reputer_value_bundle,omitempty"`
}

func (m *TopicIdReputerReputerValueBundle) Reset()         { *m = TopicIdReputerReputerValueBundle{} }
func (m *TopicIdReputerReputerValueBundle) String() string { return proto.CompactTextString(m) }
func (*TopicIdReputerReputerValueBundle) ProtoMessage()    {}
func (*TopicIdReputerReputerValueBundle) Descriptor() ([]byte, []int) {
	return fileDescriptor_4ad8782e75ed84c6, []int{32}
}
func (m *TopicIdReputerReputerValueBundle) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TopicIdReputerReputerValueBundle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TopicIdReputerReputerValueBundle.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TopicIdReputerReputerValueBundle) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopicIdReputerReputerValueBundle.Merge(m, src)
}
func (m *TopicIdReputerReputerValueBundle) XXX_Size() int {
	return m.Size()
}
func (m *TopicIdReputerReputerValueBundle) XXX_DiscardUnknown() {
	xxx_messageInfo_TopicIdReputerReputerValueBundle.DiscardUnknown(m)
}

var xxx_messageInfo_TopicIdReputerReputerValueBundle proto.InternalMessageInfo

func (m *TopicIdReputerReputerValueBundle) GetTopicId() uint64 {
	if m != nil {
		return m.TopicId
	}
	return 0
}

func (m *TopicIdReputerReputerValueBundle) GetReputer() string {
	if m != nil {
		return m.Reputer
	}
	return ""
}

func (m *TopicIdReputerReputerValueBundle) GetReputerValueBundle() *ReputerValueBundle {
	if m != nil {
		return m.ReputerValueBundle
	}
	return nil
}

func init() {
	proto.RegisterType((*GenesisState)(nil), "emissions.v9.GenesisState")
	proto.RegisterType((*TopicIdAndTopic)(nil), "emissions.v9.TopicIdAndTopic")
	proto.RegisterType((*TopicAndActorId)(nil), "emissions.v9.TopicAndActorId")
	proto.RegisterType((*TopicIdAndBlockHeight)(nil), "emissions.v9.TopicIdAndBlockHeight")
	proto.RegisterType((*BlockHeightAndTopicIds)(nil), "emissions.v9.BlockHeightAndTopicIds")
	proto.RegisterType((*TopicIdBlockHeightScores)(nil), "emissions.v9.TopicIdBlockHeightScores")
	proto.RegisterType((*TopicIdActorIdScore)(nil), "emissions.v9.TopicIdActorIdScore")
	proto.RegisterType((*TopicIdActorIdUint64)(nil), "emissions.v9.TopicIdActorIdUint64")
	proto.RegisterType((*TopicIdActorIdListeningCoefficient)(nil), "emissions.v9.TopicIdActorIdListeningCoefficient")
	proto.RegisterType((*TopicIdActorIdDec)(nil), "emissions.v9.TopicIdActorIdDec")
	proto.RegisterType((*TopicIdAndInt)(nil), "emissions.v9.TopicIdAndInt")
	proto.RegisterType((*TopicIdActorIdInt)(nil), "emissions.v9.TopicIdActorIdInt")
	proto.RegisterType((*TopicIdDelegatorReputerDelegatorInfo)(nil), "emissions.v9.TopicIdDelegatorReputerDelegatorInfo")
	proto.RegisterType((*BlockHeightTopicIdReputerStakeRemovalInfo)(nil), "emissions.v9.BlockHeightTopicIdReputerStakeRemovalInfo")
	proto.RegisterType((*ActorIdTopicIdBlockHeight)(nil), "emissions.v9.ActorIdTopicIdBlockHeight")
	proto.RegisterType((*BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo)(nil), "emissions.v9.BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo")
	proto.RegisterType((*DelegatorReputerTopicIdBlockHeight)(nil), "emissions.v9.DelegatorReputerTopicIdBlockHeight")
	proto.RegisterType((*TopicIdActorIdInference)(nil), "emissions.v9.TopicIdActorIdInference")
	proto.RegisterType((*TopicIdActorIdForecast)(nil), "emissions.v9.TopicIdActorIdForecast")
	proto.RegisterType((*LibP2PKeyAndOffchainNode)(nil), "emissions.v9.LibP2pKeyAndOffchainNode")
	proto.RegisterType((*TopicIdAndDec)(nil), "emissions.v9.TopicIdAndDec")
	proto.RegisterType((*TopicIdBlockHeightInferences)(nil), "emissions.v9.TopicIdBlockHeightInferences")
	proto.RegisterType((*TopicIdBlockHeightForecasts)(nil), "emissions.v9.TopicIdBlockHeightForecasts")
	proto.RegisterType((*TopicIdBlockHeightReputerValueBundles)(nil), "emissions.v9.TopicIdBlockHeightReputerValueBundles")
	proto.RegisterType((*TopicIdBlockHeightValueBundles)(nil), "emissions.v9.TopicIdBlockHeightValueBundles")
	proto.RegisterType((*TopicIdAndNonces)(nil), "emissions.v9.TopicIdAndNonces")
	proto.RegisterType((*TopicIdAndReputerRequestNonces)(nil), "emissions.v9.TopicIdAndReputerRequestNonces")
	proto.RegisterType((*TopicIdActorIdTimeStampedValue)(nil), "emissions.v9.TopicIdActorIdTimeStampedValue")
	proto.RegisterType((*TopicIdActorIdActorIdTimeStampedValue)(nil), "emissions.v9.TopicIdActorIdActorIdTimeStampedValue")
	proto.RegisterType((*TopicIdTimestampedActorNonce)(nil), "emissions.v9.TopicIdTimestampedActorNonce")
	proto.RegisterType((*BlockHeightTopicIds)(nil), "emissions.v9.BlockHeightTopicIds")
	proto.RegisterType((*BlockHeightTopicIdWeightPair)(nil), "emissions.v9.BlockHeightTopicIdWeightPair")
	proto.RegisterType((*TopicIdReputerReputerValueBundle)(nil), "emissions.v9.TopicIdReputerReputerValueBundle")
}

func init() { proto.RegisterFile("emissions/v9/genesis.proto", fileDescriptor_4ad8782e75ed84c6) }

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

func (m *GenesisState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MonthlyTopicRewards.Size()
		i -= size
		if _, err := m.MonthlyTopicRewards.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6
	i--
	dAtA[i] = 0x92
	{
		size := m.MonthlyReputerRewards.Size()
		i -= size
		if _, err := m.MonthlyReputerRewards.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6
	i--
	dAtA[i] = 0x8a
	if len(m.OutlierResistantNetworkInferences) > 0 {
		for iNdEx := len(m.OutlierResistantNetworkInferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OutlierResistantNetworkInferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x6
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.NetworkInferences) > 0 {
		for iNdEx := len(m.NetworkInferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NetworkInferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xfa
		}
	}
	if len(m.LatestForecasterWeights) > 0 {
		for iNdEx := len(m.LatestForecasterWeights) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestForecasterWeights[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xf2
		}
	}
	if len(m.LatestInfererWeights) > 0 {
		for iNdEx := len(m.LatestInfererWeights) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestInfererWeights[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xea
		}
	}
	if len(m.LatestRegretStdNorm) > 0 {
		for iNdEx := len(m.LatestRegretStdNorm) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestRegretStdNorm[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xe2
		}
	}
	if len(m.GlobalAdminWhitelist) > 0 {
		for iNdEx := len(m.GlobalAdminWhitelist) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.GlobalAdminWhitelist[iNdEx])
			copy(dAtA[i:], m.GlobalAdminWhitelist[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.GlobalAdminWhitelist[iNdEx])))
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xda
		}
	}
	if len(m.GlobalReputerWhitelist) > 0 {
		for iNdEx := len(m.GlobalReputerWhitelist) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.GlobalReputerWhitelist[iNdEx])
			copy(dAtA[i:], m.GlobalReputerWhitelist[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.GlobalReputerWhitelist[iNdEx])))
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xd2
		}
	}
	if len(m.GlobalWorkerWhitelist) > 0 {
		for iNdEx := len(m.GlobalWorkerWhitelist) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.GlobalWorkerWhitelist[iNdEx])
			copy(dAtA[i:], m.GlobalWorkerWhitelist[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.GlobalWorkerWhitelist[iNdEx])))
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xca
		}
	}
	if len(m.InitialReputerEmaScore) > 0 {
		for iNdEx := len(m.InitialReputerEmaScore) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InitialReputerEmaScore[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xc2
		}
	}
	if len(m.InitialForecasterEmaScore) > 0 {
		for iNdEx := len(m.InitialForecasterEmaScore) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InitialForecasterEmaScore[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xba
		}
	}
	if len(m.InitialInfererEmaScore) > 0 {
		for iNdEx := len(m.InitialInfererEmaScore) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InitialInfererEmaScore[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.MadInferences) > 0 {
		for iNdEx := len(m.MadInferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MadInferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.LastMedianInferences) > 0 {
		for iNdEx := len(m.LastMedianInferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LastMedianInferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.TopicReputerWhitelistEnabled) > 0 {
		dAtA2 := make([]byte, len(m.TopicReputerWhitelistEnabled)*10)
		var j1 int
		for _, num := range m.TopicReputerWhitelistEnabled {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintGenesis(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x5
		i--
		dAtA[i] = 0x9a
	}
	if len(m.TopicWorkerWhitelistEnabled) > 0 {
		dAtA4 := make([]byte, len(m.TopicWorkerWhitelistEnabled)*10)
		var j3 int
		for _, num := range m.TopicWorkerWhitelistEnabled {
			for num >= 1<<7 {
				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j3++
			}
			dAtA4[j3] = uint8(num)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA4[:j3])
		i = encodeVarintGenesis(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0x5
		i--
		dAtA[i] = 0x92
	}
	if len(m.TopicReputerWhitelist) > 0 {
		for iNdEx := len(m.TopicReputerWhitelist) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicReputerWhitelist[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.TopicWorkerWhitelist) > 0 {
		for iNdEx := len(m.TopicWorkerWhitelist) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicWorkerWhitelist[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.TopicCreatorWhitelist) > 0 {
		for iNdEx := len(m.TopicCreatorWhitelist) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.TopicCreatorWhitelist[iNdEx])
			copy(dAtA[i:], m.TopicCreatorWhitelist[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.TopicCreatorWhitelist[iNdEx])))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xfa
		}
	}
	if len(m.GlobalWhitelist) > 0 {
		for iNdEx := len(m.GlobalWhitelist) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.GlobalWhitelist[iNdEx])
			copy(dAtA[i:], m.GlobalWhitelist[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.GlobalWhitelist[iNdEx])))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xf2
		}
	}
	if len(m.WhitelistAdmins) > 0 {
		for iNdEx := len(m.WhitelistAdmins) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.WhitelistAdmins[iNdEx])
			copy(dAtA[i:], m.WhitelistAdmins[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.WhitelistAdmins[iNdEx])))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xea
		}
	}
	{
		size := m.RewardCurrentBlockEmission.Size()
		i -= size
		if _, err := m.RewardCurrentBlockEmission.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4
	i--
	dAtA[i] = 0xe2
	{
		size := m.TotalSumPreviousTopicWeights.Size()
		i -= size
		if _, err := m.TotalSumPreviousTopicWeights.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4
	i--
	dAtA[i] = 0xda
	if len(m.LossBundles) > 0 {
		for iNdEx := len(m.LossBundles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LossBundles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xd2
		}
	}
	if len(m.LowestReputerScoreEma) > 0 {
		for iNdEx := len(m.LowestReputerScoreEma) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LowestReputerScoreEma[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xca
		}
	}
	if len(m.ActiveReputers) > 0 {
		for iNdEx := len(m.ActiveReputers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ActiveReputers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xc2
		}
	}
	if len(m.LowestForecasterScoreEma) > 0 {
		for iNdEx := len(m.LowestForecasterScoreEma) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LowestForecasterScoreEma[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xba
		}
	}
	if len(m.LowestInfererScoreEma) > 0 {
		for iNdEx := len(m.LowestInfererScoreEma) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LowestInfererScoreEma[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.ActiveForecasters) > 0 {
		for iNdEx := len(m.ActiveForecasters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ActiveForecasters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.ActiveInferers) > 0 {
		for iNdEx := len(m.ActiveInferers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ActiveInferers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.CountForecasterInclusionsInTopicActiveSet) > 0 {
		for iNdEx := len(m.CountForecasterInclusionsInTopicActiveSet) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CountForecasterInclusionsInTopicActiveSet[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.CountInfererInclusionsInTopicActiveSet) > 0 {
		for iNdEx := len(m.CountInfererInclusionsInTopicActiveSet) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CountInfererInclusionsInTopicActiveSet[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.PreviousTopicQuantileReputerScoreEma) > 0 {
		for iNdEx := len(m.PreviousTopicQuantileReputerScoreEma) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PreviousTopicQuantileReputerScoreEma[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.PreviousTopicQuantileForecasterScoreEma) > 0 {
		for iNdEx := len(m.PreviousTopicQuantileForecasterScoreEma) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PreviousTopicQuantileForecasterScoreEma[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.PreviousTopicQuantileInfererScoreEma) > 0 {
		for iNdEx := len(m.PreviousTopicQuantileInfererScoreEma) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PreviousTopicQuantileInfererScoreEma[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xfa
		}
	}
	if len(m.ReputerScoreEmas) > 0 {
		for iNdEx := len(m.ReputerScoreEmas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ReputerScoreEmas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xf2
		}
	}
	if len(m.ForecasterScoreEmas) > 0 {
		for iNdEx := len(m.ForecasterScoreEmas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ForecasterScoreEmas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xea
		}
	}
	if len(m.InfererScoreEmas) > 0 {
		for iNdEx := len(m.InfererScoreEmas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InfererScoreEmas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xe2
		}
	}
	if len(m.BlockToLowestActiveTopicWeight) > 0 {
		for iNdEx := len(m.BlockToLowestActiveTopicWeight) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BlockToLowestActiveTopicWeight[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xda
		}
	}
	if len(m.BlockToActiveTopics) > 0 {
		for iNdEx := len(m.BlockToActiveTopics) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BlockToActiveTopics[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xd2
		}
	}
	if len(m.TopicToNextPossibleChurningBlock) > 0 {
		for iNdEx := len(m.TopicToNextPossibleChurningBlock) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicToNextPossibleChurningBlock[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xca
		}
	}
	if len(m.LastDripBlock) > 0 {
		for iNdEx := len(m.LastDripBlock) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LastDripBlock[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xc2
		}
	}
	if len(m.OpenWorkerWindows) > 0 {
		for iNdEx := len(m.OpenWorkerWindows) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OpenWorkerWindows[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xba
		}
	}
	if len(m.TopicLastReputerCommit) > 0 {
		for iNdEx := len(m.TopicLastReputerCommit) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicLastReputerCommit[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.TopicLastWorkerCommit) > 0 {
		for iNdEx := len(m.TopicLastWorkerCommit) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicLastWorkerCommit[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.LatestOneOutForecasterForecasterNetworkRegrets) > 0 {
		for iNdEx := len(m.LatestOneOutForecasterForecasterNetworkRegrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestOneOutForecasterForecasterNetworkRegrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.LatestOneOutForecasterInfererNetworkRegrets) > 0 {
		for iNdEx := len(m.LatestOneOutForecasterInfererNetworkRegrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestOneOutForecasterInfererNetworkRegrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.LatestOneOutInfererForecasterNetworkRegrets) > 0 {
		for iNdEx := len(m.LatestOneOutInfererForecasterNetworkRegrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestOneOutInfererForecasterNetworkRegrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.LatestOneOutInfererInfererNetworkRegrets) > 0 {
		for iNdEx := len(m.LatestOneOutInfererInfererNetworkRegrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestOneOutInfererInfererNetworkRegrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.LatestNaiveInfererNetworkRegrets) > 0 {
		for iNdEx := len(m.LatestNaiveInfererNetworkRegrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestNaiveInfererNetworkRegrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.LatestOneInForecasterNetworkRegrets) > 0 {
		for iNdEx := len(m.LatestOneInForecasterNetworkRegrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestOneInForecasterNetworkRegrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xfa
		}
	}
	if len(m.LatestForecasterNetworkRegrets) > 0 {
		for iNdEx := len(m.LatestForecasterNetworkRegrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestForecasterNetworkRegrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xf2
		}
	}
	if len(m.LatestInfererNetworkRegrets) > 0 {
		for iNdEx := len(m.LatestInfererNetworkRegrets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LatestInfererNetworkRegrets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xea
		}
	}
	if len(m.UnfulfilledReputerNonces) > 0 {
		for iNdEx := len(m.UnfulfilledReputerNonces) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UnfulfilledReputerNonces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xe2
		}
	}
	if len(m.UnfulfilledWorkerNonces) > 0 {
		for iNdEx := len(m.UnfulfilledWorkerNonces) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UnfulfilledWorkerNonces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xda
		}
	}
	{
		size := m.PreviousPercentageRewardToStakedReputers.Size()
		i -= size
		if _, err := m.PreviousPercentageRewardToStakedReputers.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0xd2
	if len(m.NetworkLossBundles) > 0 {
		for iNdEx := len(m.NetworkLossBundles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NetworkLossBundles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xca
		}
	}
	if len(m.AllLossBundles) > 0 {
		for iNdEx := len(m.AllLossBundles) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AllLossBundles[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xc2
		}
	}
	if len(m.AllForecasts) > 0 {
		for iNdEx := len(m.AllForecasts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AllForecasts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xba
		}
	}
	if len(m.AllInferences) > 0 {
		for iNdEx := len(m.AllInferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AllInferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xb2
		}
	}
	if len(m.PreviousTopicWeight) > 0 {
		for iNdEx := len(m.PreviousTopicWeight) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PreviousTopicWeight[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xaa
		}
	}
	if len(m.TopicFeeRevenue) > 0 {
		for iNdEx := len(m.TopicFeeRevenue) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicFeeRevenue[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.Reputers) > 0 {
		for iNdEx := len(m.Reputers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Reputers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.Workers) > 0 {
		for iNdEx := len(m.Workers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Workers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.Forecasts) > 0 {
		for iNdEx := len(m.Forecasts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Forecasts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.Inferences) > 0 {
		for iNdEx := len(m.Inferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Inferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.DelegateStakeRemovalsByActor) > 0 {
		for iNdEx := len(m.DelegateStakeRemovalsByActor) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DelegateStakeRemovalsByActor[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xfa
		}
	}
	if len(m.DelegateStakeRemovalsByBlock) > 0 {
		for iNdEx := len(m.DelegateStakeRemovalsByBlock) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DelegateStakeRemovalsByBlock[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xf2
		}
	}
	if len(m.StakeRemovalsByActor) > 0 {
		for iNdEx := len(m.StakeRemovalsByActor) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StakeRemovalsByActor[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xea
		}
	}
	if len(m.StakeRemovalsByBlock) > 0 {
		for iNdEx := len(m.StakeRemovalsByBlock) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StakeRemovalsByBlock[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xe2
		}
	}
	if len(m.DelegateRewardPerShare) > 0 {
		for iNdEx := len(m.DelegateRewardPerShare) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DelegateRewardPerShare[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xda
		}
	}
	if len(m.StakeFromDelegatorsUponReputer) > 0 {
		for iNdEx := len(m.StakeFromDelegatorsUponReputer) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StakeFromDelegatorsUponReputer[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xd2
		}
	}
	if len(m.DelegatedStakes) > 0 {
		for iNdEx := len(m.DelegatedStakes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DelegatedStakes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	if len(m.StakeSumFromDelegator) > 0 {
		for iNdEx := len(m.StakeSumFromDelegator) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StakeSumFromDelegator[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	if len(m.StakeReputerAuthority) > 0 {
		for iNdEx := len(m.StakeReputerAuthority) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StakeReputerAuthority[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xba
		}
	}
	if len(m.TopicStake) > 0 {
		for iNdEx := len(m.TopicStake) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicStake[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xb2
		}
	}
	{
		size := m.TotalStake.Size()
		i -= size
		if _, err := m.TotalStake.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xaa
	if len(m.PreviousForecasterScoreRatio) > 0 {
		for iNdEx := len(m.PreviousForecasterScoreRatio) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PreviousForecasterScoreRatio[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if len(m.PreviousForecastRewardFraction) > 0 {
		for iNdEx := len(m.PreviousForecastRewardFraction) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PreviousForecastRewardFraction[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if len(m.PreviousInferenceRewardFraction) > 0 {
		for iNdEx := len(m.PreviousInferenceRewardFraction) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PreviousInferenceRewardFraction[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.PreviousReputerRewardFraction) > 0 {
		for iNdEx := len(m.PreviousReputerRewardFraction) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PreviousReputerRewardFraction[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.ReputerListeningCoefficient) > 0 {
		for iNdEx := len(m.ReputerListeningCoefficient) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ReputerListeningCoefficient[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.ReputerScoresByBlock) > 0 {
		for iNdEx := len(m.ReputerScoresByBlock) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ReputerScoresByBlock[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.ForecasterScoresByBlock) > 0 {
		for iNdEx := len(m.ForecasterScoresByBlock) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ForecasterScoresByBlock[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.InfererScoresByBlock) > 0 {
		for iNdEx := len(m.InfererScoresByBlock) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InfererScoresByBlock[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.TopicRewardNonce) > 0 {
		for iNdEx := len(m.TopicRewardNonce) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicRewardNonce[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.TopicReputers) > 0 {
		for iNdEx := len(m.TopicReputers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicReputers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.TopicWorkers) > 0 {
		for iNdEx := len(m.TopicWorkers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TopicWorkers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.RewardableTopics) > 0 {
		dAtA6 := make([]byte, len(m.RewardableTopics)*10)
		var j5 int
		for _, num := range m.RewardableTopics {
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		i -= j5
		copy(dAtA[i:], dAtA6[:j5])
		i = encodeVarintGenesis(dAtA, i, uint64(j5))
		i--
		dAtA[i] = 0x32
	}
	if len(m.ActiveTopics) > 0 {
		dAtA8 := make([]byte, len(m.ActiveTopics)*10)
		var j7 int
		for _, num := range m.ActiveTopics {
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA8[:j7])
		i = encodeVarintGenesis(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Topics) > 0 {
		for iNdEx := len(m.Topics) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Topics[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.NextTopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.NextTopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.CoreTeamAddresses) > 0 {
		for iNdEx := len(m.CoreTeamAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.CoreTeamAddresses[iNdEx])
			copy(dAtA[i:], m.CoreTeamAddresses[iNdEx])
			i = encodeVarintGenesis(dAtA, i, uint64(len(m.CoreTeamAddresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *TopicIdAndTopic) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdAndTopic) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Topic != nil {
		{
			size, err := m.Topic.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicAndActorId) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicAndActorId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdAndBlockHeight) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

func (m *BlockHeightAndTopicIds) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *BlockHeightAndTopicIds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TopicIds) > 0 {
		dAtA12 := make([]byte, len(m.TopicIds)*10)
		var j11 int
		for _, num := range m.TopicIds {
			for num >= 1<<7 {
				dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j11++
			}
			dAtA12[j11] = uint8(num)
			j11++
		}
		i -= j11
		copy(dAtA[i:], dAtA12[:j11])
		i = encodeVarintGenesis(dAtA, i, uint64(j11))
		i--
		dAtA[i] = 0x12
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdBlockHeightScores) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdBlockHeightScores) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Scores != nil {
		{
			size, err := m.Scores.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdActorIdScore) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdActorIdScore) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Score != nil {
		{
			size, err := m.Score.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdActorIdUint64) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdActorIdUint64) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Uint64 != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Uint64))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdActorIdListeningCoefficient) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdActorIdListeningCoefficient) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ListeningCoefficient != nil {
		{
			size, err := m.ListeningCoefficient.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdActorIdDec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdActorIdDec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Dec.Size()
		i -= size
		if _, err := m.Dec.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdAndInt) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdAndInt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Int.Size()
		i -= size
		if _, err := m.Int.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdActorIdInt) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdActorIdInt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Int.Size()
		i -= size
		if _, err := m.Int.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdDelegatorReputerDelegatorInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdDelegatorReputerDelegatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DelegatorInfo != nil {
		{
			size, err := m.DelegatorInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockHeightTopicIdReputerStakeRemovalInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *BlockHeightTopicIdReputerStakeRemovalInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StakeRemovalInfo != nil {
		{
			size, err := m.StakeRemovalInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ActorIdTopicIdBlockHeight) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *ActorIdTopicIdBlockHeight) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x18
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DelegateStakeRemovalInfo != nil {
		{
			size, err := m.DelegateStakeRemovalInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x10
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DelegatorReputerTopicIdBlockHeight) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *DelegatorReputerTopicIdBlockHeight) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x20
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdActorIdInference) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdActorIdInference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Inference != nil {
		{
			size, err := m.Inference.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdActorIdForecast) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdActorIdForecast) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Forecast != nil {
		{
			size, err := m.Forecast.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LibP2PKeyAndOffchainNode) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *LibP2PKeyAndOffchainNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OffchainNode != nil {
		{
			size, err := m.OffchainNode.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.LibP2PKey) > 0 {
		i -= len(m.LibP2PKey)
		copy(dAtA[i:], m.LibP2PKey)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.LibP2PKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdAndDec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdAndDec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Dec.Size()
		i -= size
		if _, err := m.Dec.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdBlockHeightInferences) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdBlockHeightInferences) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Inferences != nil {
		{
			size, err := m.Inferences.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdBlockHeightForecasts) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdBlockHeightForecasts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Forecasts != nil {
		{
			size, err := m.Forecasts.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdBlockHeightReputerValueBundles) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdBlockHeightReputerValueBundles) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReputerValueBundles != nil {
		{
			size, err := m.ReputerValueBundles.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdBlockHeightValueBundles) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdBlockHeightValueBundles) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ValueBundle != nil {
		{
			size, err := m.ValueBundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x10
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdAndNonces) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdAndNonces) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Nonces != nil {
		{
			size, err := m.Nonces.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdAndReputerRequestNonces) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdAndReputerRequestNonces) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReputerRequestNonces != nil {
		{
			size, err := m.ReputerRequestNonces.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdActorIdTimeStampedValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdActorIdTimeStampedValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampedValue != nil {
		{
			size, err := m.TimestampedValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ActorId) > 0 {
		i -= len(m.ActorId)
		copy(dAtA[i:], m.ActorId)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdActorIdActorIdTimeStampedValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdActorIdActorIdTimeStampedValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampedValue != nil {
		{
			size, err := m.TimestampedValue.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.ActorId2) > 0 {
		i -= len(m.ActorId2)
		copy(dAtA[i:], m.ActorId2)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId2)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ActorId1) > 0 {
		i -= len(m.ActorId1)
		copy(dAtA[i:], m.ActorId1)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ActorId1)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdTimestampedActorNonce) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdTimestampedActorNonce) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimestampedActorNonce != nil {
		{
			size, err := m.TimestampedActorNonce.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockHeightTopicIds) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *BlockHeightTopicIds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicIds != nil {
		{
			size, err := m.TopicIds.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockHeightTopicIdWeightPair) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *BlockHeightTopicIdWeightPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TopicWeight != nil {
		{
			size, err := m.TopicWeight.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.BlockHeight != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.BlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TopicIdReputerReputerValueBundle) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TopicIdReputerReputerValueBundle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReputerValueBundle != nil {
		{
			size, err := m.ReputerValueBundle.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGenesis(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Reputer) > 0 {
		i -= len(m.Reputer)
		copy(dAtA[i:], m.Reputer)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.Reputer)))
		i--
		dAtA[i] = 0x12
	}
	if m.TopicId != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.TopicId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
	offset -= sovGenesis(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GenesisState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if len(m.CoreTeamAddresses) > 0 {
		for _, s := range m.CoreTeamAddresses {
			l = len(s)
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if m.NextTopicId != 0 {
		n += 1 + sovGenesis(uint64(m.NextTopicId))
	}
	if len(m.Topics) > 0 {
		for _, e := range m.Topics {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ActiveTopics) > 0 {
		l = 0
		for _, e := range m.ActiveTopics {
			l += sovGenesis(uint64(e))
		}
		n += 1 + sovGenesis(uint64(l)) + l
	}
	if len(m.RewardableTopics) > 0 {
		l = 0
		for _, e := range m.RewardableTopics {
			l += sovGenesis(uint64(e))
		}
		n += 1 + sovGenesis(uint64(l)) + l
	}
	if len(m.TopicWorkers) > 0 {
		for _, e := range m.TopicWorkers {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicReputers) > 0 {
		for _, e := range m.TopicReputers {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicRewardNonce) > 0 {
		for _, e := range m.TopicRewardNonce {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.InfererScoresByBlock) > 0 {
		for _, e := range m.InfererScoresByBlock {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ForecasterScoresByBlock) > 0 {
		for _, e := range m.ForecasterScoresByBlock {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ReputerScoresByBlock) > 0 {
		for _, e := range m.ReputerScoresByBlock {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ReputerListeningCoefficient) > 0 {
		for _, e := range m.ReputerListeningCoefficient {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PreviousReputerRewardFraction) > 0 {
		for _, e := range m.PreviousReputerRewardFraction {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PreviousInferenceRewardFraction) > 0 {
		for _, e := range m.PreviousInferenceRewardFraction {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PreviousForecastRewardFraction) > 0 {
		for _, e := range m.PreviousForecastRewardFraction {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PreviousForecasterScoreRatio) > 0 {
		for _, e := range m.PreviousForecasterScoreRatio {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	l = m.TotalStake.Size()
	n += 2 + l + sovGenesis(uint64(l))
	if len(m.TopicStake) > 0 {
		for _, e := range m.TopicStake {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.StakeReputerAuthority) > 0 {
		for _, e := range m.StakeReputerAuthority {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.StakeSumFromDelegator) > 0 {
		for _, e := range m.StakeSumFromDelegator {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DelegatedStakes) > 0 {
		for _, e := range m.DelegatedStakes {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.StakeFromDelegatorsUponReputer) > 0 {
		for _, e := range m.StakeFromDelegatorsUponReputer {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DelegateRewardPerShare) > 0 {
		for _, e := range m.DelegateRewardPerShare {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.StakeRemovalsByBlock) > 0 {
		for _, e := range m.StakeRemovalsByBlock {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.StakeRemovalsByActor) > 0 {
		for _, e := range m.StakeRemovalsByActor {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DelegateStakeRemovalsByBlock) > 0 {
		for _, e := range m.DelegateStakeRemovalsByBlock {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DelegateStakeRemovalsByActor) > 0 {
		for _, e := range m.DelegateStakeRemovalsByActor {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.Inferences) > 0 {
		for _, e := range m.Inferences {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.Forecasts) > 0 {
		for _, e := range m.Forecasts {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.Workers) > 0 {
		for _, e := range m.Workers {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.Reputers) > 0 {
		for _, e := range m.Reputers {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicFeeRevenue) > 0 {
		for _, e := range m.TopicFeeRevenue {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PreviousTopicWeight) > 0 {
		for _, e := range m.PreviousTopicWeight {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.AllInferences) > 0 {
		for _, e := range m.AllInferences {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.AllForecasts) > 0 {
		for _, e := range m.AllForecasts {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.AllLossBundles) > 0 {
		for _, e := range m.AllLossBundles {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.NetworkLossBundles) > 0 {
		for _, e := range m.NetworkLossBundles {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	l = m.PreviousPercentageRewardToStakedReputers.Size()
	n += 2 + l + sovGenesis(uint64(l))
	if len(m.UnfulfilledWorkerNonces) > 0 {
		for _, e := range m.UnfulfilledWorkerNonces {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.UnfulfilledReputerNonces) > 0 {
		for _, e := range m.UnfulfilledReputerNonces {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestInfererNetworkRegrets) > 0 {
		for _, e := range m.LatestInfererNetworkRegrets {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestForecasterNetworkRegrets) > 0 {
		for _, e := range m.LatestForecasterNetworkRegrets {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestOneInForecasterNetworkRegrets) > 0 {
		for _, e := range m.LatestOneInForecasterNetworkRegrets {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestNaiveInfererNetworkRegrets) > 0 {
		for _, e := range m.LatestNaiveInfererNetworkRegrets {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestOneOutInfererInfererNetworkRegrets) > 0 {
		for _, e := range m.LatestOneOutInfererInfererNetworkRegrets {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestOneOutInfererForecasterNetworkRegrets) > 0 {
		for _, e := range m.LatestOneOutInfererForecasterNetworkRegrets {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestOneOutForecasterInfererNetworkRegrets) > 0 {
		for _, e := range m.LatestOneOutForecasterInfererNetworkRegrets {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestOneOutForecasterForecasterNetworkRegrets) > 0 {
		for _, e := range m.LatestOneOutForecasterForecasterNetworkRegrets {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicLastWorkerCommit) > 0 {
		for _, e := range m.TopicLastWorkerCommit {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicLastReputerCommit) > 0 {
		for _, e := range m.TopicLastReputerCommit {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.OpenWorkerWindows) > 0 {
		for _, e := range m.OpenWorkerWindows {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LastDripBlock) > 0 {
		for _, e := range m.LastDripBlock {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicToNextPossibleChurningBlock) > 0 {
		for _, e := range m.TopicToNextPossibleChurningBlock {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.BlockToActiveTopics) > 0 {
		for _, e := range m.BlockToActiveTopics {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.BlockToLowestActiveTopicWeight) > 0 {
		for _, e := range m.BlockToLowestActiveTopicWeight {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.InfererScoreEmas) > 0 {
		for _, e := range m.InfererScoreEmas {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ForecasterScoreEmas) > 0 {
		for _, e := range m.ForecasterScoreEmas {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ReputerScoreEmas) > 0 {
		for _, e := range m.ReputerScoreEmas {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PreviousTopicQuantileInfererScoreEma) > 0 {
		for _, e := range m.PreviousTopicQuantileInfererScoreEma {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PreviousTopicQuantileForecasterScoreEma) > 0 {
		for _, e := range m.PreviousTopicQuantileForecasterScoreEma {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.PreviousTopicQuantileReputerScoreEma) > 0 {
		for _, e := range m.PreviousTopicQuantileReputerScoreEma {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.CountInfererInclusionsInTopicActiveSet) > 0 {
		for _, e := range m.CountInfererInclusionsInTopicActiveSet {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.CountForecasterInclusionsInTopicActiveSet) > 0 {
		for _, e := range m.CountForecasterInclusionsInTopicActiveSet {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ActiveInferers) > 0 {
		for _, e := range m.ActiveInferers {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ActiveForecasters) > 0 {
		for _, e := range m.ActiveForecasters {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LowestInfererScoreEma) > 0 {
		for _, e := range m.LowestInfererScoreEma {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LowestForecasterScoreEma) > 0 {
		for _, e := range m.LowestForecasterScoreEma {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ActiveReputers) > 0 {
		for _, e := range m.ActiveReputers {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LowestReputerScoreEma) > 0 {
		for _, e := range m.LowestReputerScoreEma {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LossBundles) > 0 {
		for _, e := range m.LossBundles {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	l = m.TotalSumPreviousTopicWeights.Size()
	n += 2 + l + sovGenesis(uint64(l))
	l = m.RewardCurrentBlockEmission.Size()
	n += 2 + l + sovGenesis(uint64(l))
	if len(m.WhitelistAdmins) > 0 {
		for _, s := range m.WhitelistAdmins {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.GlobalWhitelist) > 0 {
		for _, s := range m.GlobalWhitelist {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicCreatorWhitelist) > 0 {
		for _, s := range m.TopicCreatorWhitelist {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicWorkerWhitelist) > 0 {
		for _, e := range m.TopicWorkerWhitelist {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicReputerWhitelist) > 0 {
		for _, e := range m.TopicReputerWhitelist {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.TopicWorkerWhitelistEnabled) > 0 {
		l = 0
		for _, e := range m.TopicWorkerWhitelistEnabled {
			l += sovGenesis(uint64(e))
		}
		n += 2 + sovGenesis(uint64(l)) + l
	}
	if len(m.TopicReputerWhitelistEnabled) > 0 {
		l = 0
		for _, e := range m.TopicReputerWhitelistEnabled {
			l += sovGenesis(uint64(e))
		}
		n += 2 + sovGenesis(uint64(l)) + l
	}
	if len(m.LastMedianInferences) > 0 {
		for _, e := range m.LastMedianInferences {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.MadInferences) > 0 {
		for _, e := range m.MadInferences {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.InitialInfererEmaScore) > 0 {
		for _, e := range m.InitialInfererEmaScore {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.InitialForecasterEmaScore) > 0 {
		for _, e := range m.InitialForecasterEmaScore {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.InitialReputerEmaScore) > 0 {
		for _, e := range m.InitialReputerEmaScore {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.GlobalWorkerWhitelist) > 0 {
		for _, s := range m.GlobalWorkerWhitelist {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.GlobalReputerWhitelist) > 0 {
		for _, s := range m.GlobalReputerWhitelist {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.GlobalAdminWhitelist) > 0 {
		for _, s := range m.GlobalAdminWhitelist {
			l = len(s)
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestRegretStdNorm) > 0 {
		for _, e := range m.LatestRegretStdNorm {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestInfererWeights) > 0 {
		for _, e := range m.LatestInfererWeights {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.LatestForecasterWeights) > 0 {
		for _, e := range m.LatestForecasterWeights {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.NetworkInferences) > 0 {
		for _, e := range m.NetworkInferences {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.OutlierResistantNetworkInferences) > 0 {
		for _, e := range m.OutlierResistantNetworkInferences {
			l = e.Size()
			n += 2 + l + sovGenesis(uint64(l))
		}
	}
	l = m.MonthlyReputerRewards.Size()
	n += 2 + l + sovGenesis(uint64(l))
	l = m.MonthlyTopicRewards.Size()
	n += 2 + l + sovGenesis(uint64(l))
	return n
}

func (m *TopicIdAndTopic) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.Topic != nil {
		l = m.Topic.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicAndActorId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdAndBlockHeight) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	return n
}

func (m *BlockHeightAndTopicIds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if len(m.TopicIds) > 0 {
		l = 0
		for _, e := range m.TopicIds {
			l += sovGenesis(uint64(e))
		}
		n += 1 + sovGenesis(uint64(l)) + l
	}
	return n
}

func (m *TopicIdBlockHeightScores) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if m.Scores != nil {
		l = m.Scores.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdActorIdScore) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Score != nil {
		l = m.Score.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdActorIdUint64) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Uint64 != 0 {
		n += 1 + sovGenesis(uint64(m.Uint64))
	}
	return n
}

func (m *TopicIdActorIdListeningCoefficient) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.ListeningCoefficient != nil {
		l = m.ListeningCoefficient.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdActorIdDec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.Dec.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *TopicIdAndInt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = m.Int.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *TopicIdActorIdInt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.Int.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *TopicIdDelegatorReputerDelegatorInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.DelegatorInfo != nil {
		l = m.DelegatorInfo.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *BlockHeightTopicIdReputerStakeRemovalInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.StakeRemovalInfo != nil {
		l = m.StakeRemovalInfo.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *ActorIdTopicIdBlockHeight) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	return n
}

func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.DelegateStakeRemovalInfo != nil {
		l = m.DelegateStakeRemovalInfo.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *DelegatorReputerTopicIdBlockHeight) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	return n
}

func (m *TopicIdActorIdInference) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Inference != nil {
		l = m.Inference.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdActorIdForecast) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Forecast != nil {
		l = m.Forecast.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *LibP2PKeyAndOffchainNode) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LibP2PKey)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.OffchainNode != nil {
		l = m.OffchainNode.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdAndDec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = m.Dec.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *TopicIdBlockHeightInferences) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if m.Inferences != nil {
		l = m.Inferences.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdBlockHeightForecasts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if m.Forecasts != nil {
		l = m.Forecasts.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdBlockHeightReputerValueBundles) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if m.ReputerValueBundles != nil {
		l = m.ReputerValueBundles.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdBlockHeightValueBundles) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if m.ValueBundle != nil {
		l = m.ValueBundle.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdAndNonces) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.Nonces != nil {
		l = m.Nonces.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdAndReputerRequestNonces) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.ReputerRequestNonces != nil {
		l = m.ReputerRequestNonces.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdActorIdTimeStampedValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.TimestampedValue != nil {
		l = m.TimestampedValue.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdActorIdActorIdTimeStampedValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.ActorId1)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.ActorId2)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.TimestampedValue != nil {
		l = m.TimestampedValue.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdTimestampedActorNonce) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	if m.TimestampedActorNonce != nil {
		l = m.TimestampedActorNonce.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *BlockHeightTopicIds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if m.TopicIds != nil {
		l = m.TopicIds.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *BlockHeightTopicIdWeightPair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BlockHeight != 0 {
		n += 1 + sovGenesis(uint64(m.BlockHeight))
	}
	if m.TopicWeight != nil {
		l = m.TopicWeight.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func (m *TopicIdReputerReputerValueBundle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TopicId != 0 {
		n += 1 + sovGenesis(uint64(m.TopicId))
	}
	l = len(m.Reputer)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.ReputerValueBundle != nil {
		l = m.ReputerValueBundle.Size()
		n += 1 + l + sovGenesis(uint64(l))
	}
	return n
}

func sovGenesis(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenesis(x uint64) (n int) {
	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GenesisState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CoreTeamAddresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CoreTeamAddresses = append(m.CoreTeamAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextTopicId", wireType)
			}
			m.NextTopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextTopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Topics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Topics = append(m.Topics, &TopicIdAndTopic{})
			if err := m.Topics[len(m.Topics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ActiveTopics = append(m.ActiveTopics, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthGenesis
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthGenesis
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ActiveTopics) == 0 {
					m.ActiveTopics = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenesis
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ActiveTopics = append(m.ActiveTopics, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveTopics", wireType)
			}
		case 6:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RewardableTopics = append(m.RewardableTopics, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthGenesis
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthGenesis
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RewardableTopics) == 0 {
					m.RewardableTopics = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenesis
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RewardableTopics = append(m.RewardableTopics, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardableTopics", wireType)
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicWorkers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicWorkers = append(m.TopicWorkers, &TopicAndActorId{})
			if err := m.TopicWorkers[len(m.TopicWorkers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicReputers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicReputers = append(m.TopicReputers, &TopicAndActorId{})
			if err := m.TopicReputers[len(m.TopicReputers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicRewardNonce", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicRewardNonce = append(m.TopicRewardNonce, &TopicIdAndBlockHeight{})
			if err := m.TopicRewardNonce[len(m.TopicRewardNonce)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfererScoresByBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InfererScoresByBlock = append(m.InfererScoresByBlock, &TopicIdBlockHeightScores{})
			if err := m.InfererScoresByBlock[len(m.InfererScoresByBlock)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForecasterScoresByBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ForecasterScoresByBlock = append(m.ForecasterScoresByBlock, &TopicIdBlockHeightScores{})
			if err := m.ForecasterScoresByBlock[len(m.ForecasterScoresByBlock)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReputerScoresByBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReputerScoresByBlock = append(m.ReputerScoresByBlock, &TopicIdBlockHeightScores{})
			if err := m.ReputerScoresByBlock[len(m.ReputerScoresByBlock)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReputerListeningCoefficient", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReputerListeningCoefficient = append(m.ReputerListeningCoefficient, &TopicIdActorIdListeningCoefficient{})
			if err := m.ReputerListeningCoefficient[len(m.ReputerListeningCoefficient)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousReputerRewardFraction", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousReputerRewardFraction = append(m.PreviousReputerRewardFraction, &TopicIdActorIdDec{})
			if err := m.PreviousReputerRewardFraction[len(m.PreviousReputerRewardFraction)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousInferenceRewardFraction", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousInferenceRewardFraction = append(m.PreviousInferenceRewardFraction, &TopicIdActorIdDec{})
			if err := m.PreviousInferenceRewardFraction[len(m.PreviousInferenceRewardFraction)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousForecastRewardFraction", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousForecastRewardFraction = append(m.PreviousForecastRewardFraction, &TopicIdActorIdDec{})
			if err := m.PreviousForecastRewardFraction[len(m.PreviousForecastRewardFraction)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousForecasterScoreRatio", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousForecasterScoreRatio = append(m.PreviousForecasterScoreRatio, &TopicIdAndDec{})
			if err := m.PreviousForecasterScoreRatio[len(m.PreviousForecasterScoreRatio)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalStake", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalStake.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicStake", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicStake = append(m.TopicStake, &TopicIdAndInt{})
			if err := m.TopicStake[len(m.TopicStake)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeReputerAuthority", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakeReputerAuthority = append(m.StakeReputerAuthority, &TopicIdActorIdInt{})
			if err := m.StakeReputerAuthority[len(m.StakeReputerAuthority)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeSumFromDelegator", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakeSumFromDelegator = append(m.StakeSumFromDelegator, &TopicIdActorIdInt{})
			if err := m.StakeSumFromDelegator[len(m.StakeSumFromDelegator)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatedStakes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DelegatedStakes = append(m.DelegatedStakes, &TopicIdDelegatorReputerDelegatorInfo{})
			if err := m.DelegatedStakes[len(m.DelegatedStakes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeFromDelegatorsUponReputer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakeFromDelegatorsUponReputer = append(m.StakeFromDelegatorsUponReputer, &TopicIdActorIdInt{})
			if err := m.StakeFromDelegatorsUponReputer[len(m.StakeFromDelegatorsUponReputer)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateRewardPerShare", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DelegateRewardPerShare = append(m.DelegateRewardPerShare, &TopicIdActorIdDec{})
			if err := m.DelegateRewardPerShare[len(m.DelegateRewardPerShare)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeRemovalsByBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakeRemovalsByBlock = append(m.StakeRemovalsByBlock, &BlockHeightTopicIdReputerStakeRemovalInfo{})
			if err := m.StakeRemovalsByBlock[len(m.StakeRemovalsByBlock)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeRemovalsByActor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakeRemovalsByActor = append(m.StakeRemovalsByActor, &ActorIdTopicIdBlockHeight{})
			if err := m.StakeRemovalsByActor[len(m.StakeRemovalsByActor)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateStakeRemovalsByBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DelegateStakeRemovalsByBlock = append(m.DelegateStakeRemovalsByBlock, &BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo{})
			if err := m.DelegateStakeRemovalsByBlock[len(m.DelegateStakeRemovalsByBlock)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateStakeRemovalsByActor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DelegateStakeRemovalsByActor = append(m.DelegateStakeRemovalsByActor, &DelegatorReputerTopicIdBlockHeight{})
			if err := m.DelegateStakeRemovalsByActor[len(m.DelegateStakeRemovalsByActor)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 32:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Inferences = append(m.Inferences, &TopicIdActorIdInference{})
			if err := m.Inferences[len(m.Inferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Forecasts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Forecasts = append(m.Forecasts, &TopicIdActorIdForecast{})
			if err := m.Forecasts[len(m.Forecasts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Workers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Workers = append(m.Workers, &LibP2PKeyAndOffchainNode{})
			if err := m.Workers[len(m.Workers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 35:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputers = append(m.Reputers, &LibP2PKeyAndOffchainNode{})
			if err := m.Reputers[len(m.Reputers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 36:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicFeeRevenue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicFeeRevenue = append(m.TopicFeeRevenue, &TopicIdAndInt{})
			if err := m.TopicFeeRevenue[len(m.TopicFeeRevenue)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 37:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousTopicWeight", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousTopicWeight = append(m.PreviousTopicWeight, &TopicIdAndDec{})
			if err := m.PreviousTopicWeight[len(m.PreviousTopicWeight)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 38:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllInferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AllInferences = append(m.AllInferences, &TopicIdBlockHeightInferences{})
			if err := m.AllInferences[len(m.AllInferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 39:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllForecasts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AllForecasts = append(m.AllForecasts, &TopicIdBlockHeightForecasts{})
			if err := m.AllForecasts[len(m.AllForecasts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 40:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllLossBundles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AllLossBundles = append(m.AllLossBundles, &TopicIdBlockHeightReputerValueBundles{})
			if err := m.AllLossBundles[len(m.AllLossBundles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 41:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkLossBundles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NetworkLossBundles = append(m.NetworkLossBundles, &TopicIdBlockHeightValueBundles{})
			if err := m.NetworkLossBundles[len(m.NetworkLossBundles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 42:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousPercentageRewardToStakedReputers", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PreviousPercentageRewardToStakedReputers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 43:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnfulfilledWorkerNonces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnfulfilledWorkerNonces = append(m.UnfulfilledWorkerNonces, &TopicIdAndNonces{})
			if err := m.UnfulfilledWorkerNonces[len(m.UnfulfilledWorkerNonces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 44:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnfulfilledReputerNonces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnfulfilledReputerNonces = append(m.UnfulfilledReputerNonces, &TopicIdAndReputerRequestNonces{})
			if err := m.UnfulfilledReputerNonces[len(m.UnfulfilledReputerNonces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 45:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestInfererNetworkRegrets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestInfererNetworkRegrets = append(m.LatestInfererNetworkRegrets, &TopicIdActorIdTimeStampedValue{})
			if err := m.LatestInfererNetworkRegrets[len(m.LatestInfererNetworkRegrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 46:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestForecasterNetworkRegrets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestForecasterNetworkRegrets = append(m.LatestForecasterNetworkRegrets, &TopicIdActorIdTimeStampedValue{})
			if err := m.LatestForecasterNetworkRegrets[len(m.LatestForecasterNetworkRegrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 47:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestOneInForecasterNetworkRegrets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestOneInForecasterNetworkRegrets = append(m.LatestOneInForecasterNetworkRegrets, &TopicIdActorIdActorIdTimeStampedValue{})
			if err := m.LatestOneInForecasterNetworkRegrets[len(m.LatestOneInForecasterNetworkRegrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 48:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestNaiveInfererNetworkRegrets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestNaiveInfererNetworkRegrets = append(m.LatestNaiveInfererNetworkRegrets, &TopicIdActorIdTimeStampedValue{})
			if err := m.LatestNaiveInfererNetworkRegrets[len(m.LatestNaiveInfererNetworkRegrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 49:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestOneOutInfererInfererNetworkRegrets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestOneOutInfererInfererNetworkRegrets = append(m.LatestOneOutInfererInfererNetworkRegrets, &TopicIdActorIdActorIdTimeStampedValue{})
			if err := m.LatestOneOutInfererInfererNetworkRegrets[len(m.LatestOneOutInfererInfererNetworkRegrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 50:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestOneOutInfererForecasterNetworkRegrets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestOneOutInfererForecasterNetworkRegrets = append(m.LatestOneOutInfererForecasterNetworkRegrets, &TopicIdActorIdActorIdTimeStampedValue{})
			if err := m.LatestOneOutInfererForecasterNetworkRegrets[len(m.LatestOneOutInfererForecasterNetworkRegrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 51:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestOneOutForecasterInfererNetworkRegrets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestOneOutForecasterInfererNetworkRegrets = append(m.LatestOneOutForecasterInfererNetworkRegrets, &TopicIdActorIdActorIdTimeStampedValue{})
			if err := m.LatestOneOutForecasterInfererNetworkRegrets[len(m.LatestOneOutForecasterInfererNetworkRegrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 52:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestOneOutForecasterForecasterNetworkRegrets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestOneOutForecasterForecasterNetworkRegrets = append(m.LatestOneOutForecasterForecasterNetworkRegrets, &TopicIdActorIdActorIdTimeStampedValue{})
			if err := m.LatestOneOutForecasterForecasterNetworkRegrets[len(m.LatestOneOutForecasterForecasterNetworkRegrets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 53:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicLastWorkerCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicLastWorkerCommit = append(m.TopicLastWorkerCommit, &TopicIdTimestampedActorNonce{})
			if err := m.TopicLastWorkerCommit[len(m.TopicLastWorkerCommit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 54:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicLastReputerCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicLastReputerCommit = append(m.TopicLastReputerCommit, &TopicIdTimestampedActorNonce{})
			if err := m.TopicLastReputerCommit[len(m.TopicLastReputerCommit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 55:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OpenWorkerWindows", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OpenWorkerWindows = append(m.OpenWorkerWindows, &BlockHeightAndTopicIds{})
			if err := m.OpenWorkerWindows[len(m.OpenWorkerWindows)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 56:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastDripBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastDripBlock = append(m.LastDripBlock, &TopicIdAndBlockHeight{})
			if err := m.LastDripBlock[len(m.LastDripBlock)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 57:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicToNextPossibleChurningBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicToNextPossibleChurningBlock = append(m.TopicToNextPossibleChurningBlock, &TopicIdAndBlockHeight{})
			if err := m.TopicToNextPossibleChurningBlock[len(m.TopicToNextPossibleChurningBlock)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 58:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockToActiveTopics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockToActiveTopics = append(m.BlockToActiveTopics, &BlockHeightTopicIds{})
			if err := m.BlockToActiveTopics[len(m.BlockToActiveTopics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 59:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockToLowestActiveTopicWeight", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockToLowestActiveTopicWeight = append(m.BlockToLowestActiveTopicWeight, &BlockHeightTopicIdWeightPair{})
			if err := m.BlockToLowestActiveTopicWeight[len(m.BlockToLowestActiveTopicWeight)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 60:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InfererScoreEmas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InfererScoreEmas = append(m.InfererScoreEmas, &TopicIdActorIdScore{})
			if err := m.InfererScoreEmas[len(m.InfererScoreEmas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 61:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForecasterScoreEmas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ForecasterScoreEmas = append(m.ForecasterScoreEmas, &TopicIdActorIdScore{})
			if err := m.ForecasterScoreEmas[len(m.ForecasterScoreEmas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 62:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReputerScoreEmas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReputerScoreEmas = append(m.ReputerScoreEmas, &TopicIdActorIdScore{})
			if err := m.ReputerScoreEmas[len(m.ReputerScoreEmas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 63:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousTopicQuantileInfererScoreEma", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousTopicQuantileInfererScoreEma = append(m.PreviousTopicQuantileInfererScoreEma, &TopicIdAndDec{})
			if err := m.PreviousTopicQuantileInfererScoreEma[len(m.PreviousTopicQuantileInfererScoreEma)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 64:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousTopicQuantileForecasterScoreEma", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousTopicQuantileForecasterScoreEma = append(m.PreviousTopicQuantileForecasterScoreEma, &TopicIdAndDec{})
			if err := m.PreviousTopicQuantileForecasterScoreEma[len(m.PreviousTopicQuantileForecasterScoreEma)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 65:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousTopicQuantileReputerScoreEma", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousTopicQuantileReputerScoreEma = append(m.PreviousTopicQuantileReputerScoreEma, &TopicIdAndDec{})
			if err := m.PreviousTopicQuantileReputerScoreEma[len(m.PreviousTopicQuantileReputerScoreEma)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 66:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CountInfererInclusionsInTopicActiveSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CountInfererInclusionsInTopicActiveSet = append(m.CountInfererInclusionsInTopicActiveSet, &TopicIdActorIdUint64{})
			if err := m.CountInfererInclusionsInTopicActiveSet[len(m.CountInfererInclusionsInTopicActiveSet)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 67:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CountForecasterInclusionsInTopicActiveSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CountForecasterInclusionsInTopicActiveSet = append(m.CountForecasterInclusionsInTopicActiveSet, &TopicIdActorIdUint64{})
			if err := m.CountForecasterInclusionsInTopicActiveSet[len(m.CountForecasterInclusionsInTopicActiveSet)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 68:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveInferers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActiveInferers = append(m.ActiveInferers, &TopicAndActorId{})
			if err := m.ActiveInferers[len(m.ActiveInferers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 69:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveForecasters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActiveForecasters = append(m.ActiveForecasters, &TopicAndActorId{})
			if err := m.ActiveForecasters[len(m.ActiveForecasters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 70:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LowestInfererScoreEma", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LowestInfererScoreEma = append(m.LowestInfererScoreEma, &TopicIdActorIdScore{})
			if err := m.LowestInfererScoreEma[len(m.LowestInfererScoreEma)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 71:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LowestForecasterScoreEma", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LowestForecasterScoreEma = append(m.LowestForecasterScoreEma, &TopicIdActorIdScore{})
			if err := m.LowestForecasterScoreEma[len(m.LowestForecasterScoreEma)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 72:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveReputers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActiveReputers = append(m.ActiveReputers, &TopicAndActorId{})
			if err := m.ActiveReputers[len(m.ActiveReputers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 73:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LowestReputerScoreEma", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LowestReputerScoreEma = append(m.LowestReputerScoreEma, &TopicIdActorIdScore{})
			if err := m.LowestReputerScoreEma[len(m.LowestReputerScoreEma)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 74:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LossBundles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LossBundles = append(m.LossBundles, &TopicIdReputerReputerValueBundle{})
			if err := m.LossBundles[len(m.LossBundles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 75:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalSumPreviousTopicWeights", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalSumPreviousTopicWeights.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 76:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardCurrentBlockEmission", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RewardCurrentBlockEmission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 77:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WhitelistAdmins", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WhitelistAdmins = append(m.WhitelistAdmins, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 78:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalWhitelist", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GlobalWhitelist = append(m.GlobalWhitelist, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 79:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicCreatorWhitelist", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicCreatorWhitelist = append(m.TopicCreatorWhitelist, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 80:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicWorkerWhitelist", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicWorkerWhitelist = append(m.TopicWorkerWhitelist, &TopicAndActorId{})
			if err := m.TopicWorkerWhitelist[len(m.TopicWorkerWhitelist)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 81:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicReputerWhitelist", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicReputerWhitelist = append(m.TopicReputerWhitelist, &TopicAndActorId{})
			if err := m.TopicReputerWhitelist[len(m.TopicReputerWhitelist)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 82:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.TopicWorkerWhitelistEnabled = append(m.TopicWorkerWhitelistEnabled, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthGenesis
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthGenesis
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.TopicWorkerWhitelistEnabled) == 0 {
					m.TopicWorkerWhitelistEnabled = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenesis
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.TopicWorkerWhitelistEnabled = append(m.TopicWorkerWhitelistEnabled, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicWorkerWhitelistEnabled", wireType)
			}
		case 83:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.TopicReputerWhitelistEnabled = append(m.TopicReputerWhitelistEnabled, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthGenesis
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthGenesis
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.TopicReputerWhitelistEnabled) == 0 {
					m.TopicReputerWhitelistEnabled = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenesis
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.TopicReputerWhitelistEnabled = append(m.TopicReputerWhitelistEnabled, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicReputerWhitelistEnabled", wireType)
			}
		case 84:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastMedianInferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LastMedianInferences = append(m.LastMedianInferences, &TopicIdAndDec{})
			if err := m.LastMedianInferences[len(m.LastMedianInferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 85:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MadInferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MadInferences = append(m.MadInferences, &TopicIdAndDec{})
			if err := m.MadInferences[len(m.MadInferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 86:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialInfererEmaScore", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InitialInfererEmaScore = append(m.InitialInfererEmaScore, &TopicIdAndDec{})
			if err := m.InitialInfererEmaScore[len(m.InitialInfererEmaScore)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 87:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialForecasterEmaScore", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InitialForecasterEmaScore = append(m.InitialForecasterEmaScore, &TopicIdAndDec{})
			if err := m.InitialForecasterEmaScore[len(m.InitialForecasterEmaScore)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 88:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialReputerEmaScore", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InitialReputerEmaScore = append(m.InitialReputerEmaScore, &TopicIdAndDec{})
			if err := m.InitialReputerEmaScore[len(m.InitialReputerEmaScore)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 89:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalWorkerWhitelist", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GlobalWorkerWhitelist = append(m.GlobalWorkerWhitelist, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 90:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalReputerWhitelist", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GlobalReputerWhitelist = append(m.GlobalReputerWhitelist, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 91:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalAdminWhitelist", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GlobalAdminWhitelist = append(m.GlobalAdminWhitelist, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 92:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestRegretStdNorm", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestRegretStdNorm = append(m.LatestRegretStdNorm, &TopicIdAndDec{})
			if err := m.LatestRegretStdNorm[len(m.LatestRegretStdNorm)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 93:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestInfererWeights", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestInfererWeights = append(m.LatestInfererWeights, &TopicIdActorIdDec{})
			if err := m.LatestInfererWeights[len(m.LatestInfererWeights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 94:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestForecasterWeights", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestForecasterWeights = append(m.LatestForecasterWeights, &TopicIdActorIdDec{})
			if err := m.LatestForecasterWeights[len(m.LatestForecasterWeights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 95:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkInferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NetworkInferences = append(m.NetworkInferences, &TopicIdBlockHeightValueBundles{})
			if err := m.NetworkInferences[len(m.NetworkInferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 96:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutlierResistantNetworkInferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutlierResistantNetworkInferences = append(m.OutlierResistantNetworkInferences, &TopicIdBlockHeightValueBundles{})
			if err := m.OutlierResistantNetworkInferences[len(m.OutlierResistantNetworkInferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 97:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MonthlyReputerRewards", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MonthlyReputerRewards.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 98:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MonthlyTopicRewards", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MonthlyTopicRewards.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdAndTopic) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdAndTopic: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdAndTopic: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Topic == nil {
				m.Topic = &Topic{}
			}
			if err := m.Topic.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicAndActorId) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicAndActorId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicAndActorId: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdAndBlockHeight) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdAndBlockHeight: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdAndBlockHeight: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockHeightAndTopicIds) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockHeightAndTopicIds: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockHeightAndTopicIds: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.TopicIds = append(m.TopicIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenesis
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthGenesis
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthGenesis
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.TopicIds) == 0 {
					m.TopicIds = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenesis
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.TopicIds = append(m.TopicIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicIds", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdBlockHeightScores) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdBlockHeightScores: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdBlockHeightScores: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scores", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Scores == nil {
				m.Scores = &Scores{}
			}
			if err := m.Scores.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdActorIdScore) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdActorIdScore: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdActorIdScore: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Score == nil {
				m.Score = &Score{}
			}
			if err := m.Score.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdActorIdUint64) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdActorIdUint64: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdActorIdUint64: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint64", wireType)
			}
			m.Uint64 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uint64 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdActorIdListeningCoefficient) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdActorIdListeningCoefficient: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdActorIdListeningCoefficient: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListeningCoefficient", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ListeningCoefficient == nil {
				m.ListeningCoefficient = &ListeningCoefficient{}
			}
			if err := m.ListeningCoefficient.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdActorIdDec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdActorIdDec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdActorIdDec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dec", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Dec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdAndInt) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdAndInt: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdAndInt: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Int.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdActorIdInt) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdActorIdInt: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdActorIdInt: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Int.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdDelegatorReputerDelegatorInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdDelegatorReputerDelegatorInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdDelegatorReputerDelegatorInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DelegatorInfo == nil {
				m.DelegatorInfo = &DelegatorInfo{}
			}
			if err := m.DelegatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockHeightTopicIdReputerStakeRemovalInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockHeightTopicIdReputerStakeRemovalInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockHeightTopicIdReputerStakeRemovalInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeRemovalInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StakeRemovalInfo == nil {
				m.StakeRemovalInfo = &StakeRemovalInfo{}
			}
			if err := m.StakeRemovalInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ActorIdTopicIdBlockHeight) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ActorIdTopicIdBlockHeight: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ActorIdTopicIdBlockHeight: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockHeightTopicIdDelegatorReputerDelegateStakeRemovalInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateStakeRemovalInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DelegateStakeRemovalInfo == nil {
				m.DelegateStakeRemovalInfo = &DelegateStakeRemovalInfo{}
			}
			if err := m.DelegateStakeRemovalInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegatorReputerTopicIdBlockHeight) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DelegatorReputerTopicIdBlockHeight: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegatorReputerTopicIdBlockHeight: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdActorIdInference) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdActorIdInference: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdActorIdInference: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inference", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Inference == nil {
				m.Inference = &Inference{}
			}
			if err := m.Inference.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdActorIdForecast) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdActorIdForecast: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdActorIdForecast: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Forecast", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Forecast == nil {
				m.Forecast = &Forecast{}
			}
			if err := m.Forecast.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LibP2PKeyAndOffchainNode) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LibP2pKeyAndOffchainNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LibP2pKeyAndOffchainNode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LibP2PKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LibP2PKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OffchainNode", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OffchainNode == nil {
				m.OffchainNode = &OffchainNode{}
			}
			if err := m.OffchainNode.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdAndDec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdAndDec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdAndDec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dec", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Dec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdBlockHeightInferences) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdBlockHeightInferences: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdBlockHeightInferences: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Inferences == nil {
				m.Inferences = &Inferences{}
			}
			if err := m.Inferences.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdBlockHeightForecasts) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdBlockHeightForecasts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdBlockHeightForecasts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Forecasts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Forecasts == nil {
				m.Forecasts = &Forecasts{}
			}
			if err := m.Forecasts.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdBlockHeightReputerValueBundles) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdBlockHeightReputerValueBundles: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdBlockHeightReputerValueBundles: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReputerValueBundles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReputerValueBundles == nil {
				m.ReputerValueBundles = &ReputerValueBundles{}
			}
			if err := m.ReputerValueBundles.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdBlockHeightValueBundles) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdBlockHeightValueBundles: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdBlockHeightValueBundles: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueBundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValueBundle == nil {
				m.ValueBundle = &ValueBundle{}
			}
			if err := m.ValueBundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdAndNonces) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdAndNonces: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdAndNonces: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Nonces == nil {
				m.Nonces = &Nonces{}
			}
			if err := m.Nonces.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdAndReputerRequestNonces) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdAndReputerRequestNonces: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdAndReputerRequestNonces: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReputerRequestNonces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReputerRequestNonces == nil {
				m.ReputerRequestNonces = &ReputerRequestNonces{}
			}
			if err := m.ReputerRequestNonces.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdActorIdTimeStampedValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdActorIdTimeStampedValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdActorIdTimeStampedValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimestampedValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimestampedValue == nil {
				m.TimestampedValue = &TimestampedValue{}
			}
			if err := m.TimestampedValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdActorIdActorIdTimeStampedValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdActorIdActorIdTimeStampedValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdActorIdActorIdTimeStampedValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId1", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId1 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActorId2", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActorId2 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimestampedValue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimestampedValue == nil {
				m.TimestampedValue = &TimestampedValue{}
			}
			if err := m.TimestampedValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdTimestampedActorNonce) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdTimestampedActorNonce: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdTimestampedActorNonce: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimestampedActorNonce", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimestampedActorNonce == nil {
				m.TimestampedActorNonce = &TimestampedActorNonce{}
			}
			if err := m.TimestampedActorNonce.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockHeightTopicIds) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockHeightTopicIds: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockHeightTopicIds: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicIds", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TopicIds == nil {
				m.TopicIds = &TopicIds{}
			}
			if err := m.TopicIds.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockHeightTopicIdWeightPair) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockHeightTopicIdWeightPair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockHeightTopicIdWeightPair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
			}
			m.BlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockHeight |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicWeight", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TopicWeight == nil {
				m.TopicWeight = &TopicIdWeightPair{}
			}
			if err := m.TopicWeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicIdReputerReputerValueBundle) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TopicIdReputerReputerValueBundle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicIdReputerReputerValueBundle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicId", wireType)
			}
			m.TopicId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reputer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReputerValueBundle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReputerValueBundle == nil {
				m.ReputerValueBundle = &ReputerValueBundle{}
			}
			if err := m.ReputerValueBundle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGenesis(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowGenesis
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthGenesis
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGenesis
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGenesis
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)
