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

/*
Package types is a generated protocol buffer package.

It is generated from these files:
	token.proto

It has these top-level messages:
	TokenAction
	TokenPreCreate
	TokenFinishCreate
	TokenRevokeCreate
	Token
	ReceiptToken
	LocalToken
	ReqTokens
	ReplyTokens
	TokenRecv
	ReplyAddrRecvForTokens
	ReqTokenBalance
	ReqAccountTokenAssets
	TokenAsset
	ReplyAccountTokenAssets
	ReqAddrTokens
	ReqTokenTx
*/
package types

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import types2 "gitlab.33.cn/chain33/chain33/types"
import types3 "gitlab.33.cn/chain33/chain33/types"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

// action
type TokenAction struct {
	// Types that are valid to be assigned to Value:
	//	*TokenAction_TokenPreCreate
	//	*TokenAction_TokenFinishCreate
	//	*TokenAction_TokenRevokeCreate
	//	*TokenAction_Transfer
	//	*TokenAction_Withdraw
	//	*TokenAction_Genesis
	//	*TokenAction_TransferToExec
	Value isTokenAction_Value `protobuf_oneof:"value"`
	Ty    int32               `protobuf:"varint,7,opt,name=Ty" json:"Ty,omitempty"`
}

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

type isTokenAction_Value interface {
	isTokenAction_Value()
}

type TokenAction_TokenPreCreate struct {
	TokenPreCreate *TokenPreCreate `protobuf:"bytes,1,opt,name=tokenPreCreate,oneof"`
}
type TokenAction_TokenFinishCreate struct {
	TokenFinishCreate *TokenFinishCreate `protobuf:"bytes,2,opt,name=tokenFinishCreate,oneof"`
}
type TokenAction_TokenRevokeCreate struct {
	TokenRevokeCreate *TokenRevokeCreate `protobuf:"bytes,3,opt,name=tokenRevokeCreate,oneof"`
}
type TokenAction_Transfer struct {
	Transfer *types2.AssetsTransfer `protobuf:"bytes,4,opt,name=transfer,oneof"`
}
type TokenAction_Withdraw struct {
	Withdraw *types2.AssetsWithdraw `protobuf:"bytes,5,opt,name=withdraw,oneof"`
}
type TokenAction_Genesis struct {
	Genesis *types2.AssetsGenesis `protobuf:"bytes,6,opt,name=genesis,oneof"`
}
type TokenAction_TransferToExec struct {
	TransferToExec *types2.AssetsTransferToExec `protobuf:"bytes,8,opt,name=transferToExec,oneof"`
}

func (*TokenAction_TokenPreCreate) isTokenAction_Value()    {}
func (*TokenAction_TokenFinishCreate) isTokenAction_Value() {}
func (*TokenAction_TokenRevokeCreate) isTokenAction_Value() {}
func (*TokenAction_Transfer) isTokenAction_Value()          {}
func (*TokenAction_Withdraw) isTokenAction_Value()          {}
func (*TokenAction_Genesis) isTokenAction_Value()           {}
func (*TokenAction_TransferToExec) isTokenAction_Value()    {}

func (m *TokenAction) GetValue() isTokenAction_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *TokenAction) GetTokenPreCreate() *TokenPreCreate {
	if x, ok := m.GetValue().(*TokenAction_TokenPreCreate); ok {
		return x.TokenPreCreate
	}
	return nil
}

func (m *TokenAction) GetTokenFinishCreate() *TokenFinishCreate {
	if x, ok := m.GetValue().(*TokenAction_TokenFinishCreate); ok {
		return x.TokenFinishCreate
	}
	return nil
}

func (m *TokenAction) GetTokenRevokeCreate() *TokenRevokeCreate {
	if x, ok := m.GetValue().(*TokenAction_TokenRevokeCreate); ok {
		return x.TokenRevokeCreate
	}
	return nil
}

func (m *TokenAction) GetTransfer() *types2.AssetsTransfer {
	if x, ok := m.GetValue().(*TokenAction_Transfer); ok {
		return x.Transfer
	}
	return nil
}

func (m *TokenAction) GetWithdraw() *types2.AssetsWithdraw {
	if x, ok := m.GetValue().(*TokenAction_Withdraw); ok {
		return x.Withdraw
	}
	return nil
}

func (m *TokenAction) GetGenesis() *types2.AssetsGenesis {
	if x, ok := m.GetValue().(*TokenAction_Genesis); ok {
		return x.Genesis
	}
	return nil
}

func (m *TokenAction) GetTransferToExec() *types2.AssetsTransferToExec {
	if x, ok := m.GetValue().(*TokenAction_TransferToExec); ok {
		return x.TransferToExec
	}
	return nil
}

func (m *TokenAction) GetTy() int32 {
	if m != nil {
		return m.Ty
	}
	return 0
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TokenAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TokenAction_OneofMarshaler, _TokenAction_OneofUnmarshaler, _TokenAction_OneofSizer, []interface{}{
		(*TokenAction_TokenPreCreate)(nil),
		(*TokenAction_TokenFinishCreate)(nil),
		(*TokenAction_TokenRevokeCreate)(nil),
		(*TokenAction_Transfer)(nil),
		(*TokenAction_Withdraw)(nil),
		(*TokenAction_Genesis)(nil),
		(*TokenAction_TransferToExec)(nil),
	}
}

func _TokenAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TokenAction)
	// value
	switch x := m.Value.(type) {
	case *TokenAction_TokenPreCreate:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TokenPreCreate); err != nil {
			return err
		}
	case *TokenAction_TokenFinishCreate:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TokenFinishCreate); err != nil {
			return err
		}
	case *TokenAction_TokenRevokeCreate:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TokenRevokeCreate); err != nil {
			return err
		}
	case *TokenAction_Transfer:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Transfer); err != nil {
			return err
		}
	case *TokenAction_Withdraw:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Withdraw); err != nil {
			return err
		}
	case *TokenAction_Genesis:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Genesis); err != nil {
			return err
		}
	case *TokenAction_TransferToExec:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TransferToExec); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("TokenAction.Value has unexpected type %T", x)
	}
	return nil
}

func _TokenAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TokenAction)
	switch tag {
	case 1: // value.tokenPreCreate
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TokenPreCreate)
		err := b.DecodeMessage(msg)
		m.Value = &TokenAction_TokenPreCreate{msg}
		return true, err
	case 2: // value.tokenFinishCreate
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TokenFinishCreate)
		err := b.DecodeMessage(msg)
		m.Value = &TokenAction_TokenFinishCreate{msg}
		return true, err
	case 3: // value.tokenRevokeCreate
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TokenRevokeCreate)
		err := b.DecodeMessage(msg)
		m.Value = &TokenAction_TokenRevokeCreate{msg}
		return true, err
	case 4: // value.transfer
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types2.AssetsTransfer)
		err := b.DecodeMessage(msg)
		m.Value = &TokenAction_Transfer{msg}
		return true, err
	case 5: // value.withdraw
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types2.AssetsWithdraw)
		err := b.DecodeMessage(msg)
		m.Value = &TokenAction_Withdraw{msg}
		return true, err
	case 6: // value.genesis
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types2.AssetsGenesis)
		err := b.DecodeMessage(msg)
		m.Value = &TokenAction_Genesis{msg}
		return true, err
	case 8: // value.transferToExec
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types2.AssetsTransferToExec)
		err := b.DecodeMessage(msg)
		m.Value = &TokenAction_TransferToExec{msg}
		return true, err
	default:
		return false, nil
	}
}

func _TokenAction_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TokenAction)
	// value
	switch x := m.Value.(type) {
	case *TokenAction_TokenPreCreate:
		s := proto.Size(x.TokenPreCreate)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TokenAction_TokenFinishCreate:
		s := proto.Size(x.TokenFinishCreate)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TokenAction_TokenRevokeCreate:
		s := proto.Size(x.TokenRevokeCreate)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TokenAction_Transfer:
		s := proto.Size(x.Transfer)
		n += proto.SizeVarint(4<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TokenAction_Withdraw:
		s := proto.Size(x.Withdraw)
		n += proto.SizeVarint(5<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TokenAction_Genesis:
		s := proto.Size(x.Genesis)
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TokenAction_TransferToExec:
		s := proto.Size(x.TransferToExec)
		n += proto.SizeVarint(8<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// 创建token，支持最大精确度是8位小数,即存入数据库的实际总额需要放大1e8倍
type TokenPreCreate struct {
	Name         string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Symbol       string `protobuf:"bytes,2,opt,name=symbol" json:"symbol,omitempty"`
	Introduction string `protobuf:"bytes,3,opt,name=introduction" json:"introduction,omitempty"`
	Total        int64  `protobuf:"varint,4,opt,name=total" json:"total,omitempty"`
	Price        int64  `protobuf:"varint,5,opt,name=price" json:"price,omitempty"`
	Owner        string `protobuf:"bytes,6,opt,name=owner" json:"owner,omitempty"`
}

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

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

func (m *TokenPreCreate) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *TokenPreCreate) GetIntroduction() string {
	if m != nil {
		return m.Introduction
	}
	return ""
}

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

func (m *TokenPreCreate) GetPrice() int64 {
	if m != nil {
		return m.Price
	}
	return 0
}

func (m *TokenPreCreate) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

type TokenFinishCreate struct {
	Symbol string `protobuf:"bytes,1,opt,name=symbol" json:"symbol,omitempty"`
	Owner  string `protobuf:"bytes,2,opt,name=owner" json:"owner,omitempty"`
}

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

func (m *TokenFinishCreate) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *TokenFinishCreate) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

type TokenRevokeCreate struct {
	Symbol string `protobuf:"bytes,1,opt,name=symbol" json:"symbol,omitempty"`
	Owner  string `protobuf:"bytes,2,opt,name=owner" json:"owner,omitempty"`
}

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

func (m *TokenRevokeCreate) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *TokenRevokeCreate) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

// state db
type Token struct {
	Name         string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Symbol       string `protobuf:"bytes,2,opt,name=symbol" json:"symbol,omitempty"`
	Introduction string `protobuf:"bytes,3,opt,name=introduction" json:"introduction,omitempty"`
	Total        int64  `protobuf:"varint,4,opt,name=total" json:"total,omitempty"`
	Price        int64  `protobuf:"varint,5,opt,name=price" json:"price,omitempty"`
	Owner        string `protobuf:"bytes,6,opt,name=owner" json:"owner,omitempty"`
	Creator      string `protobuf:"bytes,7,opt,name=creator" json:"creator,omitempty"`
	Status       int32  `protobuf:"varint,8,opt,name=status" json:"status,omitempty"`
}

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

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

func (m *Token) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *Token) GetIntroduction() string {
	if m != nil {
		return m.Introduction
	}
	return ""
}

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

func (m *Token) GetPrice() int64 {
	if m != nil {
		return m.Price
	}
	return 0
}

func (m *Token) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *Token) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *Token) GetStatus() int32 {
	if m != nil {
		return m.Status
	}
	return 0
}

// log
type ReceiptToken struct {
	Symbol string `protobuf:"bytes,1,opt,name=symbol" json:"symbol,omitempty"`
	Owner  string `protobuf:"bytes,2,opt,name=owner" json:"owner,omitempty"`
	Status int32  `protobuf:"varint,3,opt,name=status" json:"status,omitempty"`
}

func (m *ReceiptToken) Reset()                    { *m = ReceiptToken{} }
func (m *ReceiptToken) String() string            { return proto.CompactTextString(m) }
func (*ReceiptToken) ProtoMessage()               {}
func (*ReceiptToken) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

func (m *ReceiptToken) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *ReceiptToken) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *ReceiptToken) GetStatus() int32 {
	if m != nil {
		return m.Status
	}
	return 0
}

// local
type LocalToken struct {
	Name                string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Symbol              string `protobuf:"bytes,2,opt,name=symbol" json:"symbol,omitempty"`
	Introduction        string `protobuf:"bytes,3,opt,name=introduction" json:"introduction,omitempty"`
	Total               int64  `protobuf:"varint,4,opt,name=total" json:"total,omitempty"`
	Price               int64  `protobuf:"varint,5,opt,name=price" json:"price,omitempty"`
	Owner               string `protobuf:"bytes,6,opt,name=owner" json:"owner,omitempty"`
	Creator             string `protobuf:"bytes,7,opt,name=creator" json:"creator,omitempty"`
	Status              int32  `protobuf:"varint,8,opt,name=status" json:"status,omitempty"`
	CreatedHeight       int64  `protobuf:"varint,9,opt,name=createdHeight" json:"createdHeight,omitempty"`
	CreatedTime         int64  `protobuf:"varint,10,opt,name=createdTime" json:"createdTime,omitempty"`
	PrepareCreateHeight int64  `protobuf:"varint,11,opt,name=prepareCreateHeight" json:"prepareCreateHeight,omitempty"`
	PrepareCreateTime   int64  `protobuf:"varint,12,opt,name=prepareCreateTime" json:"prepareCreateTime,omitempty"`
	Precision           int32  `protobuf:"varint,13,opt,name=precision" json:"precision,omitempty"`
	// 如果需要这个项可以单独做一个域存储
	TotalTransferTimes int64 `protobuf:"varint,14,opt,name=totalTransferTimes" json:"totalTransferTimes,omitempty"`
	RevokedHeight      int64 `protobuf:"varint,15,opt,name=revokedHeight" json:"revokedHeight,omitempty"`
	RevokedTime        int64 `protobuf:"varint,16,opt,name=revokedTime" json:"revokedTime,omitempty"`
}

func (m *LocalToken) Reset()                    { *m = LocalToken{} }
func (m *LocalToken) String() string            { return proto.CompactTextString(m) }
func (*LocalToken) ProtoMessage()               {}
func (*LocalToken) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }

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

func (m *LocalToken) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *LocalToken) GetIntroduction() string {
	if m != nil {
		return m.Introduction
	}
	return ""
}

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

func (m *LocalToken) GetPrice() int64 {
	if m != nil {
		return m.Price
	}
	return 0
}

func (m *LocalToken) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *LocalToken) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *LocalToken) GetStatus() int32 {
	if m != nil {
		return m.Status
	}
	return 0
}

func (m *LocalToken) GetCreatedHeight() int64 {
	if m != nil {
		return m.CreatedHeight
	}
	return 0
}

func (m *LocalToken) GetCreatedTime() int64 {
	if m != nil {
		return m.CreatedTime
	}
	return 0
}

func (m *LocalToken) GetPrepareCreateHeight() int64 {
	if m != nil {
		return m.PrepareCreateHeight
	}
	return 0
}

func (m *LocalToken) GetPrepareCreateTime() int64 {
	if m != nil {
		return m.PrepareCreateTime
	}
	return 0
}

func (m *LocalToken) GetPrecision() int32 {
	if m != nil {
		return m.Precision
	}
	return 0
}

func (m *LocalToken) GetTotalTransferTimes() int64 {
	if m != nil {
		return m.TotalTransferTimes
	}
	return 0
}

func (m *LocalToken) GetRevokedHeight() int64 {
	if m != nil {
		return m.RevokedHeight
	}
	return 0
}

func (m *LocalToken) GetRevokedTime() int64 {
	if m != nil {
		return m.RevokedTime
	}
	return 0
}

// query
type ReqTokens struct {
	QueryAll   bool     `protobuf:"varint,1,opt,name=queryAll" json:"queryAll,omitempty"`
	Status     int32    `protobuf:"varint,2,opt,name=status" json:"status,omitempty"`
	Tokens     []string `protobuf:"bytes,3,rep,name=tokens" json:"tokens,omitempty"`
	SymbolOnly bool     `protobuf:"varint,4,opt,name=symbolOnly" json:"symbolOnly,omitempty"`
}

func (m *ReqTokens) Reset()                    { *m = ReqTokens{} }
func (m *ReqTokens) String() string            { return proto.CompactTextString(m) }
func (*ReqTokens) ProtoMessage()               {}
func (*ReqTokens) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }

func (m *ReqTokens) GetQueryAll() bool {
	if m != nil {
		return m.QueryAll
	}
	return false
}

func (m *ReqTokens) GetStatus() int32 {
	if m != nil {
		return m.Status
	}
	return 0
}

func (m *ReqTokens) GetTokens() []string {
	if m != nil {
		return m.Tokens
	}
	return nil
}

func (m *ReqTokens) GetSymbolOnly() bool {
	if m != nil {
		return m.SymbolOnly
	}
	return false
}

type ReplyTokens struct {
	Tokens []*LocalToken `protobuf:"bytes,1,rep,name=tokens" json:"tokens,omitempty"`
}

func (m *ReplyTokens) Reset()                    { *m = ReplyTokens{} }
func (m *ReplyTokens) String() string            { return proto.CompactTextString(m) }
func (*ReplyTokens) ProtoMessage()               {}
func (*ReplyTokens) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }

func (m *ReplyTokens) GetTokens() []*LocalToken {
	if m != nil {
		return m.Tokens
	}
	return nil
}

type TokenRecv struct {
	Token string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"`
	Recv  int64  `protobuf:"varint,2,opt,name=recv" json:"recv,omitempty"`
}

func (m *TokenRecv) Reset()                    { *m = TokenRecv{} }
func (m *TokenRecv) String() string            { return proto.CompactTextString(m) }
func (*TokenRecv) ProtoMessage()               {}
func (*TokenRecv) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }

func (m *TokenRecv) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *TokenRecv) GetRecv() int64 {
	if m != nil {
		return m.Recv
	}
	return 0
}

type ReplyAddrRecvForTokens struct {
	TokenRecvs []*TokenRecv `protobuf:"bytes,1,rep,name=tokenRecvs" json:"tokenRecvs,omitempty"`
}

func (m *ReplyAddrRecvForTokens) Reset()                    { *m = ReplyAddrRecvForTokens{} }
func (m *ReplyAddrRecvForTokens) String() string            { return proto.CompactTextString(m) }
func (*ReplyAddrRecvForTokens) ProtoMessage()               {}
func (*ReplyAddrRecvForTokens) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }

func (m *ReplyAddrRecvForTokens) GetTokenRecvs() []*TokenRecv {
	if m != nil {
		return m.TokenRecvs
	}
	return nil
}

type ReqTokenBalance struct {
	Addresses   []string `protobuf:"bytes,1,rep,name=addresses" json:"addresses,omitempty"`
	TokenSymbol string   `protobuf:"bytes,2,opt,name=tokenSymbol" json:"tokenSymbol,omitempty"`
	Execer      string   `protobuf:"bytes,3,opt,name=execer" json:"execer,omitempty"`
}

func (m *ReqTokenBalance) Reset()                    { *m = ReqTokenBalance{} }
func (m *ReqTokenBalance) String() string            { return proto.CompactTextString(m) }
func (*ReqTokenBalance) ProtoMessage()               {}
func (*ReqTokenBalance) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }

func (m *ReqTokenBalance) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *ReqTokenBalance) GetTokenSymbol() string {
	if m != nil {
		return m.TokenSymbol
	}
	return ""
}

func (m *ReqTokenBalance) GetExecer() string {
	if m != nil {
		return m.Execer
	}
	return ""
}

type ReqAccountTokenAssets struct {
	Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
	Execer  string `protobuf:"bytes,2,opt,name=execer" json:"execer,omitempty"`
}

func (m *ReqAccountTokenAssets) Reset()                    { *m = ReqAccountTokenAssets{} }
func (m *ReqAccountTokenAssets) String() string            { return proto.CompactTextString(m) }
func (*ReqAccountTokenAssets) ProtoMessage()               {}
func (*ReqAccountTokenAssets) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }

func (m *ReqAccountTokenAssets) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *ReqAccountTokenAssets) GetExecer() string {
	if m != nil {
		return m.Execer
	}
	return ""
}

type TokenAsset struct {
	Symbol  string          `protobuf:"bytes,1,opt,name=symbol" json:"symbol,omitempty"`
	Account *types3.Account `protobuf:"bytes,2,opt,name=account" json:"account,omitempty"`
}

func (m *TokenAsset) Reset()                    { *m = TokenAsset{} }
func (m *TokenAsset) String() string            { return proto.CompactTextString(m) }
func (*TokenAsset) ProtoMessage()               {}
func (*TokenAsset) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }

func (m *TokenAsset) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *TokenAsset) GetAccount() *types3.Account {
	if m != nil {
		return m.Account
	}
	return nil
}

type ReplyAccountTokenAssets struct {
	TokenAssets []*TokenAsset `protobuf:"bytes,1,rep,name=tokenAssets" json:"tokenAssets,omitempty"`
}

func (m *ReplyAccountTokenAssets) Reset()                    { *m = ReplyAccountTokenAssets{} }
func (m *ReplyAccountTokenAssets) String() string            { return proto.CompactTextString(m) }
func (*ReplyAccountTokenAssets) ProtoMessage()               {}
func (*ReplyAccountTokenAssets) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }

func (m *ReplyAccountTokenAssets) GetTokenAssets() []*TokenAsset {
	if m != nil {
		return m.TokenAssets
	}
	return nil
}

type ReqAddrTokens struct {
	Addr      string   `protobuf:"bytes,1,opt,name=addr" json:"addr,omitempty"`
	Status    int32    `protobuf:"varint,2,opt,name=status" json:"status,omitempty"`
	Token     []string `protobuf:"bytes,3,rep,name=token" json:"token,omitempty"`
	Direction int32    `protobuf:"varint,4,opt,name=direction" json:"direction,omitempty"`
	Count     int32    `protobuf:"varint,5,opt,name=count" json:"count,omitempty"`
	FromKey   string   `protobuf:"bytes,6,opt,name=fromKey" json:"fromKey,omitempty"`
}

func (m *ReqAddrTokens) Reset()                    { *m = ReqAddrTokens{} }
func (m *ReqAddrTokens) String() string            { return proto.CompactTextString(m) }
func (*ReqAddrTokens) ProtoMessage()               {}
func (*ReqAddrTokens) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }

func (m *ReqAddrTokens) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *ReqAddrTokens) GetStatus() int32 {
	if m != nil {
		return m.Status
	}
	return 0
}

func (m *ReqAddrTokens) GetToken() []string {
	if m != nil {
		return m.Token
	}
	return nil
}

func (m *ReqAddrTokens) GetDirection() int32 {
	if m != nil {
		return m.Direction
	}
	return 0
}

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

func (m *ReqAddrTokens) GetFromKey() string {
	if m != nil {
		return m.FromKey
	}
	return ""
}

type ReqTokenTx struct {
	Symbol string `protobuf:"bytes,1,opt,name=symbol" json:"symbol,omitempty"`
	// 表示取所有/from/to/其他的hash列表
	Flag      int32  `protobuf:"varint,2,opt,name=flag" json:"flag,omitempty"`
	Count     int32  `protobuf:"varint,3,opt,name=count" json:"count,omitempty"`
	Direction int32  `protobuf:"varint,4,opt,name=direction" json:"direction,omitempty"`
	Height    int64  `protobuf:"varint,5,opt,name=height" json:"height,omitempty"`
	Index     int64  `protobuf:"varint,6,opt,name=index" json:"index,omitempty"`
	Addr      string `protobuf:"bytes,7,opt,name=addr" json:"addr,omitempty"`
}

func (m *ReqTokenTx) Reset()                    { *m = ReqTokenTx{} }
func (m *ReqTokenTx) String() string            { return proto.CompactTextString(m) }
func (*ReqTokenTx) ProtoMessage()               {}
func (*ReqTokenTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }

func (m *ReqTokenTx) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *ReqTokenTx) GetFlag() int32 {
	if m != nil {
		return m.Flag
	}
	return 0
}

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

func (m *ReqTokenTx) GetDirection() int32 {
	if m != nil {
		return m.Direction
	}
	return 0
}

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

func (m *ReqTokenTx) GetIndex() int64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *ReqTokenTx) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func init() {
	proto.RegisterType((*TokenAction)(nil), "types.TokenAction")
	proto.RegisterType((*TokenPreCreate)(nil), "types.TokenPreCreate")
	proto.RegisterType((*TokenFinishCreate)(nil), "types.TokenFinishCreate")
	proto.RegisterType((*TokenRevokeCreate)(nil), "types.TokenRevokeCreate")
	proto.RegisterType((*Token)(nil), "types.Token")
	proto.RegisterType((*ReceiptToken)(nil), "types.ReceiptToken")
	proto.RegisterType((*LocalToken)(nil), "types.LocalToken")
	proto.RegisterType((*ReqTokens)(nil), "types.ReqTokens")
	proto.RegisterType((*ReplyTokens)(nil), "types.ReplyTokens")
	proto.RegisterType((*TokenRecv)(nil), "types.TokenRecv")
	proto.RegisterType((*ReplyAddrRecvForTokens)(nil), "types.ReplyAddrRecvForTokens")
	proto.RegisterType((*ReqTokenBalance)(nil), "types.ReqTokenBalance")
	proto.RegisterType((*ReqAccountTokenAssets)(nil), "types.ReqAccountTokenAssets")
	proto.RegisterType((*TokenAsset)(nil), "types.TokenAsset")
	proto.RegisterType((*ReplyAccountTokenAssets)(nil), "types.ReplyAccountTokenAssets")
	proto.RegisterType((*ReqAddrTokens)(nil), "types.ReqAddrTokens")
	proto.RegisterType((*ReqTokenTx)(nil), "types.ReqTokenTx")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for Token service

type TokenClient interface {
	// token 对外提供服务的接口
	// 区块链接口
	GetTokenBalance(ctx context.Context, in *ReqTokenBalance, opts ...grpc.CallOption) (*types3.Accounts, error)
}

type tokenClient struct {
	cc *grpc.ClientConn
}

func NewTokenClient(cc *grpc.ClientConn) TokenClient {
	return &tokenClient{cc}
}

func (c *tokenClient) GetTokenBalance(ctx context.Context, in *ReqTokenBalance, opts ...grpc.CallOption) (*types3.Accounts, error) {
	out := new(types3.Accounts)
	err := grpc.Invoke(ctx, "/types.token/GetTokenBalance", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Token service

type TokenServer interface {
	// token 对外提供服务的接口
	// 区块链接口
	GetTokenBalance(context.Context, *ReqTokenBalance) (*types3.Accounts, error)
}

func RegisterTokenServer(s *grpc.Server, srv TokenServer) {
	s.RegisterService(&_Token_serviceDesc, srv)
}

func _Token_GetTokenBalance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqTokenBalance)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TokenServer).GetTokenBalance(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.token/GetTokenBalance",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TokenServer).GetTokenBalance(ctx, req.(*ReqTokenBalance))
	}
	return interceptor(ctx, in, info, handler)
}

var _Token_serviceDesc = grpc.ServiceDesc{
	ServiceName: "types.token",
	HandlerType: (*TokenServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetTokenBalance",
			Handler:    _Token_GetTokenBalance_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "token.proto",
}

func init() { proto.RegisterFile("token.proto", fileDescriptor0) }

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