unfreeze

commands/game.go

+package commands
+
+import "github.com/spf13/cobra"
+
+func Cmd() *cobra.Command {
+	return nil
+}

executor/doc.go

+package executor
+
+// 定期解冻token

executor/exec.go

+package executor
+
+import (
+	uf "gitlab.33.cn/chain33/chain33/plugin/dapp/unfreeze/types"
+	"gitlab.33.cn/chain33/chain33/types"
+)
+
+func (u *Unfreeze) Exec_Create(payload *uf.GameCreate, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := NewAction(u, tx, index)
+	return action.UnfreezeCreate(payload)
+}
+
+func (u *Unfreeze) Exec_Cancel(payload *uf.GameCancel, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := NewAction(u, tx, index)
+	return action.UnfreezeWithdraw(payload)
+}
+
+func (u *Unfreeze) Exec_Terminate(payload *uf.GameClose, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := NewAction(u, tx, index)
+	return action.UnfreezeTerminate(payload)
+}

executor/exec_del_local.go

+package executor
+
+import (
+	uf "gitlab.33.cn/chain33/chain33/plugin/dapp/unfreeze/types"
+	"gitlab.33.cn/chain33/chain33/types"
+)
+
+func (u *Unfreeze) execDelLocal(receiptData *types.ReceiptData) (*types.LocalDBSet, error) {
+	dbSet := &types.LocalDBSet{}
+	return dbSet, nil
+}
+
+func (u *Unfreeze) ExecDelLocal_Create(payload *uf.UnfreezeCreate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	return u.execDelLocal(receiptData)
+}
+
+func (u *Unfreeze) ExecDelLocal_Withdraw(payload *uf.UnfreezeWithdraw, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	return u.execDelLocal(receiptData)
+}
+
+func (u *Unfreeze) ExecDelLocal_Terminate(payload *uf.UnfreezeTerminate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	return u.execDelLocal(receiptData)
+}

executor/exec_local.go

+package executor
+
+import (
+	uf "gitlab.33.cn/chain33/chain33/plugin/dapp/unfreeze/types"
+	"gitlab.33.cn/chain33/chain33/types"
+)
+
+func (u *Unfreeze) execLocal(receiptData *types.ReceiptData) (*types.LocalDBSet, error) {
+	dbSet := &types.LocalDBSet{}
+	return dbSet, nil
+}
+
+func (u *Unfreeze) ExecLocal_Create(payload *uf.UnfreezeCreate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	return u.execLocal(receiptData)
+}
+
+func (u *Unfreeze) ExecLocal_Withdraw(payload *uf.UnfreezeWithdraw, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	return u.execLocal(receiptData)
+}
+
+func (u *Unfreeze) ExecLocal_Terminate(payload *uf.UnfreezeTerminate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	return u.execLocal(receiptData)
+}

executor/query.go

+package executor

executor/unfreeze.go

+package executor
+
+import (
+	"fmt"
+
+	log "github.com/inconshreveable/log15"
+	uf "gitlab.33.cn/chain33/chain33/plugin/dapp/unfreeze/types"
+	drivers "gitlab.33.cn/chain33/chain33/system/dapp"
+	"gitlab.33.cn/chain33/chain33/types"
+)
+
+var uflog = log.New("module", "execs.unfreeze")
+
+var driverName = uf.UnfreezeX
+
+func init() {
+	ety := types.LoadExecutorType(driverName)
+	ety.InitFuncList(types.ListMethod(&Unfreeze{}))
+}
+
+func Init(name string) {
+	drivers.Register(GetName(), newGame, 0)
+}
+
+type Unfreeze struct {
+	drivers.DriverBase
+}
+
+func newUnfreeze() drivers.Driver {
+	t := &Unfreeze{}
+	t.SetChild(t)
+	t.SetExecutorType(types.LoadExecutorType(driverName))
+	return t
+}
+
+func GetName() string {
+	return newUnfreeze().GetName()
+}
+
+func (u *Unfreeze) GetDriverName() string {
+	return driverName
+}
+
+func (u *Unfreeze) GetPayloadValue() types.Message {
+	return &uf.UnfreezeAction{}
+}
+
+func (u *Unfreeze) GetTypeMap() map[string]int32 {
+	return map[string]int32{
+		"Create":    uf.UnfreezeActionCreate,
+		"Withdraw":  uf.UnfreezeActionWithdraw,
+		"Terminate": uf.UnfreezeActionTerminate,
+	}
+}

executor/unfreezedb.go

+package executor
+
+//database opeartion for executor unfreeze

plugin.go

+package unfreeze
+
+import (
+	"gitlab.33.cn/chain33/chain33/plugin/dapp/unfreeze/commands"
+	uf "gitlab.33.cn/chain33/chain33/plugin/dapp/unfreeze/types"
+	"gitlab.33.cn/chain33/chain33/plugin/dapp/v/executor"
+	"gitlab.33.cn/chain33/chain33/pluginmgr"
+)
+
+func init() {
+	pluginmgr.Register(&pluginmgr.PluginBase{
+		Name:     uf.PackageName,
+		ExecName: executor.GetName(),
+		Exec:     executor.Init,
+		Cmd:      commands.Cmd,
+		RPC:      nil,
+	})
+}

proto/Makefile

+all:
+	./create_protobuf.sh

proto/create_protobuf.sh

+#!/bin/sh
+protoc --go_out=plugins=grpc:../types ./*.proto

proto/unfreeze.proto

+syntax = "proto3";
+
+package types;
+
+message Unfreeze {
+    //开始时间
+    int64 startTime = 1;
+    //币种
+    string tokenName = 2;
+    //冻结总额
+    int64 totalCount = 3;
+    //发币人地址
+    string senderAddr = 4;
+    //收币人地址
+    string receiverAddr = 5;
+    //解冻间隔
+    int64 unfreezeGap = 6;
+    //解冻方式（百分比；固额） 1 百分比 -> 2 固额
+    int32 unfreezeMeans = 7;
+    //解冻数量：若为百分比解冻方式该字段值为百分比乘以100，若为固额该字段值为币数量
+    int64 unfreezeAmount = 8;
+    //已解冻次数
+    int32 withdrawTimes = 9;
+}
+
+// message for execs.unfreeze
+message UnfreezeAction {
+    oneof value {
+        UnfreezeCreate create = 1;
+        UnfreezeWithdraw withdraw = 2;
+        UnfreezeTerminate terminate = 3;
+    }
+    int32 ty = 10;
+}
+
+message UnfreezeCreate {
+
+}
+
+message UnfreezeWithdraw {
+
+}
+
+message UnfreezeTerminate {
+
+}
+
+message ReceiptUnfreeze {
+
+}

types/const.go

+package types
+
+//unfreeze action ty
+const (
+	UnfreezeActionCreate = iota + 1
+	UnfreezeActionWithdraw
+	UnfreezeActionTerminate
+
+	//log for unfreeze
+	TyLogCreateUnfreeze    = 2001 // TODO 修改具体编号
+	TyLogWithdrawUnfreeze  = 2002
+	TyLogTerminateUnfreeze = 2003
+)
+
+//包的名字可以通过配置文件来配置
+//建议用github的组织名称，或者用户名字开头, 再加上自己的插件的名字
+//如果发生重名，可以通过配置文件修改这些名字
+var (
+	PackageName = "chain33.unfreeze"
+	RpcName     = "Chain33.Unfreeze"
+	UnfreezeX   = "unfreeze"
+	ExecerGame  = []byte(UnfreezeX)
+)
+
+const (
+	Action_CreateUnfreeze    = "createUnfreeze"
+	Action_WithdrawUnfreeze  = "withdrawUnfreeze"
+	Action_TerminateUnfreeze = "terminateUnfreeze"
+)
+
+//const (
+//	FuncName_QueryXXX = "QueryXXX"
+//)

types/tx.go

+package types

types/types.go

+package types
+
+import (
+	"reflect"
+
+	log "github.com/inconshreveable/log15"
+	"gitlab.33.cn/chain33/chain33/types"
+)
+
+var name string
+
+var tlog = log.New("module", name)
+
+func init() {
+	name = UnfreezeX
+	// init executor type
+	types.RegistorExecutor(name, &UnfreezeType{})
+}
+
+//getRealExecName
+func getRealExecName(paraName string) string {
+	return types.ExecName(paraName + UnfreezeX)
+}
+
+func NewType() *UnfreezeType {
+	c := &UnfreezeType{}
+	c.SetChild(c)
+	return c
+}
+
+// exec
+type UnfreezeType struct {
+	types.ExecTypeBase
+}
+
+func (at *UnfreezeType) GetLogMap() map[int64]*types.LogInfo {
+	return map[int64]*types.LogInfo{
+		TyLogCreateUnfreeze:    {reflect.TypeOf(ReceiptUnfreeze{}), "LogCreateUnfreeze"},
+		TyLogWithdrawUnfreeze:  {reflect.TypeOf(ReceiptUnfreeze{}), "LogWithdrawUnfreeze"},
+		TyLogTerminateUnfreeze: {reflect.TypeOf(ReceiptUnfreeze{}), "LogTerminateUnfreeze"},
+	}
+}
+
+func (g *UnfreezeType) GetPayload() types.Message {
+	return &UnfreezeAction{}
+}
+
+func (g *UnfreezeType) GetTypeMap() map[string]int32 {
+	return map[string]int32{
+		"Create":    UnfreezeActionCreate,
+		"Withdraw":  UnfreezeActionWithdraw,
+		"Terminate": UnfreezeActionTerminate,
+	}
+}

types/unfreeze.pb.go

+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: unfreeze.proto
+
+/*
+Package types is a generated protocol buffer package.
+
+It is generated from these files:
+	unfreeze.proto
+
+It has these top-level messages:
+	Unfreeze
+	UnfreezeAction
+	UnfreezeCreate
+	UnfreezeWithdraw
+	UnfreezeTerminate
+	ReceiptUnfreeze
+*/
+package types
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import 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.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Unfreeze struct {
+	// 开始时间
+	StartTime int64 `protobuf:"varint,1,opt,name=startTime" json:"startTime,omitempty"`
+	// 币种
+	TokenName string `protobuf:"bytes,2,opt,name=tokenName" json:"tokenName,omitempty"`
+	// 冻结总额
+	TotalCount int64 `protobuf:"varint,3,opt,name=totalCount" json:"totalCount,omitempty"`
+	// 发币人地址
+	SenderAddr string `protobuf:"bytes,4,opt,name=senderAddr" json:"senderAddr,omitempty"`
+	// 收币人地址
+	ReceiverAddr string `protobuf:"bytes,5,opt,name=receiverAddr" json:"receiverAddr,omitempty"`
+	// 解冻间隔
+	UnfreezeGap int64 `protobuf:"varint,6,opt,name=unfreezeGap" json:"unfreezeGap,omitempty"`
+	// 解冻方式（百分比；固额） 1 百分比 -> 2 固额
+	UnfreezeMeans int32 `protobuf:"varint,7,opt,name=unfreezeMeans" json:"unfreezeMeans,omitempty"`
+	// 解冻数量：若为百分比解冻方式该字段值为百分比乘以100，若为固额该字段值为币数量
+	UnfreezeAmount int64 `protobuf:"varint,8,opt,name=unfreezeAmount" json:"unfreezeAmount,omitempty"`
+	// 已解冻次数
+	WithdrawTimes int32 `protobuf:"varint,9,opt,name=withdrawTimes" json:"withdrawTimes,omitempty"`
+}
+
+func (m *Unfreeze) Reset()                    { *m = Unfreeze{} }
+func (m *Unfreeze) String() string            { return proto.CompactTextString(m) }
+func (*Unfreeze) ProtoMessage()               {}
+func (*Unfreeze) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *Unfreeze) GetStartTime() int64 {
+	if m != nil {
+		return m.StartTime
+	}
+	return 0
+}
+
+func (m *Unfreeze) GetTokenName() string {
+	if m != nil {
+		return m.TokenName
+	}
+	return ""
+}
+
+func (m *Unfreeze) GetTotalCount() int64 {
+	if m != nil {
+		return m.TotalCount
+	}
+	return 0
+}
+
+func (m *Unfreeze) GetSenderAddr() string {
+	if m != nil {
+		return m.SenderAddr
+	}
+	return ""
+}
+
+func (m *Unfreeze) GetReceiverAddr() string {
+	if m != nil {
+		return m.ReceiverAddr
+	}
+	return ""
+}
+
+func (m *Unfreeze) GetUnfreezeGap() int64 {
+	if m != nil {
+		return m.UnfreezeGap
+	}
+	return 0
+}
+
+func (m *Unfreeze) GetUnfreezeMeans() int32 {
+	if m != nil {
+		return m.UnfreezeMeans
+	}
+	return 0
+}
+
+func (m *Unfreeze) GetUnfreezeAmount() int64 {
+	if m != nil {
+		return m.UnfreezeAmount
+	}
+	return 0
+}
+
+func (m *Unfreeze) GetWithdrawTimes() int32 {
+	if m != nil {
+		return m.WithdrawTimes
+	}
+	return 0
+}
+
+// message for execs.unfreeze
+type UnfreezeAction struct {
+	// Types that are valid to be assigned to Value:
+	//	*UnfreezeAction_Create
+	//	*UnfreezeAction_Withdraw
+	//	*UnfreezeAction_Terminate
+	Value isUnfreezeAction_Value `protobuf_oneof:"value"`
+	Ty    int32                  `protobuf:"varint,10,opt,name=ty" json:"ty,omitempty"`
+}
+
+func (m *UnfreezeAction) Reset()                    { *m = UnfreezeAction{} }
+func (m *UnfreezeAction) String() string            { return proto.CompactTextString(m) }
+func (*UnfreezeAction) ProtoMessage()               {}
+func (*UnfreezeAction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+type isUnfreezeAction_Value interface {
+	isUnfreezeAction_Value()
+}
+
+type UnfreezeAction_Create struct {
+	Create *UnfreezeCreate `protobuf:"bytes,1,opt,name=create,oneof"`
+}
+type UnfreezeAction_Withdraw struct {
+	Withdraw *UnfreezeWithdraw `protobuf:"bytes,2,opt,name=withdraw,oneof"`
+}
+type UnfreezeAction_Terminate struct {
+	Terminate *UnfreezeTerminate `protobuf:"bytes,3,opt,name=terminate,oneof"`
+}
+
+func (*UnfreezeAction_Create) isUnfreezeAction_Value()    {}
+func (*UnfreezeAction_Withdraw) isUnfreezeAction_Value()  {}
+func (*UnfreezeAction_Terminate) isUnfreezeAction_Value() {}
+
+func (m *UnfreezeAction) GetValue() isUnfreezeAction_Value {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *UnfreezeAction) GetCreate() *UnfreezeCreate {
+	if x, ok := m.GetValue().(*UnfreezeAction_Create); ok {
+		return x.Create
+	}
+	return nil
+}
+
+func (m *UnfreezeAction) GetWithdraw() *UnfreezeWithdraw {
+	if x, ok := m.GetValue().(*UnfreezeAction_Withdraw); ok {
+		return x.Withdraw
+	}
+	return nil
+}
+
+func (m *UnfreezeAction) GetTerminate() *UnfreezeTerminate {
+	if x, ok := m.GetValue().(*UnfreezeAction_Terminate); ok {
+		return x.Terminate
+	}
+	return nil
+}
+
+func (m *UnfreezeAction) GetTy() int32 {
+	if m != nil {
+		return m.Ty
+	}
+	return 0
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*UnfreezeAction) 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 _UnfreezeAction_OneofMarshaler, _UnfreezeAction_OneofUnmarshaler, _UnfreezeAction_OneofSizer, []interface{}{
+		(*UnfreezeAction_Create)(nil),
+		(*UnfreezeAction_Withdraw)(nil),
+		(*UnfreezeAction_Terminate)(nil),
+	}
+}
+
+func _UnfreezeAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*UnfreezeAction)
+	// value
+	switch x := m.Value.(type) {
+	case *UnfreezeAction_Create:
+		b.EncodeVarint(1<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Create); err != nil {
+			return err
+		}
+	case *UnfreezeAction_Withdraw:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Withdraw); err != nil {
+			return err
+		}
+	case *UnfreezeAction_Terminate:
+		b.EncodeVarint(3<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Terminate); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("UnfreezeAction.Value has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _UnfreezeAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*UnfreezeAction)
+	switch tag {
+	case 1: // value.create
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(UnfreezeCreate)
+		err := b.DecodeMessage(msg)
+		m.Value = &UnfreezeAction_Create{msg}
+		return true, err
+	case 2: // value.withdraw
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(UnfreezeWithdraw)
+		err := b.DecodeMessage(msg)
+		m.Value = &UnfreezeAction_Withdraw{msg}
+		return true, err
+	case 3: // value.terminate
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(UnfreezeTerminate)
+		err := b.DecodeMessage(msg)
+		m.Value = &UnfreezeAction_Terminate{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _UnfreezeAction_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*UnfreezeAction)
+	// value
+	switch x := m.Value.(type) {
+	case *UnfreezeAction_Create:
+		s := proto.Size(x.Create)
+		n += proto.SizeVarint(1<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *UnfreezeAction_Withdraw:
+		s := proto.Size(x.Withdraw)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *UnfreezeAction_Terminate:
+		s := proto.Size(x.Terminate)
+		n += proto.SizeVarint(3<<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
+}
+
+type UnfreezeCreate struct {
+}
+
+func (m *UnfreezeCreate) Reset()                    { *m = UnfreezeCreate{} }
+func (m *UnfreezeCreate) String() string            { return proto.CompactTextString(m) }
+func (*UnfreezeCreate) ProtoMessage()               {}
+func (*UnfreezeCreate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+type UnfreezeWithdraw struct {
+}
+
+func (m *UnfreezeWithdraw) Reset()                    { *m = UnfreezeWithdraw{} }
+func (m *UnfreezeWithdraw) String() string            { return proto.CompactTextString(m) }
+func (*UnfreezeWithdraw) ProtoMessage()               {}
+func (*UnfreezeWithdraw) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+type UnfreezeTerminate struct {
+}
+
+func (m *UnfreezeTerminate) Reset()                    { *m = UnfreezeTerminate{} }
+func (m *UnfreezeTerminate) String() string            { return proto.CompactTextString(m) }
+func (*UnfreezeTerminate) ProtoMessage()               {}
+func (*UnfreezeTerminate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+type ReceiptUnfreeze struct {
+}
+
+func (m *ReceiptUnfreeze) Reset()                    { *m = ReceiptUnfreeze{} }
+func (m *ReceiptUnfreeze) String() string            { return proto.CompactTextString(m) }
+func (*ReceiptUnfreeze) ProtoMessage()               {}
+func (*ReceiptUnfreeze) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+
+func init() {
+	proto.RegisterType((*Unfreeze)(nil), "types.Unfreeze")
+	proto.RegisterType((*UnfreezeAction)(nil), "types.UnfreezeAction")
+	proto.RegisterType((*UnfreezeCreate)(nil), "types.UnfreezeCreate")
+	proto.RegisterType((*UnfreezeWithdraw)(nil), "types.UnfreezeWithdraw")
+	proto.RegisterType((*UnfreezeTerminate)(nil), "types.UnfreezeTerminate")
+	proto.RegisterType((*ReceiptUnfreeze)(nil), "types.ReceiptUnfreeze")
+}
+
+func init() { proto.RegisterFile("unfreeze.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 345 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x92, 0xcf, 0x4e, 0xf2, 0x40,
+	0x14, 0xc5, 0x69, 0xf9, 0x0a, 0xf4, 0xf2, 0x89, 0x30, 0xc6, 0x38, 0x0b, 0x63, 0x9a, 0xc6, 0x18,
+	0x56, 0x98, 0x60, 0x4c, 0xdc, 0x22, 0x0b, 0xd9, 0xe8, 0x62, 0x82, 0x71, 0x3d, 0xd2, 0x6b, 0x6c,
+	0xa4, 0xd3, 0x66, 0x7a, 0x81, 0xe0, 0xd3, 0xb9, 0xf7, 0xa5, 0x4c, 0x87, 0x8e, 0x85, 0xba, 0xec,
+	0xef, 0x9c, 0xfb, 0xef, 0x74, 0xa0, 0xb7, 0x52, 0x6f, 0x1a, 0xf1, 0x13, 0x47, 0x99, 0x4e, 0x29,
+	0x65, 0x1e, 0x6d, 0x33, 0xcc, 0xc3, 0x2f, 0x17, 0x3a, 0xcf, 0xa5, 0xc2, 0xce, 0xc1, 0xcf, 0x49,
+	0x6a, 0x9a, 0xc7, 0x09, 0x72, 0x27, 0x70, 0x86, 0x4d, 0x51, 0x81, 0x42, 0xa5, 0xf4, 0x03, 0xd5,
+	0x93, 0x4c, 0x90, 0xbb, 0x81, 0x33, 0xf4, 0x45, 0x05, 0xd8, 0x05, 0x00, 0xa5, 0x24, 0x97, 0xd3,
+	0x74, 0xa5, 0x88, 0x37, 0x4d, 0xf1, 0x1e, 0x29, 0xf4, 0x1c, 0x55, 0x84, 0x7a, 0x12, 0x45, 0x9a,
+	0xff, 0x33, 0xe5, 0x7b, 0x84, 0x85, 0xf0, 0x5f, 0xe3, 0x02, 0xe3, 0x75, 0xe9, 0xf0, 0x8c, 0xe3,
+	0x80, 0xb1, 0x00, 0xba, 0xf6, 0x8a, 0x07, 0x99, 0xf1, 0x96, 0x19, 0xb2, 0x8f, 0xd8, 0x25, 0x1c,
+	0xd9, 0xcf, 0x47, 0x94, 0x2a, 0xe7, 0xed, 0xc0, 0x19, 0x7a, 0xe2, 0x10, 0xb2, 0xab, 0x2a, 0x8d,
+	0x49, 0x62, 0xf6, 0xed, 0x98, 0x56, 0x35, 0x5a, 0x74, 0xdb, 0xc4, 0xf4, 0x1e, 0x69, 0xb9, 0x29,
+	0x12, 0xc8, 0xb9, 0xbf, 0xeb, 0x76, 0x00, 0xc3, 0x6f, 0x07, 0x7a, 0x36, 0xc2, 0xc9, 0x82, 0xe2,
+	0x54, 0xb1, 0x6b, 0x68, 0x2d, 0x34, 0x4a, 0xda, 0xa5, 0xd8, 0x1d, 0x9f, 0x8e, 0x4c, 0xda, 0x23,
+	0x6b, 0x9b, 0x1a, 0x71, 0xd6, 0x10, 0xa5, 0x8d, 0xdd, 0x42, 0xc7, 0x36, 0x35, 0xd1, 0x76, 0xc7,
+	0x67, 0xb5, 0x92, 0x97, 0x52, 0x9e, 0x35, 0xc4, 0xaf, 0x95, 0xdd, 0x81, 0x4f, 0xa8, 0x93, 0x58,
+	0x15, 0xa3, 0x9a, 0xa6, 0x8e, 0xd7, 0xea, 0xe6, 0x56, 0x9f, 0x35, 0x44, 0x65, 0x66, 0x3d, 0x70,
+	0x69, 0xcb, 0xc1, 0xdc, 0xe3, 0xd2, 0xf6, 0xbe, 0x0d, 0xde, 0x5a, 0x2e, 0x57, 0x18, 0xf6, 0xab,
+	0x63, 0x76, 0x5b, 0x86, 0x0c, 0xfa, 0xf5, 0x25, 0xc2, 0x13, 0x18, 0xfc, 0x19, 0x10, 0x0e, 0xe0,
+	0x58, 0x14, 0xbf, 0x2b, 0x23, 0xab, 0xbd, 0xb6, 0xcc, 0x63, 0xbb, 0xf9, 0x09, 0x00, 0x00, 0xff,
+	0xff, 0x7d, 0xf5, 0x2a, 0x9a, 0x7e, 0x02, 0x00, 0x00,
+}