// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: x/apps/apps.proto

package types

import (
	bytes "bytes"
	compress_gzip "compress/gzip"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "github.com/golang/protobuf/ptypes/timestamp"
	github_com_pokt_network_pocket_core_types "github.com/pokt-network/pocket-core/types"
	io "io"
	io_ioutil "io/ioutil"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// 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

// Application defines the total amount of bond shares and their exchange rate to
// coins. Slashing results in a decrease in the exchange rate, allowing correct
// calculation of future undelegations without iterating over delegators.
// When coins are delegated to this validator, the validator is credited with a
// delegation whose number of bond shares is based on the amount of coins
// delegated divided by the current exchange rate. Voting power can be
// calculated as total bonded shares multiplied by exchange rate.
type ProtoApplication struct {
	Address                 github_com_pokt_network_pocket_core_types.Address     `protobuf:"bytes,1,opt,name=address,proto3,casttype=github.com/pokt-network/pocket-core/types.Address" json:"address" yaml:"address"`
	PublicKey               []byte                                                `protobuf:"bytes,2,opt,name=public_key,json=publicKey,proto3" json:"public_key" yaml:"public_key"`
	Jailed                  bool                                                  `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed" yaml:"jailed"`
	Status                  github_com_pokt_network_pocket_core_types.StakeStatus `protobuf:"varint,4,opt,name=status,proto3,casttype=github.com/pokt-network/pocket-core/types.StakeStatus" json:"status" yaml:"status"`
	Chains                  []string                                              `protobuf:"bytes,5,rep,name=chains,proto3" json:"chains" yaml:"chains"`
	StakedTokens            github_com_pokt_network_pocket_core_types.BigInt      `protobuf:"bytes,6,opt,name=staked_tokens,json=stakedTokens,proto3,customtype=github.com/pokt-network/pocket-core/types.BigInt" json:"tokens" yaml:"tokens"`
	MaxRelays               github_com_pokt_network_pocket_core_types.BigInt      `protobuf:"bytes,7,opt,name=max_relays,json=maxRelays,proto3,customtype=github.com/pokt-network/pocket-core/types.BigInt" json:"max_relays" yaml:"max_relays"`
	UnstakingCompletionTime time.Time                                             `protobuf:"bytes,8,opt,name=unstaking_completion_time,json=unstakingCompletionTime,proto3,stdtime" json:"unstaking_time" yaml:"unstaking_time"`
}

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

var xxx_messageInfo_ProtoApplication proto.InternalMessageInfo

// Pool - tracking bonded and not-bonded token supply of the bond denomination
type Pool struct {
	Tokens github_com_pokt_network_pocket_core_types.BigInt `protobuf:"bytes,1,opt,name=tokens,proto3,customtype=github.com/pokt-network/pocket-core/types.BigInt" json:"tokens"`
}

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

var xxx_messageInfo_Pool proto.InternalMessageInfo

func init() {
	proto.RegisterType((*ProtoApplication)(nil), "x.apps.ProtoApplication")
	proto.RegisterType((*Pool)(nil), "x.apps.Pool")
}

func init() { proto.RegisterFile("x/apps/apps.proto", fileDescriptor_5d5a21b1d350fd62) }

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

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

	that1, ok := that.(*ProtoApplication)
	if !ok {
		that2, ok := that.(ProtoApplication)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Address, that1.Address) {
		return false
	}
	if !bytes.Equal(this.PublicKey, that1.PublicKey) {
		return false
	}
	if this.Jailed != that1.Jailed {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if len(this.Chains) != len(that1.Chains) {
		return false
	}
	for i := range this.Chains {
		if this.Chains[i] != that1.Chains[i] {
			return false
		}
	}
	if !this.StakedTokens.Equal(that1.StakedTokens) {
		return false
	}
	if !this.MaxRelays.Equal(that1.MaxRelays) {
		return false
	}
	if !this.UnstakingCompletionTime.Equal(that1.UnstakingCompletionTime) {
		return false
	}
	return true
}
func (this *Pool) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

func (m *ProtoApplication) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UnstakingCompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UnstakingCompletionTime):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintApps(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x42
	{
		size := m.MaxRelays.Size()
		i -= size
		if _, err := m.MaxRelays.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintApps(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.StakedTokens.Size()
		i -= size
		if _, err := m.StakedTokens.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintApps(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if len(m.Chains) > 0 {
		for iNdEx := len(m.Chains) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Chains[iNdEx])
			copy(dAtA[i:], m.Chains[iNdEx])
			i = encodeVarintApps(dAtA, i, uint64(len(m.Chains[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Status != 0 {
		i = encodeVarintApps(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x20
	}
	if m.Jailed {
		i--
		if m.Jailed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintApps(dAtA, i, uint64(len(m.PublicKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintApps(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Tokens.Size()
		i -= size
		if _, err := m.Tokens.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintApps(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintApps(dAtA []byte, offset int, v uint64) int {
	offset -= sovApps(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ProtoApplication) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovApps(uint64(l))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovApps(uint64(l))
	}
	if m.Jailed {
		n += 2
	}
	if m.Status != 0 {
		n += 1 + sovApps(uint64(m.Status))
	}
	if len(m.Chains) > 0 {
		for _, s := range m.Chains {
			l = len(s)
			n += 1 + l + sovApps(uint64(l))
		}
	}
	l = m.StakedTokens.Size()
	n += 1 + l + sovApps(uint64(l))
	l = m.MaxRelays.Size()
	n += 1 + l + sovApps(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UnstakingCompletionTime)
	n += 1 + l + sovApps(uint64(l))
	return n
}

func (m *Pool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Tokens.Size()
	n += 1 + l + sovApps(uint64(l))
	return n
}

func sovApps(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozApps(x uint64) (n int) {
	return sovApps(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ProtoApplication) 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 ErrIntOverflowApps
			}
			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: ProtoApplication: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProtoApplication: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApps
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApps
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthApps
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
			if m.Address == nil {
				m.Address = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApps
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApps
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthApps
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicKey == nil {
				m.PublicKey = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Jailed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApps
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Jailed = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApps
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= github_com_pokt_network_pocket_core_types.StakeStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chains", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApps
				}
				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 ErrInvalidLengthApps
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApps
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chains = append(m.Chains, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakedTokens", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApps
				}
				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 ErrInvalidLengthApps
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApps
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.StakedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRelays", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApps
				}
				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 ErrInvalidLengthApps
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthApps
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxRelays.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnstakingCompletionTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApps
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApps
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApps
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UnstakingCompletionTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApps(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApps
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApps
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthApps        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApps          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupApps = fmt.Errorf("proto: unexpected end of group")
)
