// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: emissions/v3/params.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

// Params defines the parameters of the module.
type Params struct {
	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// github release tag version
	MaxSerializedMsgLength int64                                           `protobuf:"varint,2,opt,name=max_serialized_msg_length,json=maxSerializedMsgLength,proto3" json:"max_serialized_msg_length,omitempty"`
	MinTopicWeight         github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,3,opt,name=min_topic_weight,json=minTopicWeight,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"min_topic_weight"`
	// solicatation or weight-adjustment
	RequiredMinimumStake   cosmossdk_io_math.Int `protobuf:"bytes,5,opt,name=required_minimum_stake,json=requiredMinimumStake,proto3,customtype=cosmossdk.io/math.Int" json:"required_minimum_stake"`
	RemoveStakeDelayWindow int64                 `protobuf:"varint,6,opt,name=remove_stake_delay_window,json=removeStakeDelayWindow,proto3" json:"remove_stake_delay_window,omitempty"`
	MinEpochLength         int64                 `protobuf:"varint,7,opt,name=min_epoch_length,json=minEpochLength,proto3" json:"min_epoch_length,omitempty"`
	// repeating inference request
	BetaEntropy          github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,8,opt,name=beta_entropy,json=betaEntropy,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"beta_entropy"`
	LearningRate         github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,9,opt,name=learning_rate,json=learningRate,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"learning_rate"`
	MaxGradientThreshold github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,10,opt,name=max_gradient_threshold,json=maxGradientThreshold,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"max_gradient_threshold"`
	MinStakeFraction     github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,11,opt,name=min_stake_fraction,json=minStakeFraction,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"min_stake_fraction"`
	// coefficients
	MaxUnfulfilledWorkerRequests  uint64                                          `protobuf:"varint,13,opt,name=max_unfulfilled_worker_requests,json=maxUnfulfilledWorkerRequests,proto3" json:"max_unfulfilled_worker_requests,omitempty"`
	MaxUnfulfilledReputerRequests uint64                                          `protobuf:"varint,14,opt,name=max_unfulfilled_reputer_requests,json=maxUnfulfilledReputerRequests,proto3" json:"max_unfulfilled_reputer_requests,omitempty"`
	TopicRewardStakeImportance    github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,15,opt,name=topic_reward_stake_importance,json=topicRewardStakeImportance,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"topic_reward_stake_importance"`
	// topic and has a fiducial value of 0.5
	TopicRewardFeeRevenueImportance github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,16,opt,name=topic_reward_fee_revenue_importance,json=topicRewardFeeRevenueImportance,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"topic_reward_fee_revenue_importance"`
	// a topic and has a fiducial value of 0.5
	TopicRewardAlpha github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,17,opt,name=topic_reward_alpha,json=topicRewardAlpha,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"topic_reward_alpha"`
	// a monthly timescale, 0.5 for weekly updates
	TaskRewardAlpha github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,18,opt,name=task_reward_alpha,json=taskRewardAlpha,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"task_reward_alpha"`
	// to calculate ~U_ij, ~V_ik, ~W_im
	ValidatorsVsAlloraPercentReward github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,19,opt,name=validators_vs_allora_percent_reward,json=validatorsVsAlloraPercentReward,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"validators_vs_allora_percent_reward"`
	// to allora reputers workers etc
	MaxSamplesToScaleScores   uint64                `protobuf:"varint,20,opt,name=max_samples_to_scale_scores,json=maxSamplesToScaleScores,proto3" json:"max_samples_to_scale_scores,omitempty"`
	MaxTopInferersToReward    uint64                `protobuf:"varint,21,opt,name=max_top_inferers_to_reward,json=maxTopInferersToReward,proto3" json:"max_top_inferers_to_reward,omitempty"`
	MaxTopForecastersToReward uint64                `protobuf:"varint,22,opt,name=max_top_forecasters_to_reward,json=maxTopForecastersToReward,proto3" json:"max_top_forecasters_to_reward,omitempty"`
	MaxTopReputersToReward    uint64                `protobuf:"varint,23,opt,name=max_top_reputers_to_reward,json=maxTopReputersToReward,proto3" json:"max_top_reputers_to_reward,omitempty"`
	CreateTopicFee            cosmossdk_io_math.Int `protobuf:"bytes,24,opt,name=create_topic_fee,json=createTopicFee,proto3,customtype=cosmossdk.io/math.Int" json:"create_topic_fee"`
	GradientDescentMaxIters   uint64                `protobuf:"varint,25,opt,name=gradient_descent_max_iters,json=gradientDescentMaxIters,proto3" json:"gradient_descent_max_iters,omitempty"`
	RegistrationFee           cosmossdk_io_math.Int `protobuf:"bytes,28,opt,name=registration_fee,json=registrationFee,proto3,customtype=cosmossdk.io/math.Int" json:"registration_fee"`
	DefaultPageLimit          uint64                `protobuf:"varint,29,opt,name=default_page_limit,json=defaultPageLimit,proto3" json:"default_page_limit,omitempty"`
	MaxPageLimit              uint64                `protobuf:"varint,30,opt,name=max_page_limit,json=maxPageLimit,proto3" json:"max_page_limit,omitempty"`
	// min number of epochs to keep network losses, reputer losses, inferences,
	// forecasts
	MinEpochLengthRecordLimit int64 `protobuf:"varint,31,opt,name=min_epoch_length_record_limit,json=minEpochLengthRecordLimit,proto3" json:"min_epoch_length_record_limit,omitempty"`
	// block emission rate in number of blocks expected per month
	BlocksPerMonth   uint64                                          `protobuf:"varint,32,opt,name=blocks_per_month,json=blocksPerMonth,proto3" json:"blocks_per_month,omitempty"`
	PRewardInference github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,33,opt,name=p_reward_inference,json=pRewardInference,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_reward_inference"`
	PRewardForecast  github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,34,opt,name=p_reward_forecast,json=pRewardForecast,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_reward_forecast"`
	PRewardReputer   github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,35,opt,name=p_reward_reputer,json=pRewardReputer,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_reward_reputer"`
	CRewardInference github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,36,opt,name=c_reward_inference,json=cRewardInference,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"c_reward_inference"`
	CRewardForecast  github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,37,opt,name=c_reward_forecast,json=cRewardForecast,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"c_reward_forecast"`
	CNorm            github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,38,opt,name=c_norm,json=cNorm,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"c_norm"`
	EpsilonReputer   github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,40,opt,name=epsilon_reputer,json=epsilonReputer,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"epsilon_reputer"`
	// close proximities
	HalfMaxProcessStakeRemovalsEndBlock uint64 `protobuf:"varint,42,opt,name=half_max_process_stake_removals_end_block,json=halfMaxProcessStakeRemovalsEndBlock,proto3" json:"half_max_process_stake_removals_end_block,omitempty"`
	// Applied twice once for stakeRemovals and once for
	// DelegateStakeRemovals, so actual max is this number times two
	EpsilonSafeDiv github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,43,opt,name=epsilon_safe_div,json=epsilonSafeDiv,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"epsilon_safe_div"`
	/// a small tolerance quantity used to cap division by zero
	DataSendingFee cosmossdk_io_math.Int `protobuf:"bytes,44,opt,name=data_sending_fee,json=dataSendingFee,proto3,customtype=cosmossdk.io/math.Int" json:"data_sending_fee"`
	// payload sending fee for reputer or worker
	MaxElementsPerForecast  uint64 `protobuf:"varint,45,opt,name=max_elements_per_forecast,json=maxElementsPerForecast,proto3" json:"max_elements_per_forecast,omitempty"`
	MaxActiveTopicsPerBlock uint64 `protobuf:"varint,46,opt,name=max_active_topics_per_block,json=maxActiveTopicsPerBlock,proto3" json:"max_active_topics_per_block,omitempty"`
}

func (m *Params) Reset()         { *m = Params{} }
func (m *Params) String() string { return proto.CompactTextString(m) }
func (*Params) ProtoMessage()    {}
func (*Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_3cdb117de9d25c4f, []int{0}
}
func (m *Params) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Params.Merge(m, src)
}
func (m *Params) XXX_Size() int {
	return m.Size()
}
func (m *Params) XXX_DiscardUnknown() {
	xxx_messageInfo_Params.DiscardUnknown(m)
}

var xxx_messageInfo_Params proto.InternalMessageInfo

func (m *Params) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *Params) GetMaxSerializedMsgLength() int64 {
	if m != nil {
		return m.MaxSerializedMsgLength
	}
	return 0
}

func (m *Params) GetRemoveStakeDelayWindow() int64 {
	if m != nil {
		return m.RemoveStakeDelayWindow
	}
	return 0
}

func (m *Params) GetMinEpochLength() int64 {
	if m != nil {
		return m.MinEpochLength
	}
	return 0
}

func (m *Params) GetMaxUnfulfilledWorkerRequests() uint64 {
	if m != nil {
		return m.MaxUnfulfilledWorkerRequests
	}
	return 0
}

func (m *Params) GetMaxUnfulfilledReputerRequests() uint64 {
	if m != nil {
		return m.MaxUnfulfilledReputerRequests
	}
	return 0
}

func (m *Params) GetMaxSamplesToScaleScores() uint64 {
	if m != nil {
		return m.MaxSamplesToScaleScores
	}
	return 0
}

func (m *Params) GetMaxTopInferersToReward() uint64 {
	if m != nil {
		return m.MaxTopInferersToReward
	}
	return 0
}

func (m *Params) GetMaxTopForecastersToReward() uint64 {
	if m != nil {
		return m.MaxTopForecastersToReward
	}
	return 0
}

func (m *Params) GetMaxTopReputersToReward() uint64 {
	if m != nil {
		return m.MaxTopReputersToReward
	}
	return 0
}

func (m *Params) GetGradientDescentMaxIters() uint64 {
	if m != nil {
		return m.GradientDescentMaxIters
	}
	return 0
}

func (m *Params) GetDefaultPageLimit() uint64 {
	if m != nil {
		return m.DefaultPageLimit
	}
	return 0
}

func (m *Params) GetMaxPageLimit() uint64 {
	if m != nil {
		return m.MaxPageLimit
	}
	return 0
}

func (m *Params) GetMinEpochLengthRecordLimit() int64 {
	if m != nil {
		return m.MinEpochLengthRecordLimit
	}
	return 0
}

func (m *Params) GetBlocksPerMonth() uint64 {
	if m != nil {
		return m.BlocksPerMonth
	}
	return 0
}

func (m *Params) GetHalfMaxProcessStakeRemovalsEndBlock() uint64 {
	if m != nil {
		return m.HalfMaxProcessStakeRemovalsEndBlock
	}
	return 0
}

func (m *Params) GetMaxElementsPerForecast() uint64 {
	if m != nil {
		return m.MaxElementsPerForecast
	}
	return 0
}

func (m *Params) GetMaxActiveTopicsPerBlock() uint64 {
	if m != nil {
		return m.MaxActiveTopicsPerBlock
	}
	return 0
}

func init() {
	proto.RegisterType((*Params)(nil), "emissions.v3.Params")
}

func init() { proto.RegisterFile("emissions/v3/params.proto", fileDescriptor_3cdb117de9d25c4f) }

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

func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MaxActiveTopicsPerBlock != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxActiveTopicsPerBlock))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xf0
	}
	if m.MaxElementsPerForecast != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxElementsPerForecast))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xe8
	}
	{
		size := m.DataSendingFee.Size()
		i -= size
		if _, err := m.DataSendingFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0xe2
	{
		size := m.EpsilonSafeDiv.Size()
		i -= size
		if _, err := m.EpsilonSafeDiv.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0xda
	if m.HalfMaxProcessStakeRemovalsEndBlock != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.HalfMaxProcessStakeRemovalsEndBlock))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd0
	}
	{
		size := m.EpsilonReputer.Size()
		i -= size
		if _, err := m.EpsilonReputer.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0xc2
	{
		size := m.CNorm.Size()
		i -= size
		if _, err := m.CNorm.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0xb2
	{
		size := m.CRewardForecast.Size()
		i -= size
		if _, err := m.CRewardForecast.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0xaa
	{
		size := m.CRewardInference.Size()
		i -= size
		if _, err := m.CRewardInference.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0xa2
	{
		size := m.PRewardReputer.Size()
		i -= size
		if _, err := m.PRewardReputer.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0x9a
	{
		size := m.PRewardForecast.Size()
		i -= size
		if _, err := m.PRewardForecast.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0x92
	{
		size := m.PRewardInference.Size()
		i -= size
		if _, err := m.PRewardInference.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0x8a
	if m.BlocksPerMonth != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.BlocksPerMonth))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x80
	}
	if m.MinEpochLengthRecordLimit != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MinEpochLengthRecordLimit))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf8
	}
	if m.MaxPageLimit != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxPageLimit))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf0
	}
	if m.DefaultPageLimit != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.DefaultPageLimit))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe8
	}
	{
		size := m.RegistrationFee.Size()
		i -= size
		if _, err := m.RegistrationFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xe2
	if m.GradientDescentMaxIters != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.GradientDescentMaxIters))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc8
	}
	{
		size := m.CreateTopicFee.Size()
		i -= size
		if _, err := m.CreateTopicFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xc2
	if m.MaxTopReputersToReward != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxTopReputersToReward))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb8
	}
	if m.MaxTopForecastersToReward != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxTopForecastersToReward))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb0
	}
	if m.MaxTopInferersToReward != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxTopInferersToReward))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa8
	}
	if m.MaxSamplesToScaleScores != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxSamplesToScaleScores))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	{
		size := m.ValidatorsVsAlloraPercentReward.Size()
		i -= size
		if _, err := m.ValidatorsVsAlloraPercentReward.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x9a
	{
		size := m.TaskRewardAlpha.Size()
		i -= size
		if _, err := m.TaskRewardAlpha.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	{
		size := m.TopicRewardAlpha.Size()
		i -= size
		if _, err := m.TopicRewardAlpha.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	{
		size := m.TopicRewardFeeRevenueImportance.Size()
		i -= size
		if _, err := m.TopicRewardFeeRevenueImportance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size := m.TopicRewardStakeImportance.Size()
		i -= size
		if _, err := m.TopicRewardStakeImportance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	if m.MaxUnfulfilledReputerRequests != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxUnfulfilledReputerRequests))
		i--
		dAtA[i] = 0x70
	}
	if m.MaxUnfulfilledWorkerRequests != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxUnfulfilledWorkerRequests))
		i--
		dAtA[i] = 0x68
	}
	{
		size := m.MinStakeFraction.Size()
		i -= size
		if _, err := m.MinStakeFraction.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	{
		size := m.MaxGradientThreshold.Size()
		i -= size
		if _, err := m.MaxGradientThreshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	{
		size := m.LearningRate.Size()
		i -= size
		if _, err := m.LearningRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	{
		size := m.BetaEntropy.Size()
		i -= size
		if _, err := m.BetaEntropy.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	if m.MinEpochLength != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MinEpochLength))
		i--
		dAtA[i] = 0x38
	}
	if m.RemoveStakeDelayWindow != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.RemoveStakeDelayWindow))
		i--
		dAtA[i] = 0x30
	}
	{
		size := m.RequiredMinimumStake.Size()
		i -= size
		if _, err := m.RequiredMinimumStake.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.MinTopicWeight.Size()
		i -= size
		if _, err := m.MinTopicWeight.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.MaxSerializedMsgLength != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxSerializedMsgLength))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintParams(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintParams(dAtA []byte, offset int, v uint64) int {
	offset -= sovParams(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovParams(uint64(l))
	}
	if m.MaxSerializedMsgLength != 0 {
		n += 1 + sovParams(uint64(m.MaxSerializedMsgLength))
	}
	l = m.MinTopicWeight.Size()
	n += 1 + l + sovParams(uint64(l))
	l = m.RequiredMinimumStake.Size()
	n += 1 + l + sovParams(uint64(l))
	if m.RemoveStakeDelayWindow != 0 {
		n += 1 + sovParams(uint64(m.RemoveStakeDelayWindow))
	}
	if m.MinEpochLength != 0 {
		n += 1 + sovParams(uint64(m.MinEpochLength))
	}
	l = m.BetaEntropy.Size()
	n += 1 + l + sovParams(uint64(l))
	l = m.LearningRate.Size()
	n += 1 + l + sovParams(uint64(l))
	l = m.MaxGradientThreshold.Size()
	n += 1 + l + sovParams(uint64(l))
	l = m.MinStakeFraction.Size()
	n += 1 + l + sovParams(uint64(l))
	if m.MaxUnfulfilledWorkerRequests != 0 {
		n += 1 + sovParams(uint64(m.MaxUnfulfilledWorkerRequests))
	}
	if m.MaxUnfulfilledReputerRequests != 0 {
		n += 1 + sovParams(uint64(m.MaxUnfulfilledReputerRequests))
	}
	l = m.TopicRewardStakeImportance.Size()
	n += 1 + l + sovParams(uint64(l))
	l = m.TopicRewardFeeRevenueImportance.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.TopicRewardAlpha.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.TaskRewardAlpha.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.ValidatorsVsAlloraPercentReward.Size()
	n += 2 + l + sovParams(uint64(l))
	if m.MaxSamplesToScaleScores != 0 {
		n += 2 + sovParams(uint64(m.MaxSamplesToScaleScores))
	}
	if m.MaxTopInferersToReward != 0 {
		n += 2 + sovParams(uint64(m.MaxTopInferersToReward))
	}
	if m.MaxTopForecastersToReward != 0 {
		n += 2 + sovParams(uint64(m.MaxTopForecastersToReward))
	}
	if m.MaxTopReputersToReward != 0 {
		n += 2 + sovParams(uint64(m.MaxTopReputersToReward))
	}
	l = m.CreateTopicFee.Size()
	n += 2 + l + sovParams(uint64(l))
	if m.GradientDescentMaxIters != 0 {
		n += 2 + sovParams(uint64(m.GradientDescentMaxIters))
	}
	l = m.RegistrationFee.Size()
	n += 2 + l + sovParams(uint64(l))
	if m.DefaultPageLimit != 0 {
		n += 2 + sovParams(uint64(m.DefaultPageLimit))
	}
	if m.MaxPageLimit != 0 {
		n += 2 + sovParams(uint64(m.MaxPageLimit))
	}
	if m.MinEpochLengthRecordLimit != 0 {
		n += 2 + sovParams(uint64(m.MinEpochLengthRecordLimit))
	}
	if m.BlocksPerMonth != 0 {
		n += 2 + sovParams(uint64(m.BlocksPerMonth))
	}
	l = m.PRewardInference.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.PRewardForecast.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.PRewardReputer.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.CRewardInference.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.CRewardForecast.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.CNorm.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.EpsilonReputer.Size()
	n += 2 + l + sovParams(uint64(l))
	if m.HalfMaxProcessStakeRemovalsEndBlock != 0 {
		n += 2 + sovParams(uint64(m.HalfMaxProcessStakeRemovalsEndBlock))
	}
	l = m.EpsilonSafeDiv.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.DataSendingFee.Size()
	n += 2 + l + sovParams(uint64(l))
	if m.MaxElementsPerForecast != 0 {
		n += 2 + sovParams(uint64(m.MaxElementsPerForecast))
	}
	if m.MaxActiveTopicsPerBlock != 0 {
		n += 2 + sovParams(uint64(m.MaxActiveTopicsPerBlock))
	}
	return n
}

func sovParams(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozParams(x uint64) (n int) {
	return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) 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 ErrIntOverflowParams
			}
			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: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSerializedMsgLength", wireType)
			}
			m.MaxSerializedMsgLength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxSerializedMsgLength |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinTopicWeight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinTopicWeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredMinimumStake", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RequiredMinimumStake.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoveStakeDelayWindow", wireType)
			}
			m.RemoveStakeDelayWindow = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RemoveStakeDelayWindow |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinEpochLength", wireType)
			}
			m.MinEpochLength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinEpochLength |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BetaEntropy", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BetaEntropy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LearningRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LearningRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxGradientThreshold", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxGradientThreshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinStakeFraction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinStakeFraction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnfulfilledWorkerRequests", wireType)
			}
			m.MaxUnfulfilledWorkerRequests = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxUnfulfilledWorkerRequests |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnfulfilledReputerRequests", wireType)
			}
			m.MaxUnfulfilledReputerRequests = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxUnfulfilledReputerRequests |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicRewardStakeImportance", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TopicRewardStakeImportance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicRewardFeeRevenueImportance", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TopicRewardFeeRevenueImportance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicRewardAlpha", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TopicRewardAlpha.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskRewardAlpha", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TaskRewardAlpha.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorsVsAlloraPercentReward", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ValidatorsVsAlloraPercentReward.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSamplesToScaleScores", wireType)
			}
			m.MaxSamplesToScaleScores = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxSamplesToScaleScores |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopInferersToReward", wireType)
			}
			m.MaxTopInferersToReward = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTopInferersToReward |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 22:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopForecastersToReward", wireType)
			}
			m.MaxTopForecastersToReward = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTopForecastersToReward |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopReputersToReward", wireType)
			}
			m.MaxTopReputersToReward = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTopReputersToReward |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateTopicFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CreateTopicFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GradientDescentMaxIters", wireType)
			}
			m.GradientDescentMaxIters = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GradientDescentMaxIters |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegistrationFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RegistrationFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 29:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultPageLimit", wireType)
			}
			m.DefaultPageLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DefaultPageLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 30:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxPageLimit", wireType)
			}
			m.MaxPageLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxPageLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 31:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinEpochLengthRecordLimit", wireType)
			}
			m.MinEpochLengthRecordLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinEpochLengthRecordLimit |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 32:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlocksPerMonth", wireType)
			}
			m.BlocksPerMonth = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlocksPerMonth |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PRewardInference", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PRewardInference.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PRewardForecast", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PRewardForecast.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 35:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PRewardReputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PRewardReputer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 36:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CRewardInference", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CRewardInference.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 37:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CRewardForecast", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CRewardForecast.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 38:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CNorm", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CNorm.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 40:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpsilonReputer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.EpsilonReputer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 42:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HalfMaxProcessStakeRemovalsEndBlock", wireType)
			}
			m.HalfMaxProcessStakeRemovalsEndBlock = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HalfMaxProcessStakeRemovalsEndBlock |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 43:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpsilonSafeDiv", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.EpsilonSafeDiv.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 44:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataSendingFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				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 ErrInvalidLengthParams
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthParams
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DataSendingFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 45:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxElementsPerForecast", wireType)
			}
			m.MaxElementsPerForecast = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxElementsPerForecast |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 46:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxActiveTopicsPerBlock", wireType)
			}
			m.MaxActiveTopicsPerBlock = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxActiveTopicsPerBlock |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipParams(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthParams
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipParams(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, ErrIntOverflowParams
			}
			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, ErrIntOverflowParams
				}
				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, ErrIntOverflowParams
				}
				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, ErrInvalidLengthParams
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupParams
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthParams
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthParams        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowParams          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group")
)
