types/v2/go/result.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: result.proto

package pb

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type Error_Code int32

const (
	Error_UNKNOWN_CODE Error_Code = 0
	Error_NOT_FOUND    Error_Code = 1
	Error_INVALID      Error_Code = 2
	Error_BLOCKED      Error_Code = 3
)

var Error_Code_name = map[int32]string{
	0: "UNKNOWN_CODE",
	1: "NOT_FOUND",
	2: "INVALID",
	3: "BLOCKED",
}

var Error_Code_value = map[string]int32{
	"UNKNOWN_CODE": 0,
	"NOT_FOUND":    1,
	"INVALID":      2,
	"BLOCKED":      3,
}

func (x Error_Code) String() string {
	return proto.EnumName(Error_Code_name, int32(x))
}

func (Error_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4feee897733d2100, []int{3, 0}
}

type Outputs struct {
	Txos                 []*Output  `protobuf:"bytes,1,rep,name=txos,proto3" json:"txos"`
	ExtraTxos            []*Output  `protobuf:"bytes,2,rep,name=extra_txos,json=extraTxos,proto3" json:"extra_txos"`
	Total                uint32     `protobuf:"varint,3,opt,name=total,proto3" json:"total"`
	Offset               uint32     `protobuf:"varint,4,opt,name=offset,proto3" json:"offset"`
	Blocked              []*Blocked `protobuf:"bytes,5,rep,name=blocked,proto3" json:"blocked"`
	BlockedTotal         uint32     `protobuf:"varint,6,opt,name=blocked_total,json=blockedTotal,proto3" json:"blocked_total"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *Outputs) Reset()         { *m = Outputs{} }
func (m *Outputs) String() string { return proto.CompactTextString(m) }
func (*Outputs) ProtoMessage()    {}
func (*Outputs) Descriptor() ([]byte, []int) {
	return fileDescriptor_4feee897733d2100, []int{0}
}

func (m *Outputs) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Outputs.Unmarshal(m, b)
}
func (m *Outputs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Outputs.Marshal(b, m, deterministic)
}
func (m *Outputs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Outputs.Merge(m, src)
}
func (m *Outputs) XXX_Size() int {
	return xxx_messageInfo_Outputs.Size(m)
}
func (m *Outputs) XXX_DiscardUnknown() {
	xxx_messageInfo_Outputs.DiscardUnknown(m)
}

var xxx_messageInfo_Outputs proto.InternalMessageInfo

func (m *Outputs) GetTxos() []*Output {
	if m != nil {
		return m.Txos
	}
	return nil
}

func (m *Outputs) GetExtraTxos() []*Output {
	if m != nil {
		return m.ExtraTxos
	}
	return nil
}

func (m *Outputs) GetTotal() uint32 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *Outputs) GetOffset() uint32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *Outputs) GetBlocked() []*Blocked {
	if m != nil {
		return m.Blocked
	}
	return nil
}

func (m *Outputs) GetBlockedTotal() uint32 {
	if m != nil {
		return m.BlockedTotal
	}
	return 0
}

type Output struct {
	TxHash []byte `protobuf:"bytes,1,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash"`
	Nout   uint32 `protobuf:"varint,2,opt,name=nout,proto3" json:"nout"`
	Height uint32 `protobuf:"varint,3,opt,name=height,proto3" json:"height"`
	// Types that are valid to be assigned to Meta:
	//	*Output_Claim
	//	*Output_Error
	Meta                 isOutput_Meta `protobuf_oneof:"meta"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Output) Reset()         { *m = Output{} }
func (m *Output) String() string { return proto.CompactTextString(m) }
func (*Output) ProtoMessage()    {}
func (*Output) Descriptor() ([]byte, []int) {
	return fileDescriptor_4feee897733d2100, []int{1}
}

func (m *Output) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Output.Unmarshal(m, b)
}
func (m *Output) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Output.Marshal(b, m, deterministic)
}
func (m *Output) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Output.Merge(m, src)
}
func (m *Output) XXX_Size() int {
	return xxx_messageInfo_Output.Size(m)
}
func (m *Output) XXX_DiscardUnknown() {
	xxx_messageInfo_Output.DiscardUnknown(m)
}

var xxx_messageInfo_Output proto.InternalMessageInfo

func (m *Output) GetTxHash() []byte {
	if m != nil {
		return m.TxHash
	}
	return nil
}

func (m *Output) GetNout() uint32 {
	if m != nil {
		return m.Nout
	}
	return 0
}

func (m *Output) GetHeight() uint32 {
	if m != nil {
		return m.Height
	}
	return 0
}

type isOutput_Meta interface {
	isOutput_Meta()
}

type Output_Claim struct {
	Claim *ClaimMeta `protobuf:"bytes,7,opt,name=claim,proto3,oneof"`
}

type Output_Error struct {
	Error *Error `protobuf:"bytes,15,opt,name=error,proto3,oneof"`
}

func (*Output_Claim) isOutput_Meta() {}

func (*Output_Error) isOutput_Meta() {}

func (m *Output) GetMeta() isOutput_Meta {
	if m != nil {
		return m.Meta
	}
	return nil
}

func (m *Output) GetClaim() *ClaimMeta {
	if x, ok := m.GetMeta().(*Output_Claim); ok {
		return x.Claim
	}
	return nil
}

func (m *Output) GetError() *Error {
	if x, ok := m.GetMeta().(*Output_Error); ok {
		return x.Error
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Output) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Output_Claim)(nil),
		(*Output_Error)(nil),
	}
}

type ClaimMeta struct {
	Channel              *Output  `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel"`
	Repost               *Output  `protobuf:"bytes,2,opt,name=repost,proto3" json:"repost"`
	ShortUrl             string   `protobuf:"bytes,3,opt,name=short_url,json=shortUrl,proto3" json:"short_url"`
	CanonicalUrl         string   `protobuf:"bytes,4,opt,name=canonical_url,json=canonicalUrl,proto3" json:"canonical_url"`
	IsControlling        bool     `protobuf:"varint,5,opt,name=is_controlling,json=isControlling,proto3" json:"is_controlling"`
	TakeOverHeight       uint32   `protobuf:"varint,6,opt,name=take_over_height,json=takeOverHeight,proto3" json:"take_over_height"`
	CreationHeight       uint32   `protobuf:"varint,7,opt,name=creation_height,json=creationHeight,proto3" json:"creation_height"`
	ActivationHeight     uint32   `protobuf:"varint,8,opt,name=activation_height,json=activationHeight,proto3" json:"activation_height"`
	ExpirationHeight     uint32   `protobuf:"varint,9,opt,name=expiration_height,json=expirationHeight,proto3" json:"expiration_height"`
	ClaimsInChannel      uint32   `protobuf:"varint,10,opt,name=claims_in_channel,json=claimsInChannel,proto3" json:"claims_in_channel"`
	Reposted             uint32   `protobuf:"varint,11,opt,name=reposted,proto3" json:"reposted"`
	EffectiveAmount      uint64   `protobuf:"varint,20,opt,name=effective_amount,json=effectiveAmount,proto3" json:"effective_amount"`
	SupportAmount        uint64   `protobuf:"varint,21,opt,name=support_amount,json=supportAmount,proto3" json:"support_amount"`
	TrendingGroup        uint32   `protobuf:"varint,22,opt,name=trending_group,json=trendingGroup,proto3" json:"trending_group"`
	TrendingMixed        float32  `protobuf:"fixed32,23,opt,name=trending_mixed,json=trendingMixed,proto3" json:"trending_mixed"`
	TrendingLocal        float32  `protobuf:"fixed32,24,opt,name=trending_local,json=trendingLocal,proto3" json:"trending_local"`
	TrendingGlobal       float32  `protobuf:"fixed32,25,opt,name=trending_global,json=trendingGlobal,proto3" json:"trending_global"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClaimMeta) Reset()         { *m = ClaimMeta{} }
func (m *ClaimMeta) String() string { return proto.CompactTextString(m) }
func (*ClaimMeta) ProtoMessage()    {}
func (*ClaimMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_4feee897733d2100, []int{2}
}

func (m *ClaimMeta) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClaimMeta.Unmarshal(m, b)
}
func (m *ClaimMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClaimMeta.Marshal(b, m, deterministic)
}
func (m *ClaimMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClaimMeta.Merge(m, src)
}
func (m *ClaimMeta) XXX_Size() int {
	return xxx_messageInfo_ClaimMeta.Size(m)
}
func (m *ClaimMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_ClaimMeta.DiscardUnknown(m)
}

var xxx_messageInfo_ClaimMeta proto.InternalMessageInfo

func (m *ClaimMeta) GetChannel() *Output {
	if m != nil {
		return m.Channel
	}
	return nil
}

func (m *ClaimMeta) GetRepost() *Output {
	if m != nil {
		return m.Repost
	}
	return nil
}

func (m *ClaimMeta) GetShortUrl() string {
	if m != nil {
		return m.ShortUrl
	}
	return ""
}

func (m *ClaimMeta) GetCanonicalUrl() string {
	if m != nil {
		return m.CanonicalUrl
	}
	return ""
}

func (m *ClaimMeta) GetIsControlling() bool {
	if m != nil {
		return m.IsControlling
	}
	return false
}

func (m *ClaimMeta) GetTakeOverHeight() uint32 {
	if m != nil {
		return m.TakeOverHeight
	}
	return 0
}

func (m *ClaimMeta) GetCreationHeight() uint32 {
	if m != nil {
		return m.CreationHeight
	}
	return 0
}

func (m *ClaimMeta) GetActivationHeight() uint32 {
	if m != nil {
		return m.ActivationHeight
	}
	return 0
}

func (m *ClaimMeta) GetExpirationHeight() uint32 {
	if m != nil {
		return m.ExpirationHeight
	}
	return 0
}

func (m *ClaimMeta) GetClaimsInChannel() uint32 {
	if m != nil {
		return m.ClaimsInChannel
	}
	return 0
}

func (m *ClaimMeta) GetReposted() uint32 {
	if m != nil {
		return m.Reposted
	}
	return 0
}

func (m *ClaimMeta) GetEffectiveAmount() uint64 {
	if m != nil {
		return m.EffectiveAmount
	}
	return 0
}

func (m *ClaimMeta) GetSupportAmount() uint64 {
	if m != nil {
		return m.SupportAmount
	}
	return 0
}

func (m *ClaimMeta) GetTrendingGroup() uint32 {
	if m != nil {
		return m.TrendingGroup
	}
	return 0
}

func (m *ClaimMeta) GetTrendingMixed() float32 {
	if m != nil {
		return m.TrendingMixed
	}
	return 0
}

func (m *ClaimMeta) GetTrendingLocal() float32 {
	if m != nil {
		return m.TrendingLocal
	}
	return 0
}

func (m *ClaimMeta) GetTrendingGlobal() float32 {
	if m != nil {
		return m.TrendingGlobal
	}
	return 0
}

type Error struct {
	Code                 Error_Code `protobuf:"varint,1,opt,name=code,proto3,enum=pb.Error_Code" json:"code"`
	Text                 string     `protobuf:"bytes,2,opt,name=text,proto3" json:"text"`
	Blocked              *Blocked   `protobuf:"bytes,3,opt,name=blocked,proto3" json:"blocked"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *Error) Reset()         { *m = Error{} }
func (m *Error) String() string { return proto.CompactTextString(m) }
func (*Error) ProtoMessage()    {}
func (*Error) Descriptor() ([]byte, []int) {
	return fileDescriptor_4feee897733d2100, []int{3}
}

func (m *Error) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Error.Unmarshal(m, b)
}
func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Error.Marshal(b, m, deterministic)
}
func (m *Error) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Error.Merge(m, src)
}
func (m *Error) XXX_Size() int {
	return xxx_messageInfo_Error.Size(m)
}
func (m *Error) XXX_DiscardUnknown() {
	xxx_messageInfo_Error.DiscardUnknown(m)
}

var xxx_messageInfo_Error proto.InternalMessageInfo

func (m *Error) GetCode() Error_Code {
	if m != nil {
		return m.Code
	}
	return Error_UNKNOWN_CODE
}

func (m *Error) GetText() string {
	if m != nil {
		return m.Text
	}
	return ""
}

func (m *Error) GetBlocked() *Blocked {
	if m != nil {
		return m.Blocked
	}
	return nil
}

type Blocked struct {
	Count                uint32   `protobuf:"varint,1,opt,name=count,proto3" json:"count"`
	Channel              *Output  `protobuf:"bytes,2,opt,name=channel,proto3" json:"channel"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Blocked) Reset()         { *m = Blocked{} }
func (m *Blocked) String() string { return proto.CompactTextString(m) }
func (*Blocked) ProtoMessage()    {}
func (*Blocked) Descriptor() ([]byte, []int) {
	return fileDescriptor_4feee897733d2100, []int{4}
}

func (m *Blocked) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Blocked.Unmarshal(m, b)
}
func (m *Blocked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Blocked.Marshal(b, m, deterministic)
}
func (m *Blocked) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Blocked.Merge(m, src)
}
func (m *Blocked) XXX_Size() int {
	return xxx_messageInfo_Blocked.Size(m)
}
func (m *Blocked) XXX_DiscardUnknown() {
	xxx_messageInfo_Blocked.DiscardUnknown(m)
}

var xxx_messageInfo_Blocked proto.InternalMessageInfo

func (m *Blocked) GetCount() uint32 {
	if m != nil {
		return m.Count
	}
	return 0
}

func (m *Blocked) GetChannel() *Output {
	if m != nil {
		return m.Channel
	}
	return nil
}

func init() {
	proto.RegisterEnum("pb.Error_Code", Error_Code_name, Error_Code_value)
	proto.RegisterType((*Outputs)(nil), "pb.Outputs")
	proto.RegisterType((*Output)(nil), "pb.Output")
	proto.RegisterType((*ClaimMeta)(nil), "pb.ClaimMeta")
	proto.RegisterType((*Error)(nil), "pb.Error")
	proto.RegisterType((*Blocked)(nil), "pb.Blocked")
}

func init() { proto.RegisterFile("result.proto", fileDescriptor_4feee897733d2100) }

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