// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: agoric/swingset/swingset.proto

package types

import (
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "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

// CoreEvalProposal is a gov Content type for evaluating code in the SwingSet
// core.
// See `bridgeCoreEval` in agoric-sdk packages/vats/src/core/chain-behaviors.js.
type CoreEvalProposal struct {
	Title       string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// Although evals are sequential, they may run concurrently, since they each
	// can return a Promise.
	Evals []CoreEval `protobuf:"bytes,3,rep,name=evals,proto3" json:"evals"`
}

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

var xxx_messageInfo_CoreEvalProposal proto.InternalMessageInfo

// CoreEval defines an individual SwingSet core evaluation, for use in
// CoreEvalProposal.
type CoreEval struct {
	// Grant these JSON-stringified core bootstrap permits to the jsCode, as the
	// `powers` endowment.
	JsonPermits string `protobuf:"bytes,1,opt,name=json_permits,json=jsonPermits,proto3" json:"json_permits,omitempty" yaml:"json_permits"`
	// Evaluate this JavaScript code in a Compartment endowed with `powers` as
	// well as some powerless helpers.
	JsCode string `protobuf:"bytes,2,opt,name=js_code,json=jsCode,proto3" json:"js_code,omitempty" yaml:"js_code"`
}

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

var xxx_messageInfo_CoreEval proto.InternalMessageInfo

func (m *CoreEval) GetJsonPermits() string {
	if m != nil {
		return m.JsonPermits
	}
	return ""
}

func (m *CoreEval) GetJsCode() string {
	if m != nil {
		return m.JsCode
	}
	return ""
}

// Params are the swingset configuration/governance parameters.
type Params struct {
	// Map from unit name to a value in SwingSet "beans".
	// Must not be negative.
	//
	// These values are used by SwingSet to normalize named per-resource charges
	// (maybe rent) in a single Nat usage unit, the "bean".
	//
	// There is no required order to this list of entries, but all the chain
	// nodes must all serialize and deserialize the existing order without
	// permuting it.
	BeansPerUnit []StringBeans `protobuf:"bytes,1,rep,name=beans_per_unit,json=beansPerUnit,proto3" json:"beans_per_unit"`
	// The price in Coins per the unit named "fee".  This value is used by
	// cosmic-swingset JS code to decide how many tokens to charge.
	//
	// cost = beans_used * fee_unit_price / beans_per_unit["fee"]
	FeeUnitPrice github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=fee_unit_price,json=feeUnitPrice,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"fee_unit_price"`
	// The SwingSet bootstrap vat configuration file.  Not usefully modifiable
	// via governance as it is only referenced by the chain's initial
	// construction.
	BootstrapVatConfig string `protobuf:"bytes,3,opt,name=bootstrap_vat_config,json=bootstrapVatConfig,proto3" json:"bootstrap_vat_config,omitempty"`
	// If the provision submitter doesn't hold a provisionpass, their requested
	// power flags are looked up in this fee menu (first match wins) and the sum
	// is charged.  If any power flag is not found in this menu, the request is
	// rejected.
	PowerFlagFees []PowerFlagFee `protobuf:"bytes,4,rep,name=power_flag_fees,json=powerFlagFees,proto3" json:"power_flag_fees"`
	// Maximum sizes for queues.
	// These values are used by SwingSet to compute how many messages should be
	// accepted in a block.
	//
	// There is no required order to this list of entries, but all the chain
	// nodes must all serialize and deserialize the existing order without
	// permuting it.
	QueueMax []QueueSize `protobuf:"bytes,5,rep,name=queue_max,json=queueMax,proto3" json:"queue_max"`
	// Vat cleanup budget values.
	// These values are used by SwingSet to control the pace of removing data
	// associated with a terminated vat as described at
	// https://github.com/Agoric/agoric-sdk/blob/master/packages/SwingSet/docs/run-policy.md#terminated-vat-cleanup
	//
	// There is no required order to this list of entries, but all the chain
	// nodes must all serialize and deserialize the existing order without
	// permuting it.
	VatCleanupBudget []UintMapEntry `protobuf:"bytes,6,rep,name=vat_cleanup_budget,json=vatCleanupBudget,proto3" json:"vat_cleanup_budget"`
}

func (m *Params) Reset()      { *m = Params{} }
func (*Params) ProtoMessage() {}
func (*Params) Descriptor() ([]byte, []int) {
	return fileDescriptor_ff9c341e0de15f8b, []int{2}
}
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) GetBeansPerUnit() []StringBeans {
	if m != nil {
		return m.BeansPerUnit
	}
	return nil
}

func (m *Params) GetFeeUnitPrice() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.FeeUnitPrice
	}
	return nil
}

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

func (m *Params) GetPowerFlagFees() []PowerFlagFee {
	if m != nil {
		return m.PowerFlagFees
	}
	return nil
}

func (m *Params) GetQueueMax() []QueueSize {
	if m != nil {
		return m.QueueMax
	}
	return nil
}

func (m *Params) GetVatCleanupBudget() []UintMapEntry {
	if m != nil {
		return m.VatCleanupBudget
	}
	return nil
}

// The current state of the module.
type State struct {
	// The allowed number of items to add to queues, as determined by SwingSet.
	// Transactions which attempt to enqueue more should be rejected.
	QueueAllowed []QueueSize `protobuf:"bytes,1,rep,name=queue_allowed,json=queueAllowed,proto3" json:"queue_allowed"`
}

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

var xxx_messageInfo_State proto.InternalMessageInfo

func (m *State) GetQueueAllowed() []QueueSize {
	if m != nil {
		return m.QueueAllowed
	}
	return nil
}

// Map element of a string key to a Nat bean count.
type StringBeans struct {
	// What the beans are for.
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The actual bean value.
	Beans cosmossdk_io_math.Uint `protobuf:"bytes,2,opt,name=beans,proto3,customtype=cosmossdk.io/math.Uint" json:"beans"`
}

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

var xxx_messageInfo_StringBeans proto.InternalMessageInfo

func (m *StringBeans) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

// Map a provisioning power flag to its corresponding fee.
type PowerFlagFee struct {
	PowerFlag string                                   `protobuf:"bytes,1,opt,name=power_flag,json=powerFlag,proto3" json:"power_flag,omitempty"`
	Fee       github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=fee,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"fee"`
}

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

var xxx_messageInfo_PowerFlagFee proto.InternalMessageInfo

func (m *PowerFlagFee) GetPowerFlag() string {
	if m != nil {
		return m.PowerFlag
	}
	return ""
}

func (m *PowerFlagFee) GetFee() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Fee
	}
	return nil
}

// Map element of a string key to a size.
// TODO: Replace with UintMapEntry?
type QueueSize struct {
	// What the size is for.
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The actual size value.
	Size_ int32 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
}

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

var xxx_messageInfo_QueueSize proto.InternalMessageInfo

func (m *QueueSize) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *QueueSize) GetSize_() int32 {
	if m != nil {
		return m.Size_
	}
	return 0
}

// Map element of a string key to an unsigned integer.
// The value uses cosmos-sdk Uint rather than a native Go type to ensure that
// zeroes survive "omitempty" JSON serialization.
type UintMapEntry struct {
	Key   string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value cosmossdk_io_math.Uint `protobuf:"bytes,2,opt,name=value,proto3,customtype=cosmossdk.io/math.Uint" json:"value"`
}

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

var xxx_messageInfo_UintMapEntry proto.InternalMessageInfo

func (m *UintMapEntry) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

// Egress is the format for a swingset egress.
type Egress struct {
	Nickname string                                        `protobuf:"bytes,1,opt,name=nickname,proto3" json:"nickname" yaml:"nickname"`
	Peer     github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,2,opt,name=peer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"peer" yaml:"peer"`
	// TODO: Remove these power flags as they are deprecated and have no effect.
	PowerFlags []string `protobuf:"bytes,3,rep,name=power_flags,json=powerFlags,proto3" json:"powerFlags" yaml:"powerFlags"`
}

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

var xxx_messageInfo_Egress proto.InternalMessageInfo

func (m *Egress) GetNickname() string {
	if m != nil {
		return m.Nickname
	}
	return ""
}

func (m *Egress) GetPeer() github_com_cosmos_cosmos_sdk_types.AccAddress {
	if m != nil {
		return m.Peer
	}
	return nil
}

func (m *Egress) GetPowerFlags() []string {
	if m != nil {
		return m.PowerFlags
	}
	return nil
}

// SwingStoreArtifact encodes an artifact of a swing-store export.
// Artifacts may be stored or transmitted in any order. Most handlers do
// maintain the artifact order from their original source as an effect of how
// they handle the artifacts.
type SwingStoreArtifact struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name" yaml:"name"`
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data" yaml:"data"`
}

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

var xxx_messageInfo_SwingStoreArtifact proto.InternalMessageInfo

func (m *SwingStoreArtifact) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *SwingStoreArtifact) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func init() {
	proto.RegisterType((*CoreEvalProposal)(nil), "agoric.swingset.CoreEvalProposal")
	proto.RegisterType((*CoreEval)(nil), "agoric.swingset.CoreEval")
	proto.RegisterType((*Params)(nil), "agoric.swingset.Params")
	proto.RegisterType((*State)(nil), "agoric.swingset.State")
	proto.RegisterType((*StringBeans)(nil), "agoric.swingset.StringBeans")
	proto.RegisterType((*PowerFlagFee)(nil), "agoric.swingset.PowerFlagFee")
	proto.RegisterType((*QueueSize)(nil), "agoric.swingset.QueueSize")
	proto.RegisterType((*UintMapEntry)(nil), "agoric.swingset.UintMapEntry")
	proto.RegisterType((*Egress)(nil), "agoric.swingset.Egress")
	proto.RegisterType((*SwingStoreArtifact)(nil), "agoric.swingset.SwingStoreArtifact")
}

func init() { proto.RegisterFile("agoric/swingset/swingset.proto", fileDescriptor_ff9c341e0de15f8b) }

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

func (this *Params) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Params)
	if !ok {
		that2, ok := that.(Params)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.BeansPerUnit) != len(that1.BeansPerUnit) {
		return false
	}
	for i := range this.BeansPerUnit {
		if !this.BeansPerUnit[i].Equal(&that1.BeansPerUnit[i]) {
			return false
		}
	}
	if len(this.FeeUnitPrice) != len(that1.FeeUnitPrice) {
		return false
	}
	for i := range this.FeeUnitPrice {
		if !this.FeeUnitPrice[i].Equal(&that1.FeeUnitPrice[i]) {
			return false
		}
	}
	if this.BootstrapVatConfig != that1.BootstrapVatConfig {
		return false
	}
	if len(this.PowerFlagFees) != len(that1.PowerFlagFees) {
		return false
	}
	for i := range this.PowerFlagFees {
		if !this.PowerFlagFees[i].Equal(&that1.PowerFlagFees[i]) {
			return false
		}
	}
	if len(this.QueueMax) != len(that1.QueueMax) {
		return false
	}
	for i := range this.QueueMax {
		if !this.QueueMax[i].Equal(&that1.QueueMax[i]) {
			return false
		}
	}
	if len(this.VatCleanupBudget) != len(that1.VatCleanupBudget) {
		return false
	}
	for i := range this.VatCleanupBudget {
		if !this.VatCleanupBudget[i].Equal(&that1.VatCleanupBudget[i]) {
			return false
		}
	}
	return true
}
func (this *StringBeans) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StringBeans)
	if !ok {
		that2, ok := that.(StringBeans)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if !this.Beans.Equal(that1.Beans) {
		return false
	}
	return true
}
func (this *PowerFlagFee) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PowerFlagFee)
	if !ok {
		that2, ok := that.(PowerFlagFee)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.PowerFlag != that1.PowerFlag {
		return false
	}
	if len(this.Fee) != len(that1.Fee) {
		return false
	}
	for i := range this.Fee {
		if !this.Fee[i].Equal(&that1.Fee[i]) {
			return false
		}
	}
	return true
}
func (this *QueueSize) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*QueueSize)
	if !ok {
		that2, ok := that.(QueueSize)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if this.Size_ != that1.Size_ {
		return false
	}
	return true
}
func (this *UintMapEntry) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UintMapEntry)
	if !ok {
		that2, ok := that.(UintMapEntry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if !this.Value.Equal(that1.Value) {
		return false
	}
	return true
}
func (m *CoreEvalProposal) 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 *CoreEvalProposal) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CoreEvalProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Evals) > 0 {
		for iNdEx := len(m.Evals) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Evals[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSwingset(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CoreEval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JsCode) > 0 {
		i -= len(m.JsCode)
		copy(dAtA[i:], m.JsCode)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.JsCode)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.JsonPermits) > 0 {
		i -= len(m.JsonPermits)
		copy(dAtA[i:], m.JsonPermits)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.JsonPermits)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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 len(m.VatCleanupBudget) > 0 {
		for iNdEx := len(m.VatCleanupBudget) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.VatCleanupBudget[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSwingset(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.QueueMax) > 0 {
		for iNdEx := len(m.QueueMax) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.QueueMax[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSwingset(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.PowerFlagFees) > 0 {
		for iNdEx := len(m.PowerFlagFees) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PowerFlagFees[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSwingset(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.BootstrapVatConfig) > 0 {
		i -= len(m.BootstrapVatConfig)
		copy(dAtA[i:], m.BootstrapVatConfig)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.BootstrapVatConfig)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.FeeUnitPrice) > 0 {
		for iNdEx := len(m.FeeUnitPrice) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FeeUnitPrice[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSwingset(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.BeansPerUnit) > 0 {
		for iNdEx := len(m.BeansPerUnit) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BeansPerUnit[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSwingset(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.QueueAllowed) > 0 {
		for iNdEx := len(m.QueueAllowed) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.QueueAllowed[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSwingset(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *StringBeans) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Beans.Size()
		i -= size
		if _, err := m.Beans.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintSwingset(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PowerFlagFee) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Fee) > 0 {
		for iNdEx := len(m.Fee) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Fee[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSwingset(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.PowerFlag) > 0 {
		i -= len(m.PowerFlag)
		copy(dAtA[i:], m.PowerFlag)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.PowerFlag)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueueSize) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Size_ != 0 {
		i = encodeVarintSwingset(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *UintMapEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Value.Size()
		i -= size
		if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintSwingset(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Egress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PowerFlags) > 0 {
		for iNdEx := len(m.PowerFlags) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PowerFlags[iNdEx])
			copy(dAtA[i:], m.PowerFlags[iNdEx])
			i = encodeVarintSwingset(dAtA, i, uint64(len(m.PowerFlags[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Peer) > 0 {
		i -= len(m.Peer)
		copy(dAtA[i:], m.Peer)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.Peer)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Nickname) > 0 {
		i -= len(m.Nickname)
		copy(dAtA[i:], m.Nickname)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.Nickname)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SwingStoreArtifact) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSwingset(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintSwingset(dAtA []byte, offset int, v uint64) int {
	offset -= sovSwingset(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *CoreEvalProposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	if len(m.Evals) > 0 {
		for _, e := range m.Evals {
			l = e.Size()
			n += 1 + l + sovSwingset(uint64(l))
		}
	}
	return n
}

func (m *CoreEval) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.JsonPermits)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	l = len(m.JsCode)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	return n
}

func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.BeansPerUnit) > 0 {
		for _, e := range m.BeansPerUnit {
			l = e.Size()
			n += 1 + l + sovSwingset(uint64(l))
		}
	}
	if len(m.FeeUnitPrice) > 0 {
		for _, e := range m.FeeUnitPrice {
			l = e.Size()
			n += 1 + l + sovSwingset(uint64(l))
		}
	}
	l = len(m.BootstrapVatConfig)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	if len(m.PowerFlagFees) > 0 {
		for _, e := range m.PowerFlagFees {
			l = e.Size()
			n += 1 + l + sovSwingset(uint64(l))
		}
	}
	if len(m.QueueMax) > 0 {
		for _, e := range m.QueueMax {
			l = e.Size()
			n += 1 + l + sovSwingset(uint64(l))
		}
	}
	if len(m.VatCleanupBudget) > 0 {
		for _, e := range m.VatCleanupBudget {
			l = e.Size()
			n += 1 + l + sovSwingset(uint64(l))
		}
	}
	return n
}

func (m *State) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.QueueAllowed) > 0 {
		for _, e := range m.QueueAllowed {
			l = e.Size()
			n += 1 + l + sovSwingset(uint64(l))
		}
	}
	return n
}

func (m *StringBeans) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	l = m.Beans.Size()
	n += 1 + l + sovSwingset(uint64(l))
	return n
}

func (m *PowerFlagFee) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PowerFlag)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	if len(m.Fee) > 0 {
		for _, e := range m.Fee {
			l = e.Size()
			n += 1 + l + sovSwingset(uint64(l))
		}
	}
	return n
}

func (m *QueueSize) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	if m.Size_ != 0 {
		n += 1 + sovSwingset(uint64(m.Size_))
	}
	return n
}

func (m *UintMapEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	l = m.Value.Size()
	n += 1 + l + sovSwingset(uint64(l))
	return n
}

func (m *Egress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Nickname)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	l = len(m.Peer)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	if len(m.PowerFlags) > 0 {
		for _, s := range m.PowerFlags {
			l = len(s)
			n += 1 + l + sovSwingset(uint64(l))
		}
	}
	return n
}

func (m *SwingStoreArtifact) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovSwingset(uint64(l))
	}
	return n
}

func sovSwingset(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSwingset(x uint64) (n int) {
	return sovSwingset(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *CoreEvalProposal) 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 ErrIntOverflowSwingset
			}
			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: CoreEvalProposal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CoreEvalProposal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Evals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Evals = append(m.Evals, CoreEval{})
			if err := m.Evals[len(m.Evals)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CoreEval) 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 ErrIntOverflowSwingset
			}
			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: CoreEval: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CoreEval: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JsonPermits", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JsonPermits = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JsCode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JsCode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
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 ErrIntOverflowSwingset
			}
			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 BeansPerUnit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BeansPerUnit = append(m.BeansPerUnit, StringBeans{})
			if err := m.BeansPerUnit[len(m.BeansPerUnit)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeeUnitPrice", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeeUnitPrice = append(m.FeeUnitPrice, types.Coin{})
			if err := m.FeeUnitPrice[len(m.FeeUnitPrice)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BootstrapVatConfig", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BootstrapVatConfig = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PowerFlagFees", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PowerFlagFees = append(m.PowerFlagFees, PowerFlagFee{})
			if err := m.PowerFlagFees[len(m.PowerFlagFees)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueMax", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueueMax = append(m.QueueMax, QueueSize{})
			if err := m.QueueMax[len(m.QueueMax)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VatCleanupBudget", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VatCleanupBudget = append(m.VatCleanupBudget, UintMapEntry{})
			if err := m.VatCleanupBudget[len(m.VatCleanupBudget)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *State) 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 ErrIntOverflowSwingset
			}
			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: State: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: State: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueAllowed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueueAllowed = append(m.QueueAllowed, QueueSize{})
			if err := m.QueueAllowed[len(m.QueueAllowed)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StringBeans) 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 ErrIntOverflowSwingset
			}
			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: StringBeans: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StringBeans: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Beans", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Beans.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PowerFlagFee) 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 ErrIntOverflowSwingset
			}
			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: PowerFlagFee: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PowerFlagFee: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PowerFlag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PowerFlag = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fee = append(m.Fee, types.Coin{})
			if err := m.Fee[len(m.Fee)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueueSize) 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 ErrIntOverflowSwingset
			}
			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: QueueSize: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueueSize: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UintMapEntry) 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 ErrIntOverflowSwingset
			}
			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: UintMapEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UintMapEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Egress) 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 ErrIntOverflowSwingset
			}
			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: Egress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Egress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nickname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nickname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Peer = append(m.Peer[:0], dAtA[iNdEx:postIndex]...)
			if m.Peer == nil {
				m.Peer = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PowerFlags", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PowerFlags = append(m.PowerFlags, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SwingStoreArtifact) 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 ErrIntOverflowSwingset
			}
			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: SwingStoreArtifact: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SwingStoreArtifact: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				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 ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSwingset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSwingset
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSwingset
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSwingset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSwingset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthSwingset        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSwingset          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSwingset = fmt.Errorf("proto: unexpected end of group")
)
