// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: cosmos/quarantine/v1beta1/quarantine.proto

package quarantine

import (
	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

// AutoResponse enumerates the quarantine auto-response options.
type AutoResponse int32

const (
	// AUTO_RESPONSE_UNSPECIFIED defines that an automatic response has not been specified.
	// This means that no automatic action should be taken, i.e. this auto-response is off,
	// and default quarantine behavior is used.
	AUTO_RESPONSE_UNSPECIFIED AutoResponse = 0
	// AUTO_RESPONSE_ACCEPT defines that sends should be automatically accepted, bypassing quarantine.
	AUTO_RESPONSE_ACCEPT AutoResponse = 1
	// AUTO_RESPONSE_DECLINE defines that sends should be automatically declined.
	AUTO_RESPONSE_DECLINE AutoResponse = 2
)

var AutoResponse_name = map[int32]string{
	0: "AUTO_RESPONSE_UNSPECIFIED",
	1: "AUTO_RESPONSE_ACCEPT",
	2: "AUTO_RESPONSE_DECLINE",
}

var AutoResponse_value = map[string]int32{
	"AUTO_RESPONSE_UNSPECIFIED": 0,
	"AUTO_RESPONSE_ACCEPT":      1,
	"AUTO_RESPONSE_DECLINE":     2,
}

func (x AutoResponse) String() string {
	return proto.EnumName(AutoResponse_name, int32(x))
}

func (AutoResponse) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0b055d4922680476, []int{0}
}

// QuarantinedFunds defines structure that represents coins that have been quarantined.
type QuarantinedFunds struct {
	// to_address is the intended recipient of the coins that have been quarantined.
	ToAddress string `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"`
	// unaccepted_from_addresses are the senders that have not been part of an accept yet for these coins.
	UnacceptedFromAddresses []string `protobuf:"bytes,2,rep,name=unaccepted_from_addresses,json=unacceptedFromAddresses,proto3" json:"unaccepted_from_addresses,omitempty"`
	// coins is the amount currently in quarantined for the two addresses.
	Coins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=coins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"coins"`
	// declined is true if these funds were previously declined.
	Declined bool `protobuf:"varint,4,opt,name=declined,proto3" json:"declined,omitempty"`
}

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

var xxx_messageInfo_QuarantinedFunds proto.InternalMessageInfo

func (m *QuarantinedFunds) GetToAddress() string {
	if m != nil {
		return m.ToAddress
	}
	return ""
}

func (m *QuarantinedFunds) GetUnacceptedFromAddresses() []string {
	if m != nil {
		return m.UnacceptedFromAddresses
	}
	return nil
}

func (m *QuarantinedFunds) GetCoins() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Coins
	}
	return nil
}

func (m *QuarantinedFunds) GetDeclined() bool {
	if m != nil {
		return m.Declined
	}
	return false
}

// AutoResponseEntry defines the auto response to one address from another.
type AutoResponseEntry struct {
	// to_address is the receiving address.
	ToAddress string `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"`
	// from_address is the sending address.
	FromAddress string `protobuf:"bytes,2,opt,name=from_address,json=fromAddress,proto3" json:"from_address,omitempty"`
	// response is the auto-response setting for these two addresses.
	Response AutoResponse `protobuf:"varint,3,opt,name=response,proto3,enum=cosmos.quarantine.v1beta1.AutoResponse" json:"response,omitempty"`
}

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

var xxx_messageInfo_AutoResponseEntry proto.InternalMessageInfo

func (m *AutoResponseEntry) GetToAddress() string {
	if m != nil {
		return m.ToAddress
	}
	return ""
}

func (m *AutoResponseEntry) GetFromAddress() string {
	if m != nil {
		return m.FromAddress
	}
	return ""
}

func (m *AutoResponseEntry) GetResponse() AutoResponse {
	if m != nil {
		return m.Response
	}
	return AUTO_RESPONSE_UNSPECIFIED
}

// AutoResponseUpdate defines a quarantine auto response update that should be applied.
type AutoResponseUpdate struct {
	// from_address is the address that funds would be coming from.
	FromAddress string `protobuf:"bytes,1,opt,name=from_address,json=fromAddress,proto3" json:"from_address,omitempty"`
	// response is the automatic action to take on funds sent from from_address.
	// Provide AUTO_RESPONSE_UNSPECIFIED to turn off an auto-response.
	Response AutoResponse `protobuf:"varint,2,opt,name=response,proto3,enum=cosmos.quarantine.v1beta1.AutoResponse" json:"response,omitempty"`
}

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

var xxx_messageInfo_AutoResponseUpdate proto.InternalMessageInfo

func (m *AutoResponseUpdate) GetFromAddress() string {
	if m != nil {
		return m.FromAddress
	}
	return ""
}

func (m *AutoResponseUpdate) GetResponse() AutoResponse {
	if m != nil {
		return m.Response
	}
	return AUTO_RESPONSE_UNSPECIFIED
}

// QuarantineRecord defines information regarding quarantined funds that is stored in state.
type QuarantineRecord struct {
	// unaccepted_from_addresses are the senders that have not been part of an accept yet for these coins.
	UnacceptedFromAddresses []github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,rep,name=unaccepted_from_addresses,json=unacceptedFromAddresses,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"unaccepted_from_addresses,omitempty"`
	// accepted_from_addresses are the senders that have already been part of an accept for these coins.
	AcceptedFromAddresses []github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,2,rep,name=accepted_from_addresses,json=acceptedFromAddresses,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"accepted_from_addresses,omitempty"`
	// coins is the amount that has been quarantined.
	Coins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=coins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"coins"`
	// declined is whether these funds have been declined.
	Declined bool `protobuf:"varint,4,opt,name=declined,proto3" json:"declined,omitempty"`
}

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

var xxx_messageInfo_QuarantineRecord proto.InternalMessageInfo

func (m *QuarantineRecord) GetUnacceptedFromAddresses() []github_com_cosmos_cosmos_sdk_types.AccAddress {
	if m != nil {
		return m.UnacceptedFromAddresses
	}
	return nil
}

func (m *QuarantineRecord) GetAcceptedFromAddresses() []github_com_cosmos_cosmos_sdk_types.AccAddress {
	if m != nil {
		return m.AcceptedFromAddresses
	}
	return nil
}

func (m *QuarantineRecord) GetCoins() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Coins
	}
	return nil
}

func (m *QuarantineRecord) GetDeclined() bool {
	if m != nil {
		return m.Declined
	}
	return false
}

// QuarantineRecordSuffixIndex defines a list of record suffixes that can be stored in state and used as an index.
type QuarantineRecordSuffixIndex struct {
	RecordSuffixes [][]byte `protobuf:"bytes,1,rep,name=record_suffixes,json=recordSuffixes,proto3" json:"record_suffixes,omitempty"`
}

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

var xxx_messageInfo_QuarantineRecordSuffixIndex proto.InternalMessageInfo

func (m *QuarantineRecordSuffixIndex) GetRecordSuffixes() [][]byte {
	if m != nil {
		return m.RecordSuffixes
	}
	return nil
}

func init() {
	proto.RegisterEnum("cosmos.quarantine.v1beta1.AutoResponse", AutoResponse_name, AutoResponse_value)
	proto.RegisterType((*QuarantinedFunds)(nil), "cosmos.quarantine.v1beta1.QuarantinedFunds")
	proto.RegisterType((*AutoResponseEntry)(nil), "cosmos.quarantine.v1beta1.AutoResponseEntry")
	proto.RegisterType((*AutoResponseUpdate)(nil), "cosmos.quarantine.v1beta1.AutoResponseUpdate")
	proto.RegisterType((*QuarantineRecord)(nil), "cosmos.quarantine.v1beta1.QuarantineRecord")
	proto.RegisterType((*QuarantineRecordSuffixIndex)(nil), "cosmos.quarantine.v1beta1.QuarantineRecordSuffixIndex")
}

func init() {
	proto.RegisterFile("cosmos/quarantine/v1beta1/quarantine.proto", fileDescriptor_0b055d4922680476)
}

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

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

func (m *QuarantinedFunds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Declined {
		i--
		if m.Declined {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.Coins) > 0 {
		for iNdEx := len(m.Coins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Coins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuarantine(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.UnacceptedFromAddresses) > 0 {
		for iNdEx := len(m.UnacceptedFromAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.UnacceptedFromAddresses[iNdEx])
			copy(dAtA[i:], m.UnacceptedFromAddresses[iNdEx])
			i = encodeVarintQuarantine(dAtA, i, uint64(len(m.UnacceptedFromAddresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintQuarantine(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AutoResponseEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != 0 {
		i = encodeVarintQuarantine(dAtA, i, uint64(m.Response))
		i--
		dAtA[i] = 0x18
	}
	if len(m.FromAddress) > 0 {
		i -= len(m.FromAddress)
		copy(dAtA[i:], m.FromAddress)
		i = encodeVarintQuarantine(dAtA, i, uint64(len(m.FromAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintQuarantine(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QuarantineRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Declined {
		i--
		if m.Declined {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.Coins) > 0 {
		for iNdEx := len(m.Coins) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Coins[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuarantine(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.AcceptedFromAddresses) > 0 {
		for iNdEx := len(m.AcceptedFromAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.AcceptedFromAddresses[iNdEx])
			copy(dAtA[i:], m.AcceptedFromAddresses[iNdEx])
			i = encodeVarintQuarantine(dAtA, i, uint64(len(m.AcceptedFromAddresses[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.UnacceptedFromAddresses) > 0 {
		for iNdEx := len(m.UnacceptedFromAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.UnacceptedFromAddresses[iNdEx])
			copy(dAtA[i:], m.UnacceptedFromAddresses[iNdEx])
			i = encodeVarintQuarantine(dAtA, i, uint64(len(m.UnacceptedFromAddresses[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *QuarantineRecordSuffixIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RecordSuffixes) > 0 {
		for iNdEx := len(m.RecordSuffixes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RecordSuffixes[iNdEx])
			copy(dAtA[i:], m.RecordSuffixes[iNdEx])
			i = encodeVarintQuarantine(dAtA, i, uint64(len(m.RecordSuffixes[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintQuarantine(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuarantine(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QuarantinedFunds) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovQuarantine(uint64(l))
	}
	if len(m.UnacceptedFromAddresses) > 0 {
		for _, s := range m.UnacceptedFromAddresses {
			l = len(s)
			n += 1 + l + sovQuarantine(uint64(l))
		}
	}
	if len(m.Coins) > 0 {
		for _, e := range m.Coins {
			l = e.Size()
			n += 1 + l + sovQuarantine(uint64(l))
		}
	}
	if m.Declined {
		n += 2
	}
	return n
}

func (m *AutoResponseEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovQuarantine(uint64(l))
	}
	l = len(m.FromAddress)
	if l > 0 {
		n += 1 + l + sovQuarantine(uint64(l))
	}
	if m.Response != 0 {
		n += 1 + sovQuarantine(uint64(m.Response))
	}
	return n
}

func (m *AutoResponseUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FromAddress)
	if l > 0 {
		n += 1 + l + sovQuarantine(uint64(l))
	}
	if m.Response != 0 {
		n += 1 + sovQuarantine(uint64(m.Response))
	}
	return n
}

func (m *QuarantineRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.UnacceptedFromAddresses) > 0 {
		for _, b := range m.UnacceptedFromAddresses {
			l = len(b)
			n += 1 + l + sovQuarantine(uint64(l))
		}
	}
	if len(m.AcceptedFromAddresses) > 0 {
		for _, b := range m.AcceptedFromAddresses {
			l = len(b)
			n += 1 + l + sovQuarantine(uint64(l))
		}
	}
	if len(m.Coins) > 0 {
		for _, e := range m.Coins {
			l = e.Size()
			n += 1 + l + sovQuarantine(uint64(l))
		}
	}
	if m.Declined {
		n += 2
	}
	return n
}

func (m *QuarantineRecordSuffixIndex) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.RecordSuffixes) > 0 {
		for _, b := range m.RecordSuffixes {
			l = len(b)
			n += 1 + l + sovQuarantine(uint64(l))
		}
	}
	return n
}

func sovQuarantine(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuarantine(x uint64) (n int) {
	return sovQuarantine(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QuarantinedFunds) 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 ErrIntOverflowQuarantine
			}
			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: QuarantinedFunds: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuarantinedFunds: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuarantine
				}
				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 ErrInvalidLengthQuarantine
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuarantine
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnacceptedFromAddresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuarantine
				}
				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 ErrInvalidLengthQuarantine
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuarantine
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnacceptedFromAddresses = append(m.UnacceptedFromAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coins", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuarantine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuarantine
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuarantine
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Coins = append(m.Coins, types.Coin{})
			if err := m.Coins[len(m.Coins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Declined", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuarantine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Declined = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQuarantine(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuarantine
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QuarantineRecord) 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 ErrIntOverflowQuarantine
			}
			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: QuarantineRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuarantineRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnacceptedFromAddresses", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuarantine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuarantine
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuarantine
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnacceptedFromAddresses = append(m.UnacceptedFromAddresses, make([]byte, postIndex-iNdEx))
			copy(m.UnacceptedFromAddresses[len(m.UnacceptedFromAddresses)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AcceptedFromAddresses", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuarantine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuarantine
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuarantine
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AcceptedFromAddresses = append(m.AcceptedFromAddresses, make([]byte, postIndex-iNdEx))
			copy(m.AcceptedFromAddresses[len(m.AcceptedFromAddresses)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coins", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuarantine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQuarantine
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQuarantine
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Coins = append(m.Coins, types.Coin{})
			if err := m.Coins[len(m.Coins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Declined", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuarantine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Declined = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQuarantine(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuarantine
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthQuarantine        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuarantine          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuarantine = fmt.Errorf("proto: unexpected end of group")
)
