// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: emissions/v1/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"`
	RewardCadence              int64                                           `protobuf:"varint,2,opt,name=reward_cadence,json=rewardCadence,proto3" json:"reward_cadence,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"`
	MaxTopicsPerBlock          uint64                                          `protobuf:"varint,4,opt,name=max_topics_per_block,json=maxTopicsPerBlock,proto3" json:"max_topics_per_block,omitempty"`
	MaxMissingInferencePercent github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,5,opt,name=max_missing_inference_percent,json=maxMissingInferencePercent,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"max_missing_inference_percent"`
	RequiredMinimumStake       cosmossdk_io_math.Uint                          `protobuf:"bytes,6,opt,name=required_minimum_stake,json=requiredMinimumStake,proto3,customtype=cosmossdk.io/math.Uint" json:"required_minimum_stake"`
	RemoveStakeDelayWindow     int64                                           `protobuf:"varint,7,opt,name=remove_stake_delay_window,json=removeStakeDelayWindow,proto3" json:"remove_stake_delay_window,omitempty"`
	MinEpochLength             int64                                           `protobuf:"varint,8,opt,name=min_epoch_length,json=minEpochLength,proto3" json:"min_epoch_length,omitempty"`
	Sharpness                  github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,9,opt,name=sharpness,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"sharpness"`
	// high values
	BetaEntropy                     github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,10,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,11,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,12,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,13,opt,name=min_stake_fraction,json=minStakeFraction,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"min_stake_fraction"`
	Epsilon                         github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,14,opt,name=epsilon,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"epsilon"`
	PInferenceSynthesis             github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,15,opt,name=p_inference_synthesis,json=pInferenceSynthesis,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_inference_synthesis"`
	PRewardSpread                   github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,16,opt,name=p_reward_spread,json=pRewardSpread,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"p_reward_spread"`
	AlphaRegret                     github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,17,opt,name=alpha_regret,json=alphaRegret,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"alpha_regret"`
	MaxUnfulfilledWorkerRequests    uint64                                          `protobuf:"varint,18,opt,name=max_unfulfilled_worker_requests,json=maxUnfulfilledWorkerRequests,proto3" json:"max_unfulfilled_worker_requests,omitempty"`
	MaxUnfulfilledReputerRequests   uint64                                          `protobuf:"varint,19,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,20,opt,name=topic_reward_stake_importance,json=topicRewardStakeImportance,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"topic_reward_stake_importance"`
	TopicRewardFeeRevenueImportance github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,21,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"`
	// 0.5
	TopicRewardAlpha github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,22,opt,name=topic_reward_alpha,json=topicRewardAlpha,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"topic_reward_alpha"`
	// updates
	TaskRewardAlpha                 github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,23,opt,name=task_reward_alpha,json=taskRewardAlpha,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"task_reward_alpha"`
	ValidatorsVsAlloraPercentReward github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,24,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"`
	MaxSamplesToScaleScores         uint64                                          `protobuf:"varint,25,opt,name=max_samples_to_scale_scores,json=maxSamplesToScaleScores,proto3" json:"max_samples_to_scale_scores,omitempty"`
	// max this many inferences from unique workers and forecasts thereof are accepted per payload
	MaxTopWorkersToReward           uint64                                          `protobuf:"varint,26,opt,name=max_top_workers_to_reward,json=maxTopWorkersToReward,proto3" json:"max_top_workers_to_reward,omitempty"`
	MaxTopReputersToReward          uint64                                          `protobuf:"varint,27,opt,name=max_top_reputers_to_reward,json=maxTopReputersToReward,proto3" json:"max_top_reputers_to_reward,omitempty"`
	CreateTopicFee                  cosmossdk_io_math.Int                           `protobuf:"bytes,28,opt,name=create_topic_fee,json=createTopicFee,proto3,customtype=cosmossdk.io/math.Int" json:"create_topic_fee"`
	SigmoidA                        github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,29,opt,name=sigmoid_a,json=sigmoidA,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"sigmoid_a"`
	SigmoidB                        github_com_allora_network_allora_chain_math.Dec `protobuf:"bytes,30,opt,name=sigmoid_b,json=sigmoidB,proto3,customtype=github.com/allora-network/allora-chain/math.Dec" json:"sigmoid_b"`
	GradientDescentMaxIters         uint64                                          `protobuf:"varint,31,opt,name=gradient_descent_max_iters,json=gradientDescentMaxIters,proto3" json:"gradient_descent_max_iters,omitempty"`
	MaxRetriesToFulfilNoncesWorker  int64                                           `protobuf:"varint,32,opt,name=max_retries_to_fulfil_nonces_worker,json=maxRetriesToFulfilNoncesWorker,proto3" json:"max_retries_to_fulfil_nonces_worker,omitempty"`
	MaxRetriesToFulfilNoncesReputer int64                                           `protobuf:"varint,33,opt,name=max_retries_to_fulfil_nonces_reputer,json=maxRetriesToFulfilNoncesReputer,proto3" json:"max_retries_to_fulfil_nonces_reputer,omitempty"`
	TopicPageLimit                  uint64                                          `protobuf:"varint,34,opt,name=topic_page_limit,json=topicPageLimit,proto3" json:"topic_page_limit,omitempty"`
	MaxTopicPages                   uint64                                          `protobuf:"varint,35,opt,name=max_topic_pages,json=maxTopicPages,proto3" json:"max_topic_pages,omitempty"`
	RegistrationFee                 cosmossdk_io_math.Int                           `protobuf:"bytes,36,opt,name=registration_fee,json=registrationFee,proto3,customtype=cosmossdk.io/math.Int" json:"registration_fee"`
	DefaultLimit                    uint64                                          `protobuf:"varint,37,opt,name=default_limit,json=defaultLimit,proto3" json:"default_limit,omitempty"`
	MaxLimit                        uint64                                          `protobuf:"varint,38,opt,name=max_limit,json=maxLimit,proto3" json:"max_limit,omitempty"`
	MinEpochLengthRecordLimit       int64                                           `protobuf:"varint,39,opt,name=min_epoch_length_record_limit,json=minEpochLengthRecordLimit,proto3" json:"min_epoch_length_record_limit,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_f535e53c00d44458, []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) GetRewardCadence() int64 {
	if m != nil {
		return m.RewardCadence
	}
	return 0
}

func (m *Params) GetMaxTopicsPerBlock() uint64 {
	if m != nil {
		return m.MaxTopicsPerBlock
	}
	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) GetMaxTopWorkersToReward() uint64 {
	if m != nil {
		return m.MaxTopWorkersToReward
	}
	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) GetMaxRetriesToFulfilNoncesWorker() int64 {
	if m != nil {
		return m.MaxRetriesToFulfilNoncesWorker
	}
	return 0
}

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

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

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

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

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

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

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

func init() { proto.RegisterFile("emissions/v1/params.proto", fileDescriptor_f535e53c00d44458) }

var fileDescriptor_f535e53c00d44458 = []byte{
	// 1207 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x97, 0xcf, 0x6f, 0x1c, 0x35,
	0x14, 0xc7, 0xb3, 0xb4, 0xb4, 0x8d, 0x9b, 0x9f, 0x6e, 0x92, 0x3a, 0x69, 0xb3, 0x09, 0x4d, 0x5b,
	0x22, 0xa4, 0x66, 0x29, 0x1c, 0x28, 0x3f, 0x0e, 0x34, 0xb4, 0xa9, 0x22, 0x1a, 0x14, 0x26, 0x29,
	0x95, 0x0a, 0x92, 0xe5, 0xcc, 0xbc, 0xdd, 0xb5, 0x32, 0x63, 0x0f, 0xb6, 0x77, 0xb3, 0xe9, 0x9d,
	0x3b, 0x7f, 0x06, 0x47, 0x0e, 0x1c, 0xf9, 0x03, 0x7a, 0xac, 0x38, 0x21, 0x0e, 0x15, 0x6a, 0x0f,
	0xfc, 0x1b, 0xc8, 0xcf, 0x9e, 0x64, 0xb7, 0x08, 0x84, 0x18, 0x2e, 0x55, 0xc7, 0xfe, 0xbe, 0xcf,
	0x7b, 0x79, 0xef, 0xd9, 0x7e, 0x4b, 0x16, 0xa1, 0x90, 0xd6, 0x4a, 0xad, 0x6c, 0xab, 0x7f, 0xbb,
	0x55, 0x0a, 0x23, 0x0a, 0xbb, 0x51, 0x1a, 0xed, 0x34, 0x9d, 0x38, 0xd9, 0xda, 0xe8, 0xdf, 0x5e,
	0x5a, 0x4c, 0xb5, 0x2d, 0xb4, 0xe5, 0xb8, 0xd7, 0x0a, 0x1f, 0x41, 0xb8, 0x34, 0x2b, 0x0a, 0xa9,
	0x74, 0x0b, 0xff, 0x8d, 0x4b, 0x73, 0x1d, 0xdd, 0xd1, 0x41, 0xea, 0xff, 0x17, 0x56, 0xaf, 0xfd,
	0xcc, 0xc8, 0xb9, 0x5d, 0x74, 0x41, 0x19, 0x39, 0xdf, 0x07, 0xe3, 0xe9, 0xac, 0xb1, 0xda, 0x58,
	0x1f, 0x4f, 0xaa, 0x4f, 0x7a, 0x83, 0x4c, 0x19, 0x38, 0x12, 0x26, 0xe3, 0xa9, 0xc8, 0x40, 0xa5,
	0xc0, 0xde, 0x58, 0x6d, 0xac, 0x9f, 0x49, 0x26, 0xc3, 0xea, 0x67, 0x61, 0x91, 0x0a, 0x32, 0x53,
	0x48, 0xc5, 0x9d, 0x2e, 0x65, 0xca, 0x8f, 0x40, 0x76, 0xba, 0x8e, 0x9d, 0xf1, 0xa4, 0xcd, 0x0f,
	0x9e, 0xbd, 0x58, 0x19, 0xfb, 0xed, 0xc5, 0x4a, 0xab, 0x23, 0x5d, 0xb7, 0x77, 0xb0, 0x91, 0xea,
	0xa2, 0x25, 0xf2, 0x5c, 0x1b, 0x71, 0x4b, 0x81, 0x3b, 0xd2, 0xe6, 0xb0, 0xfa, 0x4c, 0xbb, 0x42,
	0xaa, 0x56, 0x21, 0x5c, 0x77, 0xe3, 0x1e, 0xa4, 0xc9, 0x54, 0x21, 0xd5, 0xbe, 0xe7, 0x3d, 0x46,
	0x1c, 0x6d, 0x91, 0xb9, 0x42, 0x0c, 0x82, 0x0b, 0xcb, 0x4b, 0x30, 0xfc, 0x20, 0xd7, 0xe9, 0x21,
	0x3b, 0xbb, 0xda, 0x58, 0x3f, 0x9b, 0xcc, 0x16, 0x62, 0x80, 0x6a, 0xbb, 0x0b, 0x66, 0xd3, 0x6f,
	0xd0, 0xa7, 0x64, 0xd9, 0x1b, 0x60, 0xda, 0x54, 0x87, 0x4b, 0xd5, 0x06, 0xe3, 0x83, 0xf5, 0xb6,
	0x29, 0x28, 0xc7, 0xde, 0xac, 0x17, 0xe0, 0x52, 0x21, 0x06, 0x3b, 0x01, 0xbe, 0x5d, 0xb1, 0x77,
	0x03, 0x9a, 0x76, 0xc9, 0x82, 0x81, 0x6f, 0x7b, 0xd2, 0x40, 0xc6, 0x0b, 0xa9, 0x64, 0xd1, 0x2b,
	0xb8, 0x75, 0xe2, 0x10, 0xd8, 0x39, 0x74, 0xfa, 0x5e, 0x74, 0xba, 0x10, 0x4a, 0x67, 0xb3, 0xc3,
	0x0d, 0xa9, 0x03, 0xfa, 0x91, 0x54, 0xee, 0x97, 0x9f, 0x6e, 0x5d, 0x8c, 0x45, 0xf5, 0x9f, 0x3f,
	0xfc, 0xf1, 0xe3, 0x3b, 0x8d, 0x64, 0xae, 0x22, 0xee, 0x04, 0xe0, 0x9e, 0xe7, 0xd1, 0x0f, 0xc9,
	0xa2, 0x81, 0x42, 0xf7, 0x21, 0xf0, 0x79, 0x06, 0xb9, 0x38, 0xe6, 0x47, 0x52, 0x65, 0xfa, 0x88,
	0x9d, 0xc7, 0x5a, 0x2d, 0x04, 0x01, 0xea, 0xef, 0xf9, 0xed, 0xc7, 0xb8, 0x4b, 0xd7, 0x43, 0xd1,
	0xa0, 0xd4, 0x69, 0x97, 0xe7, 0xa0, 0x3a, 0xae, 0xcb, 0x2e, 0xa0, 0x85, 0xcf, 0xfd, 0x7d, 0xbf,
	0xfc, 0x10, 0x57, 0xe9, 0x23, 0x32, 0x6e, 0xbb, 0xc2, 0x94, 0x0a, 0xac, 0x65, 0xe3, 0xf5, 0xd2,
	0x76, 0x4a, 0xa2, 0x4f, 0xc8, 0xc4, 0x01, 0x38, 0xc1, 0x41, 0x39, 0xa3, 0xcb, 0x63, 0x46, 0xea,
	0x91, 0x2f, 0x7a, 0xd8, 0xfd, 0xc0, 0xa2, 0xdf, 0x90, 0xc9, 0x1c, 0x84, 0x51, 0xbe, 0xf4, 0x46,
	0x38, 0x60, 0x17, 0xeb, 0xc1, 0x27, 0x2a, 0x5a, 0x22, 0x1c, 0xd0, 0x82, 0x2c, 0xf8, 0xde, 0xea,
	0x18, 0x91, 0x49, 0x50, 0x8e, 0xbb, 0xae, 0x01, 0xdb, 0xd5, 0x79, 0xc6, 0x26, 0xea, 0xb9, 0xf1,
	0x3d, 0xfe, 0x20, 0x52, 0xf7, 0x2b, 0x28, 0x05, 0x42, 0x7d, 0xa5, 0x42, 0x85, 0xdb, 0x46, 0xa4,
	0xce, 0x1f, 0xd5, 0xc9, 0x7a, 0xae, 0x7c, 0xf1, 0xb1, 0x27, 0xb6, 0x22, 0x90, 0x7e, 0x49, 0xce,
	0x43, 0x69, 0x65, 0xae, 0x15, 0x9b, 0xaa, 0xc7, 0xae, 0x38, 0xf4, 0x90, 0xcc, 0x97, 0x43, 0x47,
	0xcf, 0x1e, 0x2b, 0xd7, 0x05, 0x2b, 0x2d, 0x9b, 0xae, 0xe7, 0xe0, 0x52, 0x79, 0x72, 0xe6, 0xf6,
	0x2a, 0x26, 0xe5, 0x64, 0xba, 0xe4, 0xf1, 0xba, 0xb2, 0xa5, 0x01, 0x91, 0xb1, 0x99, 0x7a, 0x6e,
	0x26, 0xcb, 0x04, 0x71, 0x7b, 0x48, 0xf3, 0x0d, 0x2b, 0xf2, 0xb2, 0x2b, 0xb8, 0x81, 0x8e, 0x01,
	0xc7, 0x66, 0x6b, 0x36, 0x2c, 0xc2, 0x12, 0x64, 0xd1, 0xfb, 0x64, 0xc5, 0xb7, 0x54, 0x4f, 0xb5,
	0x7b, 0x79, 0x5b, 0xe6, 0x39, 0x64, 0xdc, 0x9b, 0x82, 0xe1, 0xfe, 0xdc, 0x83, 0x75, 0x96, 0x51,
	0xbc, 0xea, 0xae, 0x16, 0x62, 0xf0, 0xe8, 0x54, 0xf5, 0x18, 0x45, 0x49, 0xd4, 0xd0, 0x07, 0x64,
	0xf5, 0x75, 0x8c, 0x81, 0xb2, 0xe7, 0x86, 0x39, 0x97, 0x90, 0xb3, 0x3c, 0xca, 0x49, 0x82, 0xea,
	0x04, 0xf4, 0x94, 0x2c, 0x87, 0xeb, 0xbc, 0x4a, 0x28, 0x36, 0x9f, 0x2c, 0x4a, 0x6d, 0x9c, 0xf0,
	0x0f, 0xc1, 0x5c, 0xcd, 0xeb, 0x13, 0xe9, 0x31, 0xbd, 0x9e, 0xbd, 0x7d, 0x82, 0xa6, 0xdf, 0x35,
	0xc8, 0xda, 0x88, 0xf3, 0x36, 0x00, 0x37, 0xd0, 0x07, 0xd5, 0x1b, 0x09, 0x61, 0xbe, 0x5e, 0x08,
	0x2b, 0x43, 0x21, 0x6c, 0x01, 0x24, 0xc1, 0xc1, 0x50, 0x1c, 0x40, 0xe8, 0x48, 0x18, 0x58, 0x2f,
	0xb6, 0x50, 0xf3, 0xdc, 0x0d, 0x79, 0xbd, 0xeb, 0x81, 0x34, 0x25, 0xb3, 0x4e, 0xd8, 0xc3, 0x51,
	0x2f, 0x97, 0xeb, 0x79, 0x99, 0xf6, 0xc4, 0x61, 0x27, 0x3e, 0xa7, 0x7d, 0x91, 0xcb, 0x4c, 0x38,
	0x6d, 0x2c, 0xef, 0x5b, 0x1e, 0x0c, 0xab, 0xe7, 0x30, 0x7a, 0x67, 0xac, 0x66, 0x4e, 0x4f, 0x7d,
	0x7c, 0x65, 0xef, 0xa2, 0x24, 0x3e, 0x8a, 0x21, 0x18, 0xfa, 0x09, 0xb9, 0xe2, 0x1b, 0xd4, 0x8a,
	0xa2, 0xcc, 0xc1, 0x72, 0xa7, 0xb9, 0x4d, 0x45, 0x0e, 0xdc, 0xa6, 0xda, 0x80, 0x65, 0x8b, 0xd8,
	0x9b, 0x97, 0x0b, 0x31, 0xd8, 0x0b, 0x8a, 0x7d, 0xbd, 0xe7, 0xf7, 0xf7, 0x70, 0x9b, 0xde, 0x21,
	0x8b, 0x71, 0x0a, 0x88, 0xa7, 0x03, 0x09, 0x31, 0xf4, 0x25, 0xb4, 0x9d, 0x0f, 0xa3, 0x40, 0x38,
	0x17, 0x76, 0x5f, 0x47, 0xbf, 0x1f, 0x91, 0xa5, 0xca, 0x32, 0x1e, 0x88, 0x61, 0xd3, 0x2b, 0x68,
	0xba, 0x10, 0x4c, 0xe3, 0x51, 0x38, 0xb5, 0x7d, 0x42, 0x66, 0x52, 0x03, 0xc2, 0x41, 0x9c, 0x70,
	0xda, 0x00, 0xec, 0x2a, 0xe6, 0xe9, 0xdd, 0x98, 0xa7, 0xf9, 0xbf, 0x3e, 0xe4, 0xdb, 0xf8, 0x8e,
	0x93, 0xf8, 0x8e, 0x6f, 0x57, 0xcf, 0xf8, 0x54, 0x20, 0xe1, 0xb0, 0xb2, 0x05, 0x40, 0xf7, 0xc9,
	0xb8, 0x95, 0x9d, 0x42, 0xcb, 0x8c, 0x0b, 0xb6, 0x5c, 0x2f, 0xf9, 0x17, 0x22, 0xe9, 0xee, 0x30,
	0xf5, 0x80, 0x35, 0xff, 0x1f, 0xea, 0x26, 0xfd, 0x98, 0x2c, 0x9d, 0x3c, 0x79, 0x19, 0x58, 0x6c,
	0x1b, 0x9f, 0x54, 0xe9, 0xb3, 0xc5, 0x56, 0x42, 0xe9, 0x2a, 0xc5, 0xbd, 0x20, 0xd8, 0x11, 0x83,
	0x6d, 0xbf, 0x4d, 0x3f, 0x27, 0x6b, 0x5e, 0x6b, 0xc0, 0x19, 0x19, 0x0a, 0x1f, 0xee, 0x1e, 0xae,
	0xb4, 0x4a, 0xc1, 0xc6, 0x7a, 0xb2, 0x55, 0x9c, 0x40, 0x9a, 0x85, 0x18, 0x24, 0x41, 0xb9, 0xaf,
	0xb7, 0x50, 0xf7, 0x05, 0xca, 0x42, 0x59, 0xe9, 0x0e, 0xb9, 0xfe, 0x8f, 0xb0, 0x58, 0x62, 0xf6,
	0x16, 0xd2, 0x56, 0xfe, 0x8e, 0x16, 0x2b, 0xed, 0x47, 0xa1, 0x50, 0xd9, 0x52, 0x74, 0x80, 0xe7,
	0xb2, 0x90, 0x8e, 0x5d, 0xc3, 0x3f, 0x67, 0x0a, 0xd7, 0x77, 0x45, 0x07, 0x1e, 0xfa, 0x55, 0x7a,
	0x93, 0x4c, 0x9f, 0x8c, 0xa1, 0xa8, 0xb6, 0x6c, 0x0d, 0x85, 0x93, 0xd5, 0x04, 0xea, 0xb5, 0x96,
	0x7e, 0x4d, 0x66, 0x0c, 0x74, 0xa4, 0x75, 0x46, 0xf8, 0xb7, 0x15, 0x5b, 0xe6, 0xfa, 0x7f, 0x6c,
	0x99, 0xe9, 0x61, 0x92, 0xef, 0x99, 0x35, 0x32, 0x99, 0x41, 0x5b, 0xf4, 0x72, 0x17, 0x63, 0xbd,
	0x81, 0x21, 0x4c, 0xc4, 0xc5, 0x10, 0xe9, 0x15, 0x32, 0xee, 0x23, 0x0d, 0x82, 0x9b, 0x28, 0xb8,
	0x50, 0x88, 0x41, 0xd8, 0xfc, 0x94, 0x2c, 0xbf, 0x3e, 0xfb, 0x71, 0x03, 0xa9, 0x36, 0x59, 0x34,
	0x78, 0x1b, 0x13, 0xb7, 0x38, 0x3a, 0x08, 0x26, 0xa8, 0x40, 0xc2, 0x66, 0xf2, 0xec, 0x65, 0xb3,
	0xf1, 0xfc, 0x65, 0xb3, 0xf1, 0xfb, 0xcb, 0x66, 0xe3, 0xfb, 0x57, 0xcd, 0xb1, 0xe7, 0xaf, 0x9a,
	0x63, 0xbf, 0xbe, 0x6a, 0x8e, 0x3d, 0xb9, 0xf3, 0x2f, 0x1b, 0x6c, 0xd0, 0x3a, 0xfd, 0xb9, 0xe3,
	0x8e, 0x4b, 0xb0, 0x07, 0xe7, 0xf0, 0x97, 0xc9, 0xfb, 0x7f, 0x06, 0x00, 0x00, 0xff, 0xff, 0xb7,
	0xb1, 0x76, 0x90, 0x08, 0x0d, 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.MinEpochLengthRecordLimit != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MinEpochLengthRecordLimit))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xb8
	}
	if m.MaxLimit != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxLimit))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xb0
	}
	if m.DefaultLimit != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.DefaultLimit))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xa8
	}
	{
		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] = 0x2
	i--
	dAtA[i] = 0xa2
	if m.MaxTopicPages != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxTopicPages))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x98
	}
	if m.TopicPageLimit != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.TopicPageLimit))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x90
	}
	if m.MaxRetriesToFulfilNoncesReputer != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxRetriesToFulfilNoncesReputer))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x88
	}
	if m.MaxRetriesToFulfilNoncesWorker != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxRetriesToFulfilNoncesWorker))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x80
	}
	if m.GradientDescentMaxIters != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.GradientDescentMaxIters))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf8
	}
	{
		size := m.SigmoidB.Size()
		i -= size
		if _, err := m.SigmoidB.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xf2
	{
		size := m.SigmoidA.Size()
		i -= size
		if _, err := m.SigmoidA.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xea
	{
		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] = 0xe2
	if m.MaxTopReputersToReward != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxTopReputersToReward))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd8
	}
	if m.MaxTopWorkersToReward != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxTopWorkersToReward))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd0
	}
	if m.MaxSamplesToScaleScores != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxSamplesToScaleScores))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc8
	}
	{
		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] = 0xc2
	{
		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] = 0xba
	{
		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] = 0xb2
	{
		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] = 0xaa
	{
		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] = 0x1
	i--
	dAtA[i] = 0xa2
	if m.MaxUnfulfilledReputerRequests != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxUnfulfilledReputerRequests))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if m.MaxUnfulfilledWorkerRequests != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxUnfulfilledWorkerRequests))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	{
		size := m.AlphaRegret.Size()
		i -= size
		if _, err := m.AlphaRegret.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	{
		size := m.PRewardSpread.Size()
		i -= size
		if _, err := m.PRewardSpread.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size := m.PInferenceSynthesis.Size()
		i -= size
		if _, err := m.PInferenceSynthesis.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	{
		size := m.Epsilon.Size()
		i -= size
		if _, err := m.Epsilon.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x72
	{
		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] = 0x6a
	{
		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] = 0x62
	{
		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] = 0x5a
	{
		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] = 0x52
	{
		size := m.Sharpness.Size()
		i -= size
		if _, err := m.Sharpness.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	if m.MinEpochLength != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MinEpochLength))
		i--
		dAtA[i] = 0x40
	}
	if m.RemoveStakeDelayWindow != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.RemoveStakeDelayWindow))
		i--
		dAtA[i] = 0x38
	}
	{
		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] = 0x32
	{
		size := m.MaxMissingInferencePercent.Size()
		i -= size
		if _, err := m.MaxMissingInferencePercent.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintParams(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.MaxTopicsPerBlock != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.MaxTopicsPerBlock))
		i--
		dAtA[i] = 0x20
	}
	{
		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.RewardCadence != 0 {
		i = encodeVarintParams(dAtA, i, uint64(m.RewardCadence))
		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.RewardCadence != 0 {
		n += 1 + sovParams(uint64(m.RewardCadence))
	}
	l = m.MinTopicWeight.Size()
	n += 1 + l + sovParams(uint64(l))
	if m.MaxTopicsPerBlock != 0 {
		n += 1 + sovParams(uint64(m.MaxTopicsPerBlock))
	}
	l = m.MaxMissingInferencePercent.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.Sharpness.Size()
	n += 1 + l + sovParams(uint64(l))
	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))
	l = m.Epsilon.Size()
	n += 1 + l + sovParams(uint64(l))
	l = m.PInferenceSynthesis.Size()
	n += 1 + l + sovParams(uint64(l))
	l = m.PRewardSpread.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.AlphaRegret.Size()
	n += 2 + l + sovParams(uint64(l))
	if m.MaxUnfulfilledWorkerRequests != 0 {
		n += 2 + sovParams(uint64(m.MaxUnfulfilledWorkerRequests))
	}
	if m.MaxUnfulfilledReputerRequests != 0 {
		n += 2 + sovParams(uint64(m.MaxUnfulfilledReputerRequests))
	}
	l = m.TopicRewardStakeImportance.Size()
	n += 2 + 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.MaxTopWorkersToReward != 0 {
		n += 2 + sovParams(uint64(m.MaxTopWorkersToReward))
	}
	if m.MaxTopReputersToReward != 0 {
		n += 2 + sovParams(uint64(m.MaxTopReputersToReward))
	}
	l = m.CreateTopicFee.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.SigmoidA.Size()
	n += 2 + l + sovParams(uint64(l))
	l = m.SigmoidB.Size()
	n += 2 + l + sovParams(uint64(l))
	if m.GradientDescentMaxIters != 0 {
		n += 2 + sovParams(uint64(m.GradientDescentMaxIters))
	}
	if m.MaxRetriesToFulfilNoncesWorker != 0 {
		n += 2 + sovParams(uint64(m.MaxRetriesToFulfilNoncesWorker))
	}
	if m.MaxRetriesToFulfilNoncesReputer != 0 {
		n += 2 + sovParams(uint64(m.MaxRetriesToFulfilNoncesReputer))
	}
	if m.TopicPageLimit != 0 {
		n += 2 + sovParams(uint64(m.TopicPageLimit))
	}
	if m.MaxTopicPages != 0 {
		n += 2 + sovParams(uint64(m.MaxTopicPages))
	}
	l = m.RegistrationFee.Size()
	n += 2 + l + sovParams(uint64(l))
	if m.DefaultLimit != 0 {
		n += 2 + sovParams(uint64(m.DefaultLimit))
	}
	if m.MaxLimit != 0 {
		n += 2 + sovParams(uint64(m.MaxLimit))
	}
	if m.MinEpochLengthRecordLimit != 0 {
		n += 2 + sovParams(uint64(m.MinEpochLengthRecordLimit))
	}
	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 RewardCadence", wireType)
			}
			m.RewardCadence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RewardCadence |= 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 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopicsPerBlock", wireType)
			}
			m.MaxTopicsPerBlock = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTopicsPerBlock |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxMissingInferencePercent", 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.MaxMissingInferencePercent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			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 7:
			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 8:
			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 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sharpness", 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.Sharpness.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			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 11:
			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 12:
			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 13:
			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 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epsilon", 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.Epsilon.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PInferenceSynthesis", 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.PInferenceSynthesis.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PRewardSpread", 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.PRewardSpread.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlphaRegret", 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.AlphaRegret.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			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 19:
			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 20:
			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 21:
			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 22:
			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 23:
			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 24:
			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 25:
			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 26:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopWorkersToReward", wireType)
			}
			m.MaxTopWorkersToReward = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTopWorkersToReward |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 27:
			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 28:
			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 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigmoidA", 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.SigmoidA.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigmoidB", 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.SigmoidB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 31:
			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 32:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRetriesToFulfilNoncesWorker", wireType)
			}
			m.MaxRetriesToFulfilNoncesWorker = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxRetriesToFulfilNoncesWorker |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 33:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRetriesToFulfilNoncesReputer", wireType)
			}
			m.MaxRetriesToFulfilNoncesReputer = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxRetriesToFulfilNoncesReputer |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 34:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicPageLimit", wireType)
			}
			m.TopicPageLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TopicPageLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 35:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTopicPages", wireType)
			}
			m.MaxTopicPages = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTopicPages |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 36:
			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 37:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultLimit", wireType)
			}
			m.DefaultLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DefaultLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 38:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxLimit", wireType)
			}
			m.MaxLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowParams
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 39:
			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
				}
			}
		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")
)
