d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-20 07:26:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add orderbook calculator and verify func

Browse Source
This commit is contained in:
Adrian Gallagher
2019-06-30 22:09:19 +10:00
parent 7dbfcb311c
commit 7112a89491
14 changed files with 1452 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

180
cmd/gctcli/commands.go
View File

@@ -1243,6 +1243,186 @@ func submitOrder(c *cli.Context) error {
return nil
}
var simulateOrderCommand = cli.Command{
Name: "simulateorder",
Usage: "simulate order simulates an exchange order",
ArgsUsage: "<exchange> <currency_pair> <side> <amount>",
Action: simulateOrder,
Flags: []cli.Flag{
cli.StringFlag{
Name: "exchange",
Usage: "the exchange to simulate the order for",
},
cli.StringFlag{
Name: "currency_pair",
Usage: "the currency pair",
},
cli.StringFlag{
Name: "side",
Usage: "the order side to use (BUY OR SELL)",
},
cli.Float64Flag{
Name: "amount",
Usage: "the amount for the order",
},
},
}
func simulateOrder(c *cli.Context) error {
if c.NArg() == 0 && c.NumFlags() == 0 {
cli.ShowCommandHelp(c, "simulateorder")
return nil
}
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
var exchangeName string
var currencyPair string
var orderSide string
var amount float64
if c.IsSet("exchange") {
exchangeName = c.String("exchange")
} else {
exchangeName = c.Args().First()
}
if c.IsSet("currency_pair") {
currencyPair = c.String("currency_pair")
} else {
currencyPair = c.Args().Get(1)
}
if c.IsSet("side") {
orderSide = c.String("side")
} else {
orderSide = c.Args().Get(2)
}
if c.IsSet("amount") {
amount = c.Float64("amount")
} else {
amount, _ = strconv.ParseFloat(c.Args().Get(3), 64)
}
if !validPair(currencyPair) {
return errInvalidPair
}
p := currency.NewPairDelimiter(currencyPair, pairDelimiter)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.SimulateOrder(context.Background(), &gctrpc.SimulateOrderRequest{
Exchange: exchangeName,
Pair: &gctrpc.CurrencyPair{
Delimiter: p.Delimiter,
Base: p.Base.String(),
Quote: p.Quote.String(),
},
Side: orderSide,
Amount: amount,
})
if err != nil {
return err
}
jsonOutput(result)
return nil
}
var whaleBombCommand = cli.Command{
Name: "whalebomb",
Usage: "whale bomb finds the amount required to reach a price target",
ArgsUsage: "<exchange> <currency_pair> <side> <price>",
Action: whaleBomb,
Flags: []cli.Flag{
cli.StringFlag{
Name: "exchange",
Usage: "the exchange to whale bomb",
},
cli.StringFlag{
Name: "currency_pair",
Usage: "the currency pair",
},
cli.StringFlag{
Name: "side",
Usage: "the order side to use (BUY OR SELL)",
},
cli.Float64Flag{
Name: "price",
Usage: "the price target",
},
},
}
func whaleBomb(c *cli.Context) error {
if c.NArg() == 0 && c.NumFlags() == 0 {
cli.ShowCommandHelp(c, "whalebomb")
return nil
}
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
var exchangeName string
var currencyPair string
var orderSide string
var price float64
if c.IsSet("exchange") {
exchangeName = c.String("exchange")
} else {
exchangeName = c.Args().First()
}
if c.IsSet("currency_pair") {
currencyPair = c.String("currency_pair")
} else {
currencyPair = c.Args().Get(1)
}
if c.IsSet("side") {
orderSide = c.String("side")
} else {
orderSide = c.Args().Get(2)
}
if c.IsSet("price") {
price = c.Float64("price")
} else {
price, _ = strconv.ParseFloat(c.Args().Get(3), 64)
}
if !validPair(currencyPair) {
return errInvalidPair
}
p := currency.NewPairDelimiter(currencyPair, pairDelimiter)
client := gctrpc.NewGoCryptoTraderClient(conn)
result, err := client.WhaleBomb(context.Background(), &gctrpc.WhaleBombRequest{
Exchange: exchangeName,
Pair: &gctrpc.CurrencyPair{
Delimiter: p.Delimiter,
Base: p.Base.String(),
Quote: p.Quote.String(),
},
Side: orderSide,
PriceTarget: price,
})
if err != nil {
return err
}
jsonOutput(result)
return nil
}
var cancelOrderCommand = cli.Command{
Name: "cancelorder",
Usage: "cancel order cancels an exchange order",

2
cmd/gctcli/main.go
View File

@@ -111,6 +111,8 @@ func main() {
getOrdersCommand,
getOrderCommand,
submitOrderCommand,
simulateOrderCommand,
whaleBombCommand,
cancelOrderCommand,
cancelAllOrdersCommand,
getEventsCommand,

74
engine/rpcserver.go
View File

@@ -664,6 +664,80 @@ func (s *RPCServer) SubmitOrder(ctx context.Context, r *gctrpc.SubmitOrderReques
}, err
}
// SimulateOrder simulates an order specified by exchange, currency pair and asset
// type
func (s *RPCServer) SimulateOrder(ctx context.Context, r *gctrpc.SimulateOrderRequest) (*gctrpc.SimulateOrderResponse, error) {
exch := GetExchangeByName(r.Exchange)
if exch == nil {
return nil, errors.New("exchange is not loaded/doesn't exist")
}
p := currency.NewPairFromStrings(r.Pair.Base, r.Pair.Quote)
o, err := exch.FetchOrderbook(p, asset.Spot)
if err != nil {
return nil, err
}
var buy = true
if !strings.EqualFold(r.Side, exchange.BuyOrderSide.ToString()) &&
!strings.EqualFold(r.Side, exchange.BidOrderSide.ToString()) {
buy = false
}
result := o.SimulateOrder(r.Amount, buy)
var resp gctrpc.SimulateOrderResponse
for x := range result.Orders {
resp.Orders = append(resp.Orders, &gctrpc.OrderbookItem{
Price: result.Orders[x].Price,
Amount: result.Orders[x].Amount,
})
}
resp.Amount = result.Amount
resp.MaximumPrice = result.MaximumPrice
resp.MinimumPrice = result.MinimumPrice
resp.PercentageGainLoss = result.PercentageGainOrLoss
resp.Status = result.Status
return &resp, nil
}
// WhaleBomb finds the amount required to reach a specific price target for a given exchange, pair
// and asset type
func (s *RPCServer) WhaleBomb(ctx context.Context, r *gctrpc.WhaleBombRequest) (*gctrpc.SimulateOrderResponse, error) {
exch := GetExchangeByName(r.Exchange)
if exch == nil {
return nil, errors.New("exchange is not loaded/doesn't exist")
}
p := currency.NewPairFromStrings(r.Pair.Base, r.Pair.Quote)
o, err := exch.FetchOrderbook(p, asset.Spot)
if err != nil {
return nil, err
}
var buy = true
if !strings.EqualFold(r.Side, exchange.BuyOrderSide.ToString()) &&
!strings.EqualFold(r.Side, exchange.BidOrderSide.ToString()) {
buy = false
}
result, err := o.WhaleBomb(r.PriceTarget, buy)
var resp gctrpc.SimulateOrderResponse
for x := range result.Orders {
resp.Orders = append(resp.Orders, &gctrpc.OrderbookItem{
Price: result.Orders[x].Price,
Amount: result.Orders[x].Amount,
})
}
resp.Amount = result.Amount
resp.MaximumPrice = result.MaximumPrice
resp.MinimumPrice = result.MinimumPrice
resp.PercentageGainLoss = result.PercentageGainOrLoss
resp.Status = result.Status
return &resp, err
}
// CancelOrder cancels an order specified by exchange, currency pair and asset
// type
func (s *RPCServer) CancelOrder(ctx context.Context, r *gctrpc.CancelOrderRequest) (*gctrpc.CancelOrderResponse, error) {

7
exchanges/exchange.go
View File

@@ -725,7 +725,10 @@ func (e *Base) IsAssetTypeSupported(asset asset.Item) bool {
// PrintEnabledPairs prints the exchanges enabled asset pairs
func (e *Base) PrintEnabledPairs() {
for k, v := range e.CurrencyPairs.Pairs {
log.Infof("Asset type %v:", k)
log.Infof("\t Enabled pairs: %v", v.Enabled)
log.Infof("%s Asset type %v:\n\t Enabled pairs: %v",
e.Name, strings.ToUpper(k.String()), v.Enabled)
}
}
// GetBase returns the exchange base
func (e *Base) GetBase() *Base { return e }

1
exchanges/interfaces.go
View File

@@ -63,4 +63,5 @@ type IBotExchange interface {
GetDefaultConfig() (*config.ExchangeConfig, error)
GetSubscriptions() ([]WebsocketChannelSubscription, error)
AuthenticateWebsocket() error
GetBase() *Base
}

227
exchanges/orderbook/calculator.go Normal file
View File

@@ -0,0 +1,227 @@
package orderbook
import (
"errors"
"fmt"
"sort"
math "github.com/thrasher-/gocryptotrader/common/math"
log "github.com/thrasher-/gocryptotrader/logger"
)
// WhaleBombResult returns the whale bomb result
type WhaleBombResult struct {
Amount float64
MinimumPrice float64
MaximumPrice float64
PercentageGainOrLoss float64
Orders orderSummary
Status string
}
// WhaleBomb finds the amount required to target a price
func (o *Base) WhaleBomb(priceTarget float64, buy bool) (*WhaleBombResult, error) {
if priceTarget < 0 {
return nil, errors.New("price target is invalid")
}
if buy {
a, orders := o.findAmount(priceTarget, true)
min, max := orders.MinimumPrice(false), orders.MaximumPrice(true)
var err error
if max < priceTarget {
err = errors.New("unable to hit price target due to insufficient orderbook items")
}
status := fmt.Sprintf("Buying %.2f %v worth of %v will send the price from %v to %v [%.2f%%] and take %v orders.",
a, o.Pair.Quote.String(), o.Pair.Base.String(), min, max,
math.CalculatePercentageGainOrLoss(max, min), len(orders))
return &WhaleBombResult{
Amount: a,
Orders: orders,
MinimumPrice: min,
MaximumPrice: max,
Status: status,
}, err
}
a, orders := o.findAmount(priceTarget, false)
min, max := orders.MinimumPrice(false), orders.MaximumPrice(true)
var err error
if min > priceTarget {
err = errors.New("unable to hit price target due to insufficient orderbook items")
}
status := fmt.Sprintf("Selling %.2f %v worth of %v will send the price from %v to %v [%.2f%%] and take %v orders.",
a, o.Pair.Base.String(), o.Pair.Quote.String(), max, min,
math.CalculatePercentageGainOrLoss(min, max), len(orders))
return &WhaleBombResult{
Amount: a,
Orders: orders,
MinimumPrice: min,
MaximumPrice: max,
Status: status,
}, err
}
// OrderSimulationResult returns the order simulation result
type OrderSimulationResult WhaleBombResult
// SimulateOrder simulates an order
func (o *Base) SimulateOrder(amount float64, buy bool) *OrderSimulationResult {
if buy {
orders, amt := o.buy(amount)
min, max := orders.MinimumPrice(false), orders.MaximumPrice(true)
pct := math.CalculatePercentageGainOrLoss(max, min)
status := fmt.Sprintf("Buying %.2f %v worth of %v will send the price from %v to %v [%.2f%%] and take %v orders.",
amount, o.Pair.Quote.String(), o.Pair.Base.String(), min, max,
pct, len(orders))
return &OrderSimulationResult{
Orders: orders,
Amount: amt,
MinimumPrice: min,
MaximumPrice: max,
PercentageGainOrLoss: pct,
Status: status,
}
}
orders, amt := o.sell(amount)
min, max := orders.MinimumPrice(false), orders.MaximumPrice(true)
pct := math.CalculatePercentageGainOrLoss(min, max)
status := fmt.Sprintf("Selling %f %v worth of %v will send the price from %v to %v [%.2f%%] and take %v orders.",
amount, o.Pair.Base.String(), o.Pair.Quote.String(), max, min,
pct, len(orders))
return &OrderSimulationResult{
Orders: orders,
Amount: amt,
MinimumPrice: min,
MaximumPrice: max,
PercentageGainOrLoss: pct,
Status: status,
}
}
type orderSummary []Item
func (o orderSummary) Print() {
for x := range o {
log.Debugf("Order: Price: %f Amount: %f", o[x].Price, o[x].Amount)
}
}
func (o orderSummary) MinimumPrice(reverse bool) float64 {
if len(o) != 0 {
sortOrdersByPrice(&o, reverse)
return o[0].Price
}
return 0
}
func (o orderSummary) MaximumPrice(reverse bool) float64 {
if len(o) != 0 {
sortOrdersByPrice(&o, reverse)
return o[0].Price
}
return 0
}
// ByPrice used for sorting orders by order date
type ByPrice orderSummary
func (b ByPrice) Len() int { return len(b) }
func (b ByPrice) Less(i, j int) bool { return b[i].Price < b[j].Price }
func (b ByPrice) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
// sortOrdersByPrice the caller function to sort orders
func sortOrdersByPrice(o *orderSummary, reverse bool) {
if reverse {
sort.Sort(sort.Reverse(ByPrice(*o)))
} else {
sort.Sort(ByPrice(*o))
}
}
func (o *Base) findAmount(price float64, buy bool) (float64, orderSummary) {
var orders orderSummary
var amt float64
if buy {
asks := o.Asks
for x := range asks {
if asks[x].Price >= price {
amt += asks[x].Price * asks[x].Amount
orders = append(orders, Item{
Price: asks[x].Price,
Amount: asks[x].Amount,
})
return amt, orders
}
orders = append(orders, Item{
Price: asks[x].Price,
Amount: asks[x].Amount,
})
amt += asks[x].Price * asks[x].Amount
}
return amt, orders
}
for x := range o.Bids {
if o.Bids[x].Price <= price {
amt += o.Bids[x].Amount
orders = append(orders, Item{
Price: o.Bids[x].Price,
Amount: o.Bids[x].Amount,
})
break
}
orders = append(orders, Item{
Price: o.Bids[x].Price,
Amount: o.Bids[x].Amount,
})
amt += o.Bids[x].Amount
}
return amt, orders
}
func (o *Base) buy(amount float64) (orders orderSummary, baseAmount float64) {
var processedAmt float64
for x := range o.Asks {
subtotal := o.Asks[x].Price * o.Asks[x].Amount
if processedAmt+subtotal >= amount {
diff := amount - processedAmt
subAmt := diff / o.Asks[x].Price
orders = append(orders, Item{
Price: o.Asks[x].Price,
Amount: subAmt,
})
baseAmount += subAmt
break
}
processedAmt += subtotal
baseAmount += o.Asks[x].Amount
orders = append(orders, Item{
Price: o.Asks[x].Price,
Amount: o.Asks[x].Amount,
})
}
return
}
func (o *Base) sell(amount float64) (orders orderSummary, quoteAmount float64) {
var processedAmt float64
for x := range o.Bids {
if processedAmt+o.Bids[x].Amount >= amount {
diff := amount - processedAmt
orders = append(orders, Item{
Price: o.Bids[x].Price,
Amount: diff,
})
quoteAmount += diff * o.Bids[x].Price
break
}
processedAmt += o.Bids[x].Amount
quoteAmount += o.Bids[x].Amount * o.Bids[x].Price
orders = append(orders, Item{
Price: o.Bids[x].Price,
Amount: o.Bids[x].Amount,
})
}
return
}

79
exchanges/orderbook/calculator_test.go Normal file
View File

@@ -0,0 +1,79 @@
package orderbook
import (
"testing"
"github.com/thrasher-/gocryptotrader/currency"
)
func testSetup() Base {
return Base{
ExchangeName: "a",
Pair: currency.NewPair(currency.BTC, currency.USD),
Asks: []Item{
{Price: 7000, Amount: 1},
{Price: 7001, Amount: 2},
},
Bids: []Item{
{Price: 6999, Amount: 1},
{Price: 6998, Amount: 2},
},
}
}
func TestWhaleBomb(t *testing.T) {
t.Parallel()
b := testSetup()
// invalid price amout
_, err := b.WhaleBomb(-1, true)
if err == nil {
t.Error("unexpected result")
}
// valid
b.WhaleBomb(7001, true)
// invalid
b.WhaleBomb(7002, true)
// valid
b.WhaleBomb(6998, false)
// invalid
b.WhaleBomb(6997, false)
}
func TestSimulateOrder(t *testing.T) {
t.Parallel()
b := testSetup()
b.SimulateOrder(8000, true)
b.SimulateOrder(1.5, false)
}
func TestOrderSummary(t *testing.T) {
var o orderSummary
if p := o.MaximumPrice(false); p != 0 {
t.Error("unexpected result")
}
if p := o.MinimumPrice(false); p != 0 {
t.Error("unexpected result")
}
o = orderSummary{
{Price: 1337, Amount: 1},
{Price: 9001, Amount: 1},
}
if p := o.MaximumPrice(false); p != 1337 {
t.Error("unexpected result")
}
if p := o.MaximumPrice(true); p != 9001 {
t.Error("unexpected result")
}
if p := o.MinimumPrice(false); p != 1337 {
t.Error("unexpected result")
}
if p := o.MinimumPrice(true); p != 9001 {
t.Error("unexpected result")
}
o.Print()
}

42
exchanges/orderbook/orderbook.go
View File

@@ -2,6 +2,7 @@ package orderbook
import (
"errors"
"sort"
"sync"
"time"
@@ -47,6 +48,45 @@ type Orderbook struct {
ExchangeName string
}
type byOBPrice []Item
func (a byOBPrice) Len() int { return len(a) }
func (a byOBPrice) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a byOBPrice) Less(i, j int) bool { return a[i].Price < a[j].Price }
// Verify ensures that the orderbook items are correctly sorted
// Bids should always go from a high price to a low price and
// asks should always go from a low price to a higher price
func (o *Base) Verify() {
var lastPrice float64
var sortBids, sortAsks bool
for x := range o.Bids {
if lastPrice != 0 && o.Bids[x].Price >= lastPrice {
sortBids = true
break
}
lastPrice = o.Bids[x].Price
}
lastPrice = 0
for x := range o.Asks {
if lastPrice != 0 && o.Asks[x].Price <= lastPrice {
sortAsks = true
break
}
lastPrice = o.Asks[x].Price
}
if sortBids {
sort.Sort(sort.Reverse(byOBPrice(o.Bids)))
}
if sortAsks {
sort.Sort((byOBPrice(o.Asks)))
}
}
// TotalBidsAmount returns the total amount of bids and the total orderbook
// bids value
func (o *Base) TotalBidsAmount() (amountCollated, total float64) {
@@ -168,6 +208,8 @@ func (o *Base) Process() error {
o.LastUpdated = time.Now()
}
o.Verify()
orderbook, err := GetByExchange(o.ExchangeName)
if err != nil {
CreateNewOrderbook(o.ExchangeName, o, o.AssetType)

22
exchanges/orderbook/orderbook_test.go
View File

@@ -12,6 +12,28 @@ import (
log "github.com/thrasher-/gocryptotrader/logger"
)
func TestVerify(t *testing.T) {
t.Parallel()
b := Base{
ExchangeName: "TestExchange",
Pair: currency.NewPair(currency.BTC, currency.USD),
Bids: []Item{
{Price: 100}, {Price: 101}, {Price: 99},
},
Asks: []Item{
{Price: 100}, {Price: 99}, {Price: 101},
},
}
b.Verify()
if r := b.Bids[1].Price; r != 100 {
t.Error("unexpected result")
}
if r := b.Asks[1].Price; r != 100 {
t.Error("unexpected result")
}
}
func TestCalculateTotalBids(t *testing.T) {
t.Parallel()
currency := currency.NewPairFromStrings("BTC", "USD")

24
exchanges/orderbook/simulator/simulator_test.go Normal file
View File

@@ -0,0 +1,24 @@
package simulator
import (
"testing"
"github.com/thrasher-/gocryptotrader/currency"
"github.com/thrasher-/gocryptotrader/exchanges/asset"
"github.com/thrasher-/gocryptotrader/exchanges/bitstamp"
)
func TestSimulate(t *testing.T) {
b := bitstamp.Bitstamp{}
b.SetDefaults()
b.Verbose = false
o, err := b.FetchOrderbook(currency.NewPair(currency.BTC, currency.USD), asset.Spot)
if err != nil {
t.Error(err)
}
r := o.SimulateOrder(10000000, true)
t.Log(r.Status)
r = o.SimulateOrder(2171, false)
t.Log(r.Status)
}

832
gctrpc/rpc.pb.go
View File

@@ -3190,6 +3190,211 @@ func (m *SubmitOrderResponse) GetOrderId() string {
return ""
}
type SimulateOrderRequest struct {
Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"`
Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"`
Amount float64 `protobuf:"fixed64,3,opt,name=amount,proto3" json:"amount,omitempty"`
Side string `protobuf:"bytes,4,opt,name=side,proto3" json:"side,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SimulateOrderRequest) Reset() { *m = SimulateOrderRequest{} }
func (m *SimulateOrderRequest) String() string { return proto.CompactTextString(m) }
func (*SimulateOrderRequest) ProtoMessage() {}
func (*SimulateOrderRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{65}
}
func (m *SimulateOrderRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SimulateOrderRequest.Unmarshal(m, b)
}
func (m *SimulateOrderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SimulateOrderRequest.Marshal(b, m, deterministic)
}
func (m *SimulateOrderRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SimulateOrderRequest.Merge(m, src)
}
func (m *SimulateOrderRequest) XXX_Size() int {
return xxx_messageInfo_SimulateOrderRequest.Size(m)
}
func (m *SimulateOrderRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SimulateOrderRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SimulateOrderRequest proto.InternalMessageInfo
func (m *SimulateOrderRequest) GetExchange() string {
if m != nil {
return m.Exchange
}
return ""
}
func (m *SimulateOrderRequest) GetPair() *CurrencyPair {
if m != nil {
return m.Pair
}
return nil
}
func (m *SimulateOrderRequest) GetAmount() float64 {
if m != nil {
return m.Amount
}
return 0
}
func (m *SimulateOrderRequest) GetSide() string {
if m != nil {
return m.Side
}
return ""
}
type SimulateOrderResponse struct {
Orders []*OrderbookItem `protobuf:"bytes,1,rep,name=orders,proto3" json:"orders,omitempty"`
Amount float64 `protobuf:"fixed64,2,opt,name=amount,proto3" json:"amount,omitempty"`
MinimumPrice float64 `protobuf:"fixed64,3,opt,name=minimum_price,json=minimumPrice,proto3" json:"minimum_price,omitempty"`
MaximumPrice float64 `protobuf:"fixed64,4,opt,name=maximum_price,json=maximumPrice,proto3" json:"maximum_price,omitempty"`
PercentageGainLoss float64 `protobuf:"fixed64,5,opt,name=percentage_gain_loss,json=percentageGainLoss,proto3" json:"percentage_gain_loss,omitempty"`
Status string `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SimulateOrderResponse) Reset() { *m = SimulateOrderResponse{} }
func (m *SimulateOrderResponse) String() string { return proto.CompactTextString(m) }
func (*SimulateOrderResponse) ProtoMessage() {}
func (*SimulateOrderResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{66}
}
func (m *SimulateOrderResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SimulateOrderResponse.Unmarshal(m, b)
}
func (m *SimulateOrderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SimulateOrderResponse.Marshal(b, m, deterministic)
}
func (m *SimulateOrderResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_SimulateOrderResponse.Merge(m, src)
}
func (m *SimulateOrderResponse) XXX_Size() int {
return xxx_messageInfo_SimulateOrderResponse.Size(m)
}
func (m *SimulateOrderResponse) XXX_DiscardUnknown() {
xxx_messageInfo_SimulateOrderResponse.DiscardUnknown(m)
}
var xxx_messageInfo_SimulateOrderResponse proto.InternalMessageInfo
func (m *SimulateOrderResponse) GetOrders() []*OrderbookItem {
if m != nil {
return m.Orders
}
return nil
}
func (m *SimulateOrderResponse) GetAmount() float64 {
if m != nil {
return m.Amount
}
return 0
}
func (m *SimulateOrderResponse) GetMinimumPrice() float64 {
if m != nil {
return m.MinimumPrice
}
return 0
}
func (m *SimulateOrderResponse) GetMaximumPrice() float64 {
if m != nil {
return m.MaximumPrice
}
return 0
}
func (m *SimulateOrderResponse) GetPercentageGainLoss() float64 {
if m != nil {
return m.PercentageGainLoss
}
return 0
}
func (m *SimulateOrderResponse) GetStatus() string {
if m != nil {
return m.Status
}
return ""
}
type WhaleBombRequest struct {
Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"`
Pair *CurrencyPair `protobuf:"bytes,2,opt,name=pair,proto3" json:"pair,omitempty"`
PriceTarget float64 `protobuf:"fixed64,3,opt,name=price_target,json=priceTarget,proto3" json:"price_target,omitempty"`
Side string `protobuf:"bytes,4,opt,name=side,proto3" json:"side,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WhaleBombRequest) Reset() { *m = WhaleBombRequest{} }
func (m *WhaleBombRequest) String() string { return proto.CompactTextString(m) }
func (*WhaleBombRequest) ProtoMessage() {}
func (*WhaleBombRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{67}
}
func (m *WhaleBombRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WhaleBombRequest.Unmarshal(m, b)
}
func (m *WhaleBombRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WhaleBombRequest.Marshal(b, m, deterministic)
}
func (m *WhaleBombRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_WhaleBombRequest.Merge(m, src)
}
func (m *WhaleBombRequest) XXX_Size() int {
return xxx_messageInfo_WhaleBombRequest.Size(m)
}
func (m *WhaleBombRequest) XXX_DiscardUnknown() {
xxx_messageInfo_WhaleBombRequest.DiscardUnknown(m)
}
var xxx_messageInfo_WhaleBombRequest proto.InternalMessageInfo
func (m *WhaleBombRequest) GetExchange() string {
if m != nil {
return m.Exchange
}
return ""
}
func (m *WhaleBombRequest) GetPair() *CurrencyPair {
if m != nil {
return m.Pair
}
return nil
}
func (m *WhaleBombRequest) GetPriceTarget() float64 {
if m != nil {
return m.PriceTarget
}
return 0
}
func (m *WhaleBombRequest) GetSide() string {
if m != nil {
return m.Side
}
return ""
}
type CancelOrderRequest struct {
Exchange string `protobuf:"bytes,1,opt,name=exchange,proto3" json:"exchange,omitempty"`
AccountId string `protobuf:"bytes,2,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
@@ -3207,7 +3412,7 @@ func (m *CancelOrderRequest) Reset() { *m = CancelOrderRequest{} }
func (m *CancelOrderRequest) String() string { return proto.CompactTextString(m) }
func (*CancelOrderRequest) ProtoMessage() {}
func (*CancelOrderRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{65}
return fileDescriptor_77a6da22d6a3feb1, []int{68}
}
func (m *CancelOrderRequest) XXX_Unmarshal(b []byte) error {
@@ -3287,7 +3492,7 @@ func (m *CancelOrderResponse) Reset() { *m = CancelOrderResponse{} }
func (m *CancelOrderResponse) String() string { return proto.CompactTextString(m) }
func (*CancelOrderResponse) ProtoMessage() {}
func (*CancelOrderResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{66}
return fileDescriptor_77a6da22d6a3feb1, []int{69}
}
func (m *CancelOrderResponse) XXX_Unmarshal(b []byte) error {
@@ -3319,7 +3524,7 @@ func (m *CancelAllOrdersRequest) Reset() { *m = CancelAllOrdersRequest{}
func (m *CancelAllOrdersRequest) String() string { return proto.CompactTextString(m) }
func (*CancelAllOrdersRequest) ProtoMessage() {}
func (*CancelAllOrdersRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{67}
return fileDescriptor_77a6da22d6a3feb1, []int{70}
}
func (m *CancelAllOrdersRequest) XXX_Unmarshal(b []byte) error {
@@ -3358,7 +3563,7 @@ func (m *CancelAllOrdersResponse) Reset() { *m = CancelAllOrdersResponse
func (m *CancelAllOrdersResponse) String() string { return proto.CompactTextString(m) }
func (*CancelAllOrdersResponse) ProtoMessage() {}
func (*CancelAllOrdersResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{68}
return fileDescriptor_77a6da22d6a3feb1, []int{71}
}
func (m *CancelAllOrdersResponse) XXX_Unmarshal(b []byte) error {
@@ -3398,7 +3603,7 @@ func (m *CancelAllOrdersResponse_Orders) Reset() { *m = CancelAllOrdersR
func (m *CancelAllOrdersResponse_Orders) String() string { return proto.CompactTextString(m) }
func (*CancelAllOrdersResponse_Orders) ProtoMessage() {}
func (*CancelAllOrdersResponse_Orders) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{68, 0}
return fileDescriptor_77a6da22d6a3feb1, []int{71, 0}
}
func (m *CancelAllOrdersResponse_Orders) XXX_Unmarshal(b []byte) error {
@@ -3443,7 +3648,7 @@ func (m *GetEventsRequest) Reset() { *m = GetEventsRequest{} }
func (m *GetEventsRequest) String() string { return proto.CompactTextString(m) }
func (*GetEventsRequest) ProtoMessage() {}
func (*GetEventsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{69}
return fileDescriptor_77a6da22d6a3feb1, []int{72}
}
func (m *GetEventsRequest) XXX_Unmarshal(b []byte) error {
@@ -3479,7 +3684,7 @@ func (m *ConditionParams) Reset() { *m = ConditionParams{} }
func (m *ConditionParams) String() string { return proto.CompactTextString(m) }
func (*ConditionParams) ProtoMessage() {}
func (*ConditionParams) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{70}
return fileDescriptor_77a6da22d6a3feb1, []int{73}
}
func (m *ConditionParams) XXX_Unmarshal(b []byte) error {
@@ -3552,7 +3757,7 @@ func (m *GetEventsResponse) Reset() { *m = GetEventsResponse{} }
func (m *GetEventsResponse) String() string { return proto.CompactTextString(m) }
func (*GetEventsResponse) ProtoMessage() {}
func (*GetEventsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{71}
return fileDescriptor_77a6da22d6a3feb1, []int{74}
}
func (m *GetEventsResponse) XXX_Unmarshal(b []byte) error {
@@ -3638,7 +3843,7 @@ func (m *AddEventRequest) Reset() { *m = AddEventRequest{} }
func (m *AddEventRequest) String() string { return proto.CompactTextString(m) }
func (*AddEventRequest) ProtoMessage() {}
func (*AddEventRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{72}
return fileDescriptor_77a6da22d6a3feb1, []int{75}
}
func (m *AddEventRequest) XXX_Unmarshal(b []byte) error {
@@ -3712,7 +3917,7 @@ func (m *AddEventResponse) Reset() { *m = AddEventResponse{} }
func (m *AddEventResponse) String() string { return proto.CompactTextString(m) }
func (*AddEventResponse) ProtoMessage() {}
func (*AddEventResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{73}
return fileDescriptor_77a6da22d6a3feb1, []int{76}
}
func (m *AddEventResponse) XXX_Unmarshal(b []byte) error {
@@ -3751,7 +3956,7 @@ func (m *RemoveEventRequest) Reset() { *m = RemoveEventRequest{} }
func (m *RemoveEventRequest) String() string { return proto.CompactTextString(m) }
func (*RemoveEventRequest) ProtoMessage() {}
func (*RemoveEventRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{74}
return fileDescriptor_77a6da22d6a3feb1, []int{77}
}
func (m *RemoveEventRequest) XXX_Unmarshal(b []byte) error {
@@ -3789,7 +3994,7 @@ func (m *RemoveEventResponse) Reset() { *m = RemoveEventResponse{} }
func (m *RemoveEventResponse) String() string { return proto.CompactTextString(m) }
func (*RemoveEventResponse) ProtoMessage() {}
func (*RemoveEventResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{75}
return fileDescriptor_77a6da22d6a3feb1, []int{78}
}
func (m *RemoveEventResponse) XXX_Unmarshal(b []byte) error {
@@ -3823,7 +4028,7 @@ func (m *GetCryptocurrencyDepositAddressesRequest) Reset() {
func (m *GetCryptocurrencyDepositAddressesRequest) String() string { return proto.CompactTextString(m) }
func (*GetCryptocurrencyDepositAddressesRequest) ProtoMessage() {}
func (*GetCryptocurrencyDepositAddressesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{76}
return fileDescriptor_77a6da22d6a3feb1, []int{79}
}
func (m *GetCryptocurrencyDepositAddressesRequest) XXX_Unmarshal(b []byte) error {
@@ -3864,7 +4069,7 @@ func (m *GetCryptocurrencyDepositAddressesResponse) Reset() {
func (m *GetCryptocurrencyDepositAddressesResponse) String() string { return proto.CompactTextString(m) }
func (*GetCryptocurrencyDepositAddressesResponse) ProtoMessage() {}
func (*GetCryptocurrencyDepositAddressesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{77}
return fileDescriptor_77a6da22d6a3feb1, []int{80}
}
func (m *GetCryptocurrencyDepositAddressesResponse) XXX_Unmarshal(b []byte) error {
@@ -3906,7 +4111,7 @@ func (m *GetCryptocurrencyDepositAddressRequest) Reset() {
func (m *GetCryptocurrencyDepositAddressRequest) String() string { return proto.CompactTextString(m) }
func (*GetCryptocurrencyDepositAddressRequest) ProtoMessage() {}
func (*GetCryptocurrencyDepositAddressRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{78}
return fileDescriptor_77a6da22d6a3feb1, []int{81}
}
func (m *GetCryptocurrencyDepositAddressRequest) XXX_Unmarshal(b []byte) error {
@@ -3954,7 +4159,7 @@ func (m *GetCryptocurrencyDepositAddressResponse) Reset() {
func (m *GetCryptocurrencyDepositAddressResponse) String() string { return proto.CompactTextString(m) }
func (*GetCryptocurrencyDepositAddressResponse) ProtoMessage() {}
func (*GetCryptocurrencyDepositAddressResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{79}
return fileDescriptor_77a6da22d6a3feb1, []int{82}
}
func (m *GetCryptocurrencyDepositAddressResponse) XXX_Unmarshal(b []byte) error {
@@ -4009,7 +4214,7 @@ func (m *WithdrawCurrencyRequest) Reset() { *m = WithdrawCurrencyRequest
func (m *WithdrawCurrencyRequest) String() string { return proto.CompactTextString(m) }
func (*WithdrawCurrencyRequest) ProtoMessage() {}
func (*WithdrawCurrencyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{80}
return fileDescriptor_77a6da22d6a3feb1, []int{83}
}
func (m *WithdrawCurrencyRequest) XXX_Unmarshal(b []byte) error {
@@ -4160,7 +4365,7 @@ func (m *WithdrawResponse) Reset() { *m = WithdrawResponse{} }
func (m *WithdrawResponse) String() string { return proto.CompactTextString(m) }
func (*WithdrawResponse) ProtoMessage() {}
func (*WithdrawResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_77a6da22d6a3feb1, []int{81}
return fileDescriptor_77a6da22d6a3feb1, []int{84}
}
func (m *WithdrawResponse) XXX_Unmarshal(b []byte) error {
@@ -4263,6 +4468,9 @@ func init() {
proto.RegisterType((*GetOrderRequest)(nil), "gctrpc.GetOrderRequest")
proto.RegisterType((*SubmitOrderRequest)(nil), "gctrpc.SubmitOrderRequest")
proto.RegisterType((*SubmitOrderResponse)(nil), "gctrpc.SubmitOrderResponse")
proto.RegisterType((*SimulateOrderRequest)(nil), "gctrpc.SimulateOrderRequest")
proto.RegisterType((*SimulateOrderResponse)(nil), "gctrpc.SimulateOrderResponse")
proto.RegisterType((*WhaleBombRequest)(nil), "gctrpc.WhaleBombRequest")
proto.RegisterType((*CancelOrderRequest)(nil), "gctrpc.CancelOrderRequest")
proto.RegisterType((*CancelOrderResponse)(nil), "gctrpc.CancelOrderResponse")
proto.RegisterType((*CancelAllOrdersRequest)(nil), "gctrpc.CancelAllOrdersRequest")
@@ -4288,261 +4496,273 @@ func init() {
func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
var fileDescriptor_77a6da22d6a3feb1 = []byte{
// 4062 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x4d, 0x6f, 0x24, 0x49,
0x56, 0xca, 0xb2, 0xdb, 0x1f, 0xaf, 0xca, 0x2e, 0x3b, 0xfc, 0x55, 0x2e, 0xdb, 0x6d, 0x77, 0xee,
0x76, 0x4f, 0xf7, 0x7c, 0xd8, 0x3b, 0x3d, 0x2d, 0x76, 0xd8, 0x59, 0x16, 0x3c, 0x9e, 0x1e, 0x6f,
0xb3, 0xbb, 0xd3, 0x26, 0xbb, 0xb7, 0x47, 0x9a, 0x45, 0x14, 0xe9, 0xcc, 0xb0, 0x9d, 0x72, 0x3a,
0x33, 0x27, 0x33, 0xca, 0xee, 0x1a, 0x21, 0x21, 0xad, 0x04, 0x47, 0x38, 0xac, 0x90, 0x38, 0x70,
0xe2, 0x88, 0xc4, 0x05, 0x71, 0xe2, 0x30, 0xe2, 0x8a, 0x38, 0x72, 0xe1, 0x07, 0x20, 0x6e, 0xb0,
0x27, 0x2e, 0x9c, 0x50, 0xbc, 0xf8, 0xc8, 0x88, 0xca, 0xac, 0x72, 0x35, 0x3b, 0x9a, 0x4b, 0x77,
0xe5, 0x8b, 0x17, 0xef, 0xbd, 0x78, 0xef, 0xc5, 0x8b, 0xf7, 0x5e, 0x84, 0x61, 0x3e, 0xcf, 0x82,
0xfd, 0x2c, 0x4f, 0x59, 0x4a, 0x66, 0xce, 0x03, 0x96, 0x67, 0x41, 0x77, 0xfb, 0x3c, 0x4d, 0xcf,
0x63, 0x7a, 0xe0, 0x67, 0xd1, 0x81, 0x9f, 0x24, 0x29, 0xf3, 0x59, 0x94, 0x26, 0x85, 0xc0, 0x72,
0x97, 0x60, 0xf1, 0x98, 0xb2, 0x67, 0xc9, 0x59, 0xea, 0xd1, 0x2f, 0xfb, 0xb4, 0x60, 0xee, 0x3f,
0x4e, 0x43, 0x5b, 0x83, 0x8a, 0x2c, 0x4d, 0x0a, 0x4a, 0xd6, 0x61, 0xa6, 0x9f, 0xb1, 0xe8, 0x8a,
0x76, 0x9c, 0x3d, 0xe7, 0xe1, 0xbc, 0x27, 0xbf, 0xc8, 0x01, 0xac, 0xf8, 0xd7, 0x7e, 0x14, 0xfb,
0xa7, 0x31, 0xed, 0xd1, 0xd7, 0xc1, 0x85, 0x9f, 0x9c, 0xd3, 0xa2, 0xd3, 0xd8, 0x73, 0x1e, 0x4e,
0x79, 0x44, 0x0f, 0x3d, 0x55, 0x23, 0xe4, 0x1d, 0x58, 0xa6, 0x09, 0x07, 0x85, 0x06, 0xfa, 0x14,
0xa2, 0x2f, 0xc9, 0x81, 0x12, 0xf9, 0x09, 0xac, 0x87, 0xf4, 0xcc, 0xef, 0xc7, 0xac, 0x77, 0x96,
0xe6, 0xf4, 0x75, 0x2f, 0xcb, 0xd3, 0xeb, 0x28, 0xa4, 0x79, 0x67, 0x1a, 0xa5, 0x58, 0x95, 0xa3,
0x9f, 0xf2, 0xc1, 0x13, 0x39, 0x46, 0x1e, 0xc3, 0x9a, 0x9e, 0x15, 0xf9, 0xac, 0x17, 0xf4, 0xf3,
0x9c, 0x26, 0xc1, 0xa0, 0x73, 0x07, 0x27, 0xad, 0xa8, 0x49, 0x91, 0xcf, 0x8e, 0xe4, 0x10, 0xf9,
0x1c, 0x96, 0x8a, 0xfe, 0x69, 0x31, 0x28, 0x18, 0xbd, 0xea, 0x15, 0xcc, 0x67, 0xfd, 0xa2, 0x33,
0xb3, 0x37, 0xf5, 0xb0, 0xf9, 0xf8, 0xdd, 0x7d, 0xa1, 0xc6, 0xfd, 0x21, 0x95, 0xec, 0xbf, 0x50,
0xf8, 0x2f, 0x10, 0xfd, 0x69, 0xc2, 0xf2, 0x81, 0xd7, 0x2e, 0x6c, 0x28, 0xf9, 0x0c, 0x16, 0xf2,
0x2c, 0xe8, 0xd1, 0x24, 0xcc, 0xd2, 0x28, 0x61, 0x45, 0x67, 0x16, 0xa9, 0x3e, 0x1a, 0x45, 0xd5,
0xcb, 0x82, 0xa7, 0x0a, 0x57, 0x90, 0x6c, 0xe5, 0x06, 0xa8, 0xfb, 0x31, 0xac, 0xd6, 0x31, 0x26,
0x4b, 0x30, 0x75, 0x49, 0x07, 0xd2, 0x3a, 0xfc, 0x27, 0x59, 0x85, 0x3b, 0xd7, 0x7e, 0xdc, 0xa7,
0x68, 0x8c, 0x39, 0x4f, 0x7c, 0xfc, 0xa0, 0xf1, 0xa1, 0xd3, 0x7d, 0x09, 0xcb, 0x15, 0x36, 0x35,
0x04, 0x1e, 0x99, 0x04, 0x9a, 0x8f, 0x57, 0x94, 0xc8, 0xde, 0xc9, 0x91, 0x9a, 0x6b, 0x50, 0x75,
0xef, 0xc1, 0xee, 0x31, 0x65, 0x47, 0xe9, 0xd5, 0x55, 0x3f, 0x89, 0x02, 0xf4, 0x31, 0x8f, 0xc6,
0xfe, 0x80, 0xe6, 0x85, 0xf2, 0xac, 0xcf, 0x60, 0xb5, 0x6e, 0x9c, 0x74, 0x60, 0x56, 0xda, 0x1e,
0xf9, 0xcf, 0x79, 0xea, 0x93, 0x6c, 0xc3, 0x7c, 0x90, 0x26, 0x09, 0x0d, 0x18, 0x0d, 0xe5, 0x42,
0x4a, 0x80, 0xfb, 0xe7, 0x0d, 0xd8, 0x1b, 0xcd, 0x53, 0xba, 0xee, 0x57, 0xb0, 0x1e, 0x98, 0x08,
0xbd, 0x5c, 0x62, 0x74, 0x1c, 0x34, 0xc5, 0x91, 0x61, 0x8a, 0xb1, 0x94, 0xf6, 0x6b, 0x47, 0x85,
0x91, 0xd6, 0x82, 0xba, 0xb1, 0xee, 0x19, 0x74, 0x47, 0x4f, 0xaa, 0x51, 0xf9, 0x63, 0x5b, 0xe5,
0xdb, 0x4a, 0xb4, 0x3a, 0x22, 0xa6, 0xee, 0xbf, 0x0f, 0x1b, 0xc7, 0x34, 0xa1, 0x79, 0x14, 0x68,
0xe7, 0x90, 0x3a, 0xe7, 0x1a, 0xd4, 0x3e, 0x29, 0x59, 0x95, 0x00, 0xb7, 0x0b, 0x9d, 0xea, 0x44,
0xb1, 0x5c, 0x77, 0x1d, 0x56, 0x8f, 0x29, 0xd3, 0x70, 0x6d, 0xc5, 0xaf, 0x1d, 0x58, 0xc3, 0x81,
0xe2, 0xb4, 0x18, 0x88, 0x01, 0xa9, 0xea, 0x3f, 0x86, 0x65, 0x4d, 0xba, 0x50, 0xdb, 0x48, 0x68,
0xf9, 0x03, 0x43, 0xcb, 0xd5, 0x99, 0xe5, 0x66, 0x2a, 0xcc, 0xdd, 0x54, 0xee, 0x49, 0x09, 0xee,
0x1e, 0xc1, 0x5a, 0x2d, 0xea, 0x9b, 0xf8, 0xbf, 0xdb, 0x81, 0xf5, 0x63, 0xca, 0x0c, 0x37, 0x36,
0x1c, 0xb4, 0x69, 0x80, 0xb9, 0x5f, 0x16, 0xcc, 0xcf, 0x59, 0xe9, 0x97, 0xf2, 0x93, 0xdc, 0x87,
0xc5, 0x38, 0x2a, 0x18, 0x4d, 0x7a, 0x7e, 0x18, 0xe6, 0xb4, 0x10, 0x21, 0x6f, 0xde, 0x5b, 0x10,
0xd0, 0x43, 0x01, 0x74, 0xff, 0xc9, 0xe1, 0x86, 0x19, 0x62, 0x25, 0x95, 0xf5, 0x53, 0x98, 0x2f,
0xa3, 0x82, 0x50, 0xd2, 0xbe, 0xa1, 0xa4, 0xba, 0x39, 0xfb, 0x43, 0xa1, 0xa1, 0x24, 0xd0, 0xfd,
0x03, 0x58, 0xfc, 0xa6, 0x37, 0xf4, 0x87, 0xd0, 0x95, 0xbe, 0xa1, 0x22, 0xf2, 0x67, 0xfe, 0x15,
0x55, 0x7e, 0xd5, 0x85, 0x39, 0x15, 0xc0, 0x25, 0x0f, 0xfd, 0xed, 0xee, 0xc0, 0x56, 0xed, 0x4c,
0xe9, 0x58, 0x07, 0xb0, 0x72, 0x4c, 0x99, 0x0e, 0xf3, 0x8a, 0xe2, 0xc8, 0x28, 0xe0, 0x3e, 0x41,
0x4f, 0x34, 0x26, 0x48, 0x15, 0x6e, 0xc3, 0x7c, 0x79, 0x88, 0x48, 0xdf, 0xd6, 0x00, 0xf7, 0x31,
0xba, 0xa9, 0x9a, 0xf5, 0xfc, 0xe5, 0x89, 0x47, 0xc5, 0xb4, 0x4d, 0x98, 0x4b, 0x59, 0xd6, 0x0b,
0xd2, 0x50, 0x89, 0x3e, 0x9b, 0xb2, 0xec, 0x28, 0x0d, 0xa9, 0x74, 0x0d, 0x63, 0x8e, 0x76, 0x8d,
0xbf, 0x15, 0xa6, 0xb4, 0x87, 0xa4, 0x1c, 0xbf, 0x0f, 0xf3, 0x8a, 0xa0, 0x32, 0xe5, 0x7b, 0x86,
0x29, 0xeb, 0xe6, 0xec, 0x3f, 0x17, 0x1c, 0xa5, 0x25, 0xe7, 0xa4, 0x00, 0x45, 0xf7, 0x23, 0x58,
0xb0, 0x86, 0x6e, 0xf3, 0xec, 0x79, 0xd3, 0x64, 0x4f, 0x60, 0xfd, 0x93, 0xa8, 0x30, 0x4f, 0xdc,
0x49, 0xcc, 0xf5, 0xf5, 0x94, 0xb5, 0x34, 0xeb, 0xe0, 0x27, 0x30, 0x9d, 0xf8, 0xfa, 0xd8, 0xc7,
0xdf, 0xa6, 0xa1, 0x1a, 0x76, 0xb8, 0xee, 0xc0, 0xec, 0x35, 0xcd, 0x4f, 0xd3, 0x82, 0xe2, 0x99,
0x3e, 0xe7, 0xa9, 0x4f, 0xf2, 0x1d, 0x58, 0xe8, 0x17, 0x51, 0x72, 0xde, 0x2b, 0xfc, 0x24, 0x3c,
0x4d, 0x5f, 0xe3, 0x09, 0x3e, 0xe7, 0xb5, 0x10, 0xf8, 0x42, 0xc0, 0xc8, 0x3d, 0x68, 0x5d, 0x30,
0x96, 0xf5, 0x78, 0x6a, 0x91, 0xf6, 0x99, 0x3c, 0xb0, 0x9b, 0x1c, 0xf6, 0x52, 0x80, 0xf8, 0xc6,
0x43, 0x94, 0x7e, 0x41, 0x73, 0xff, 0x9c, 0x26, 0xac, 0x33, 0x23, 0x36, 0x1e, 0x87, 0xfe, 0x5c,
0x01, 0xc9, 0x0e, 0x00, 0xa2, 0x65, 0x79, 0xfa, 0x7a, 0xd0, 0x99, 0x15, 0xae, 0xc1, 0x21, 0x27,
0x1c, 0x40, 0xde, 0x82, 0xf6, 0xa9, 0x5f, 0x50, 0x95, 0x1a, 0x44, 0xb4, 0xe8, 0xcc, 0x21, 0xce,
0x22, 0x07, 0x1f, 0x69, 0x28, 0x79, 0xc4, 0xf3, 0x82, 0x2c, 0x4b, 0xf9, 0xa6, 0xef, 0xf9, 0x45,
0x41, 0x59, 0xd1, 0x99, 0x47, 0xcc, 0xb6, 0x86, 0x1f, 0x22, 0x98, 0xaf, 0x50, 0x65, 0x36, 0x99,
0x1f, 0xe5, 0x45, 0x07, 0x10, 0xaf, 0x25, 0x81, 0x27, 0x1c, 0xc6, 0x19, 0x97, 0xf9, 0x92, 0x40,
0x6b, 0x0a, 0xc6, 0x1a, 0x2c, 0x10, 0xdf, 0x81, 0x65, 0xbf, 0xcf, 0x2e, 0x68, 0xc2, 0x78, 0xd4,
0xe7, 0xcc, 0xb3, 0xa8, 0xd3, 0x42, 0x9d, 0x2d, 0x59, 0x03, 0x87, 0x59, 0xe4, 0xde, 0xc0, 0xd2,
0x31, 0x65, 0x2f, 0xa3, 0xe0, 0x92, 0xe6, 0x13, 0x18, 0x9c, 0x3c, 0x84, 0x69, 0xce, 0x5b, 0xc6,
0x81, 0x55, 0x7d, 0xca, 0xc8, 0x6c, 0x88, 0x4b, 0xe0, 0x21, 0x06, 0xd7, 0x23, 0xae, 0xba, 0xc7,
0x06, 0x99, 0xb0, 0xe9, 0xbc, 0x37, 0x8f, 0x90, 0x97, 0x83, 0x8c, 0xba, 0xaf, 0xa0, 0x65, 0x4e,
0xe2, 0x1b, 0x32, 0xa4, 0x71, 0x74, 0x15, 0x31, 0x9a, 0xab, 0x0d, 0xa9, 0x01, 0xdc, 0x97, 0xb8,
0x7a, 0xa5, 0xdb, 0xe2, 0x6f, 0xee, 0xcb, 0x5f, 0xf6, 0x53, 0xa6, 0x68, 0x8b, 0x0f, 0xf7, 0xaf,
0x1a, 0xb0, 0xa8, 0x96, 0x23, 0x1d, 0x51, 0xc9, 0xec, 0xdc, 0x2a, 0xf3, 0x3d, 0x68, 0xc5, 0x7e,
0xc1, 0x7a, 0xfd, 0x2c, 0xf4, 0x55, 0xda, 0x30, 0xe5, 0x35, 0x39, 0xec, 0xe7, 0x02, 0xc4, 0x6d,
0xa5, 0xb2, 0x42, 0xb4, 0x82, 0xe4, 0xde, 0x0a, 0xcc, 0xc5, 0x10, 0x98, 0xe6, 0x73, 0xd0, 0x53,
0x1d, 0x0f, 0x7f, 0x73, 0xd8, 0x45, 0x74, 0x7e, 0x81, 0x9e, 0xe9, 0x78, 0xf8, 0x9b, 0x6f, 0xd0,
0x38, 0xbd, 0x41, 0x3f, 0x74, 0x3c, 0xfe, 0x93, 0x43, 0x4e, 0xa3, 0x10, 0xdd, 0xce, 0xf1, 0xf8,
0x4f, 0x0e, 0xf1, 0x8b, 0x4b, 0x74, 0x32, 0xc7, 0xe3, 0x3f, 0x79, 0x46, 0x7d, 0x9d, 0xc6, 0xfd,
0x2b, 0x8a, 0xfe, 0xe4, 0x78, 0xf2, 0x8b, 0x6c, 0xc1, 0x7c, 0x96, 0x47, 0x01, 0xed, 0xf9, 0xec,
0x02, 0x5d, 0xc8, 0xf1, 0xe6, 0x10, 0x70, 0xc8, 0x2e, 0xdc, 0x15, 0x58, 0xd6, 0x86, 0xd6, 0x91,
0xe9, 0x73, 0x98, 0x95, 0x90, 0xb1, 0x46, 0xff, 0x1e, 0xcc, 0x32, 0x81, 0xd6, 0x69, 0x60, 0x88,
0x5a, 0x57, 0x3a, 0xb4, 0x35, 0xed, 0x29, 0x34, 0xf7, 0x77, 0x81, 0x98, 0xdc, 0xa4, 0x21, 0x1e,
0x95, 0x74, 0x44, 0xa8, 0x6b, 0xdb, 0x74, 0x8a, 0x92, 0xc0, 0x57, 0x18, 0xe8, 0x9f, 0xe7, 0x21,
0x0f, 0x02, 0xe9, 0xe5, 0xb7, 0xea, 0x9a, 0x3f, 0x83, 0x05, 0xcd, 0xf8, 0x19, 0xa3, 0x57, 0x5c,
0xe1, 0xfe, 0x55, 0xda, 0x4f, 0x18, 0xf2, 0x74, 0x3c, 0xf9, 0xc5, 0x3d, 0x10, 0xf5, 0x8b, 0x2c,
0x1d, 0x4f, 0x7c, 0x90, 0x45, 0x68, 0x44, 0xa1, 0x2c, 0x4c, 0x1a, 0x51, 0xe8, 0xfe, 0xaf, 0x03,
0xcb, 0xc6, 0x42, 0xde, 0xd8, 0x29, 0x2b, 0x1e, 0xd7, 0xa8, 0xf1, 0xb8, 0x47, 0x30, 0x7d, 0x1a,
0x85, 0xbc, 0x1e, 0xe2, 0x7a, 0x5d, 0x53, 0xe4, 0xac, 0x75, 0x78, 0x88, 0xc2, 0x51, 0xfd, 0xe2,
0xb2, 0xe8, 0x4c, 0x8f, 0x45, 0xe5, 0x28, 0x95, 0xfd, 0x70, 0xa7, 0xba, 0x1f, 0x6c, 0x5d, 0xce,
0x0c, 0xeb, 0x52, 0x64, 0x82, 0x9a, 0xb6, 0xf6, 0xbc, 0x00, 0xa0, 0x04, 0x8e, 0x35, 0xeb, 0x6f,
0x03, 0xa4, 0x1a, 0x53, 0xfa, 0xdf, 0x66, 0x45, 0x68, 0xed, 0x82, 0x06, 0xb2, 0xfb, 0x13, 0x3c,
0xc6, 0x4d, 0xe6, 0x52, 0xf9, 0x8f, 0x2d, 0x9a, 0xc2, 0x17, 0x49, 0x85, 0x66, 0x61, 0x11, 0xfb,
0x00, 0x89, 0x1d, 0x06, 0x01, 0x37, 0xbd, 0x51, 0xf4, 0x8e, 0x3d, 0x1f, 0x5f, 0xc1, 0xac, 0x9c,
0x21, 0xdd, 0x42, 0x20, 0x34, 0xa2, 0x90, 0x7c, 0x04, 0x60, 0x9c, 0x21, 0x62, 0x5d, 0x5b, 0x4a,
0x06, 0x39, 0x49, 0x79, 0x03, 0xb2, 0x33, 0xd0, 0xdd, 0x33, 0x58, 0xa9, 0x41, 0xe1, 0xa2, 0xe8,
0x92, 0x55, 0x8a, 0xa2, 0xbe, 0xc9, 0x2e, 0x34, 0x59, 0xca, 0xfc, 0xb8, 0x57, 0x26, 0x00, 0x8e,
0x07, 0x08, 0x7a, 0xc5, 0x21, 0x18, 0xa0, 0xd2, 0x58, 0x78, 0x2e, 0x0f, 0x50, 0x69, 0x1c, 0xba,
0x3e, 0x26, 0x35, 0xd6, 0xa2, 0xa5, 0x0a, 0xc7, 0x99, 0xec, 0x1d, 0x98, 0xf3, 0xc5, 0x14, 0xb5,
0xb0, 0xf6, 0xd0, 0xc2, 0x3c, 0x8d, 0xe0, 0x12, 0x3c, 0x81, 0x8e, 0xd2, 0xe4, 0x2c, 0x3a, 0x57,
0xde, 0xf1, 0x16, 0x06, 0x2b, 0x05, 0x2b, 0xf3, 0x89, 0xd0, 0x67, 0x3e, 0x72, 0x6b, 0x79, 0xf8,
0xdb, 0xfd, 0x33, 0x07, 0x96, 0x4e, 0xd2, 0x9c, 0x9d, 0xa5, 0x71, 0x94, 0xca, 0xd4, 0x99, 0xa7,
0x12, 0x2a, 0xb5, 0x96, 0x39, 0x9a, 0xfc, 0xe4, 0x11, 0x32, 0x48, 0xa3, 0x44, 0xf8, 0x6a, 0x43,
0x2a, 0x28, 0x8d, 0x12, 0xee, 0xaa, 0x64, 0x0f, 0x9a, 0x21, 0x2d, 0x82, 0x3c, 0xca, 0x78, 0xa9,
0x24, 0xc3, 0x82, 0x09, 0xe2, 0x84, 0x4f, 0xfd, 0xd8, 0x4f, 0x02, 0x2a, 0x23, 0xbb, 0xfa, 0x74,
0xd7, 0x30, 0x5c, 0x69, 0x49, 0x8c, 0xaa, 0xd5, 0x06, 0xcb, 0xa5, 0xfc, 0x16, 0xcc, 0x67, 0x0a,
0x28, 0xdd, 0xaf, 0xa3, 0x34, 0x34, 0xbc, 0x1c, 0xaf, 0x44, 0x75, 0xb7, 0x79, 0x5e, 0x5d, 0xd2,
0x7b, 0xd1, 0xbf, 0xba, 0xf2, 0xf3, 0x81, 0xe2, 0x96, 0xc0, 0xf4, 0x51, 0x1a, 0x25, 0x5c, 0x51,
0x7c, 0x51, 0x2a, 0xf1, 0xe2, 0xbf, 0x4d, 0xd1, 0x1b, 0x96, 0xe8, 0xa6, 0xb6, 0xa6, 0x6c, 0x6d,
0xdd, 0x05, 0xc8, 0x68, 0x1e, 0xd0, 0x84, 0xf9, 0xe7, 0x6a, 0xc5, 0x06, 0xc4, 0xbd, 0x00, 0xf2,
0xfc, 0xec, 0x2c, 0x8e, 0x12, 0xca, 0xd9, 0x4a, 0x61, 0xc6, 0x68, 0x7f, 0xb4, 0x0c, 0x36, 0xa7,
0xa9, 0x0a, 0xa7, 0x9f, 0xc1, 0xf2, 0xf3, 0xa4, 0x86, 0x91, 0x22, 0xe7, 0x8c, 0x23, 0xd7, 0xa8,
0x90, 0xfb, 0x31, 0xb4, 0x0c, 0xc1, 0x0b, 0xf2, 0x21, 0xcc, 0x4b, 0x19, 0x75, 0x12, 0xde, 0xd5,
0xd1, 0xa0, 0xb2, 0x42, 0xaf, 0x44, 0x76, 0xff, 0xda, 0x81, 0x66, 0x29, 0x59, 0x41, 0x9e, 0xc0,
0x1d, 0xae, 0x6e, 0x45, 0xe5, 0xae, 0xa6, 0x52, 0xe2, 0xec, 0xe3, 0xbf, 0x22, 0x77, 0x17, 0xc8,
0xdd, 0x17, 0x00, 0x25, 0xb0, 0x26, 0x6b, 0x3f, 0xb0, 0xab, 0xaf, 0xcd, 0x2a, 0x55, 0x25, 0x9a,
0x91, 0xd0, 0xff, 0xeb, 0x34, 0x2f, 0xa5, 0x6a, 0x9c, 0x45, 0xfa, 0xe0, 0x7b, 0xd0, 0x14, 0x7b,
0x81, 0x47, 0x00, 0x25, 0x70, 0xab, 0x6c, 0x1b, 0x44, 0x89, 0x07, 0xb8, 0x37, 0x70, 0x9c, 0xbc,
0x0f, 0x0b, 0x28, 0x6c, 0x2f, 0x15, 0x0a, 0x91, 0x1b, 0xdb, 0x9e, 0xd0, 0x42, 0x14, 0xa9, 0x32,
0x92, 0xc1, 0x9a, 0x35, 0xa5, 0x57, 0x08, 0x11, 0xe4, 0x21, 0xf5, 0x43, 0xa3, 0xce, 0x19, 0x25,
0xa5, 0x50, 0x96, 0x24, 0x28, 0xc7, 0x84, 0xea, 0x56, 0x82, 0xea, 0x08, 0x39, 0x80, 0x96, 0xe4,
0x88, 0x9a, 0x91, 0x47, 0x9c, 0x2d, 0x63, 0x53, 0x4c, 0x44, 0x04, 0x72, 0x05, 0xab, 0xe6, 0x04,
0x2d, 0xe1, 0x1d, 0x9c, 0xf8, 0xd1, 0xe4, 0x12, 0x26, 0x15, 0x01, 0x49, 0x50, 0x19, 0xe8, 0xfe,
0x21, 0x74, 0x46, 0x2d, 0xa8, 0xc6, 0xec, 0x6f, 0xdb, 0x66, 0x5f, 0xad, 0x71, 0xc9, 0xc2, 0x6c,
0xce, 0x7d, 0x01, 0x1b, 0x23, 0x84, 0x79, 0x83, 0x8a, 0xde, 0xf0, 0x54, 0xd3, 0x9b, 0xfe, 0xd2,
0x81, 0xee, 0x61, 0x18, 0x56, 0x82, 0x53, 0x59, 0x80, 0x7f, 0xdb, 0x21, 0x77, 0x07, 0xb6, 0x6a,
0x05, 0x92, 0x9d, 0x82, 0xd7, 0xb0, 0xe3, 0xd1, 0xab, 0xf4, 0x9a, 0x7e, 0xdb, 0x22, 0xbb, 0x7b,
0x70, 0x77, 0x14, 0x67, 0x29, 0x1b, 0xb6, 0xce, 0xec, 0xd6, 0xb3, 0x4e, 0x8c, 0xfe, 0xcb, 0x81,
0x05, 0xbb, 0x29, 0xfd, 0x4d, 0xd5, 0xd1, 0xef, 0x02, 0xc9, 0x69, 0xc1, 0x7a, 0x79, 0x1a, 0xc7,
0xbc, 0x9c, 0x0e, 0x69, 0xec, 0x0f, 0x64, 0x3b, 0x7c, 0x89, 0x8f, 0x78, 0x62, 0xe0, 0x13, 0x0e,
0x27, 0x1b, 0x30, 0xeb, 0x67, 0x51, 0x8f, 0x7b, 0x8d, 0xa8, 0xa5, 0x67, 0xfc, 0x2c, 0xfa, 0x09,
0x1d, 0x10, 0x17, 0x16, 0xe4, 0x40, 0x2f, 0xa6, 0xd7, 0x34, 0xc6, 0x9c, 0x6f, 0xca, 0x6b, 0x8a,
0xe1, 0x9f, 0x72, 0x10, 0xaf, 0x7d, 0xb3, 0x3c, 0xe2, 0xee, 0x57, 0xf6, 0xdd, 0x67, 0x51, 0x9a,
0xb6, 0x84, 0xab, 0xd5, 0xb9, 0xbf, 0x80, 0xcd, 0x1a, 0x5d, 0xc8, 0x18, 0xf5, 0x23, 0x68, 0xdb,
0xdd, 0x7b, 0x15, 0xa7, 0x74, 0xd6, 0x6a, 0x4d, 0xf4, 0x16, 0xcf, 0x2c, 0x3a, 0x32, 0xfb, 0x44,
0x1c, 0xcf, 0x67, 0xba, 0x5f, 0xe4, 0x7e, 0x09, 0xab, 0x25, 0xf0, 0x28, 0x4d, 0xae, 0x69, 0x5e,
0x70, 0x6f, 0x23, 0x30, 0x7d, 0x96, 0xa7, 0xaa, 0xd9, 0x89, 0xbf, 0x79, 0xde, 0xc6, 0x52, 0xe9,
0x06, 0x0d, 0x96, 0x72, 0x9c, 0xdc, 0x67, 0xea, 0x94, 0xc2, 0xdf, 0x3c, 0x4f, 0x8e, 0x90, 0x08,
0xed, 0xe1, 0x98, 0x70, 0xd5, 0xa6, 0x84, 0x71, 0x2e, 0xee, 0x2b, 0x4c, 0x1f, 0x4d, 0x51, 0xe4,
0x1a, 0x7f, 0x07, 0x9a, 0x62, 0x8d, 0x7c, 0xa6, 0x5a, 0xdf, 0xb6, 0xb5, 0xbe, 0x21, 0x31, 0x3d,
0x38, 0xd3, 0x50, 0xf7, 0xd7, 0x0d, 0x68, 0x61, 0xc6, 0xfa, 0x09, 0x65, 0x7e, 0x14, 0x8f, 0xcf,
0xa5, 0x45, 0x0e, 0xda, 0xd0, 0x39, 0xe8, 0x77, 0x60, 0xc1, 0x6c, 0x66, 0x0c, 0x54, 0x31, 0x6b,
0xb4, 0x32, 0x06, 0xe4, 0x3e, 0x2c, 0x62, 0x69, 0x5d, 0x62, 0x09, 0x9f, 0x59, 0x40, 0xa8, 0x46,
0xb3, 0x0b, 0x81, 0x3b, 0x43, 0x85, 0x00, 0x1f, 0xc6, 0x64, 0xba, 0x57, 0x44, 0xa1, 0xae, 0x13,
0x10, 0xf2, 0x22, 0x0a, 0x8d, 0x61, 0x9c, 0x3d, 0x6b, 0x0c, 0xe3, 0x6c, 0x5e, 0x03, 0xe5, 0x54,
0x34, 0xe1, 0xf1, 0x2e, 0x69, 0x0e, 0x9d, 0xae, 0xa5, 0x80, 0x2f, 0xa3, 0x2b, 0xbc, 0x69, 0x92,
0x8d, 0x63, 0xd1, 0x67, 0x91, 0x5f, 0x65, 0x99, 0x06, 0x66, 0x99, 0x56, 0x16, 0x75, 0x4d, 0xab,
0xa8, 0xdb, 0x85, 0x66, 0x9a, 0xd1, 0xa4, 0x27, 0x4b, 0xec, 0x96, 0xc8, 0x1e, 0x38, 0xe8, 0x15,
0x42, 0x64, 0xcb, 0x04, 0x75, 0x5e, 0x4c, 0x52, 0x97, 0xda, 0x8a, 0x69, 0x0c, 0x2b, 0x46, 0x15,
0x82, 0x53, 0xb7, 0x15, 0x82, 0xee, 0x21, 0x66, 0xc5, 0x8a, 0xb1, 0x74, 0x9f, 0x77, 0x61, 0x06,
0xd5, 0xa4, 0x3c, 0x67, 0xd5, 0x2a, 0x63, 0xa4, 0x53, 0x78, 0x12, 0xc7, 0xfd, 0x31, 0xde, 0xcf,
0xe1, 0xd0, 0x24, 0xa2, 0x6f, 0xc2, 0x9c, 0xb0, 0x8a, 0xf6, 0x9a, 0x59, 0xfc, 0x7e, 0x16, 0xba,
0xff, 0xee, 0x00, 0x79, 0xd1, 0x3f, 0xbd, 0x8a, 0x26, 0xa7, 0x36, 0x79, 0x81, 0x4e, 0x60, 0x1a,
0xdd, 0x44, 0xb8, 0x23, 0xfe, 0x1e, 0xf2, 0x90, 0xe9, 0x61, 0x0f, 0x29, 0xcd, 0x79, 0xa7, 0xbe,
0x46, 0x9f, 0x31, 0x8d, 0xcf, 0x43, 0x7c, 0x1c, 0xd1, 0x84, 0xf5, 0x64, 0xb3, 0x85, 0x87, 0x78,
0x04, 0x3c, 0x0b, 0xdd, 0x17, 0xb0, 0x62, 0xad, 0x4c, 0x6a, 0xfa, 0x1e, 0xb4, 0x84, 0x00, 0x59,
0xec, 0x07, 0xba, 0xd3, 0xdc, 0x44, 0xd8, 0x09, 0x82, 0xc6, 0xe9, 0xeb, 0xbf, 0x1d, 0x20, 0x47,
0xfc, 0xe0, 0x8a, 0x27, 0xd6, 0x17, 0x77, 0x1c, 0x51, 0x25, 0x95, 0xf4, 0xe6, 0x25, 0xe4, 0x99,
0xcd, 0x6c, 0xca, 0x62, 0xa6, 0x35, 0x3d, 0xfd, 0x86, 0xad, 0x90, 0xca, 0xae, 0xbd, 0x0f, 0x8b,
0x37, 0x7e, 0x1c, 0x53, 0xa6, 0x2f, 0x2b, 0x64, 0xcf, 0x54, 0x40, 0x55, 0xc5, 0xa5, 0xec, 0x35,
0x5b, 0xda, 0x8b, 0x97, 0x44, 0xd6, 0x7a, 0xe5, 0xd9, 0xf7, 0x04, 0xd6, 0x05, 0xf8, 0x30, 0x8e,
0x27, 0xde, 0x43, 0xee, 0xdf, 0x34, 0x60, 0xa3, 0x32, 0x4d, 0x1f, 0x12, 0xf6, 0x0e, 0x78, 0xa0,
0x97, 0x5b, 0x3f, 0x61, 0x5f, 0x7e, 0xca, 0x59, 0xdd, 0x7f, 0x76, 0x60, 0x46, 0x80, 0xc6, 0x5a,
0xe3, 0x0b, 0x65, 0x7e, 0x19, 0x63, 0x44, 0xfe, 0xfb, 0xfd, 0xc9, 0x98, 0x89, 0xff, 0xcc, 0x0b,
0x2a, 0xe1, 0x37, 0xf2, 0x6e, 0xea, 0x47, 0xb0, 0x34, 0x8c, 0xf0, 0x46, 0xcd, 0x7b, 0x51, 0x43,
0x3f, 0xbd, 0xa6, 0xc6, 0x85, 0xd4, 0xd7, 0x0e, 0xb4, 0x8f, 0xd2, 0x24, 0x8c, 0x78, 0x7c, 0x3c,
0xf1, 0x73, 0xff, 0xaa, 0x90, 0x77, 0xa2, 0x02, 0xa4, 0x9a, 0xac, 0x1a, 0x30, 0xa2, 0x9d, 0xb5,
0x03, 0x10, 0x5c, 0xd0, 0xe0, 0xb2, 0x27, 0xfb, 0x4b, 0xe2, 0x22, 0x95, 0x43, 0x3e, 0x8e, 0xc2,
0x82, 0xbc, 0x07, 0x2b, 0xe5, 0x70, 0xcf, 0x4f, 0xc2, 0x9e, 0x6c, 0x2e, 0x61, 0xbf, 0x59, 0xe3,
0x1d, 0x26, 0xe1, 0x61, 0x71, 0x89, 0x5d, 0x71, 0xdd, 0x53, 0xe9, 0x59, 0x1b, 0xb6, 0xad, 0xe1,
0x87, 0x08, 0x76, 0xff, 0xc7, 0xc1, 0x78, 0xa7, 0x56, 0x25, 0xad, 0x5d, 0xb6, 0x51, 0xb0, 0xbb,
0x66, 0x99, 0xac, 0x31, 0x64, 0x32, 0x02, 0xd3, 0x11, 0xa3, 0x57, 0x2a, 0x8c, 0xf0, 0xdf, 0xe4,
0x63, 0x58, 0xd2, 0x2b, 0xee, 0x65, 0xa8, 0x16, 0xb9, 0x4d, 0x36, 0xca, 0x32, 0xc1, 0xd2, 0x9a,
0xd7, 0x0e, 0x86, 0xd4, 0xa8, 0xb6, 0xd7, 0x9d, 0x5b, 0xb7, 0x17, 0x8f, 0x4a, 0x01, 0x6a, 0x7b,
0x46, 0x26, 0x51, 0xf8, 0x25, 0xa4, 0xa6, 0x41, 0x9f, 0xd1, 0x50, 0x26, 0x46, 0xfa, 0xdb, 0xfd,
0x4f, 0x07, 0xda, 0x87, 0x61, 0x88, 0xeb, 0x9e, 0x24, 0x4c, 0xa8, 0x55, 0x36, 0x6e, 0x59, 0xe5,
0xd4, 0xff, 0x73, 0x95, 0xbf, 0x71, 0x10, 0x19, 0xa1, 0x04, 0xd7, 0x85, 0xa5, 0x72, 0x9d, 0xf5,
0xe6, 0x75, 0xbf, 0x0b, 0x44, 0x24, 0xd3, 0x96, 0x3a, 0x86, 0xb1, 0xd6, 0x60, 0xc5, 0xc2, 0x92,
0xb1, 0xe6, 0x53, 0x78, 0x78, 0x4c, 0xd9, 0x51, 0x3e, 0xc8, 0x58, 0xaa, 0x92, 0x97, 0x4f, 0x68,
0x96, 0x16, 0x91, 0x8a, 0x5c, 0x74, 0xa2, 0xe8, 0xf3, 0x2f, 0x0e, 0x3c, 0x9a, 0x80, 0x90, 0x5c,
0xc2, 0x1f, 0x55, 0xbb, 0x09, 0xbf, 0x67, 0x3e, 0x14, 0x98, 0x88, 0xca, 0xbe, 0x86, 0xc8, 0xfb,
0x5a, 0x4d, 0xb2, 0xfb, 0x43, 0x58, 0xb4, 0x07, 0xdf, 0x28, 0x54, 0xc4, 0xf0, 0xe0, 0x16, 0x21,
0x26, 0xf1, 0xb9, 0x07, 0xb0, 0x18, 0x58, 0x24, 0x24, 0xa3, 0x21, 0xa8, 0x7b, 0x04, 0x6f, 0xdd,
0xca, 0x4d, 0xaa, 0x6d, 0x64, 0x3d, 0xe6, 0xfe, 0xfd, 0x34, 0x6c, 0x7c, 0x1e, 0xb1, 0x8b, 0x30,
0xf7, 0x6f, 0x94, 0xf7, 0x4d, 0x22, 0xe4, 0x50, 0xa9, 0xd6, 0xa8, 0x56, 0x97, 0x6f, 0xc3, 0x72,
0x9a, 0x50, 0xcc, 0x28, 0x7b, 0x99, 0x5f, 0x14, 0x37, 0x69, 0xae, 0xce, 0xd2, 0x76, 0x9a, 0x50,
0x9e, 0x55, 0x9e, 0x48, 0xf0, 0xd0, 0x69, 0x3c, 0x3d, 0x7c, 0x1a, 0x2f, 0xc1, 0x54, 0x16, 0x25,
0xb2, 0x43, 0xce, 0x7f, 0xf2, 0xb3, 0x93, 0xe5, 0x7e, 0x68, 0x50, 0x96, 0x67, 0x27, 0x42, 0x35,
0x5d, 0xb3, 0x67, 0x3b, 0x3b, 0xd4, 0xb3, 0x35, 0x74, 0x32, 0x67, 0xd7, 0xa8, 0xbb, 0xd0, 0x94,
0x3f, 0x7b, 0xcc, 0x3f, 0x97, 0x09, 0x2f, 0x48, 0xd0, 0x4b, 0xff, 0xdc, 0xc8, 0x87, 0xc0, 0xca,
0x87, 0x76, 0x00, 0xce, 0x28, 0xed, 0x59, 0xa9, 0xef, 0xfc, 0x19, 0xa5, 0x22, 0xe8, 0xf2, 0xc4,
0xe8, 0xd4, 0x4f, 0x2e, 0x7b, 0x58, 0x71, 0xb6, 0x84, 0x38, 0x1c, 0xf0, 0x19, 0xaf, 0x3a, 0xef,
0x41, 0x0b, 0x07, 0x95, 0x4c, 0x0b, 0x42, 0xa3, 0x1c, 0x76, 0x58, 0xd6, 0xce, 0x88, 0x12, 0x44,
0x6c, 0xd0, 0x59, 0x2c, 0xe7, 0x1f, 0x45, 0x6c, 0xa0, 0xe7, 0xa3, 0xce, 0xf2, 0x41, 0xa7, 0x5d,
0xce, 0x3f, 0x12, 0x20, 0x2e, 0x5e, 0x71, 0x13, 0x9d, 0x51, 0x71, 0xc5, 0xbe, 0x24, 0x1f, 0x9d,
0x70, 0xc8, 0x51, 0x1a, 0x62, 0x1d, 0x70, 0x13, 0xe5, 0x46, 0x29, 0xb2, 0x2c, 0x0a, 0x16, 0x0e,
0x54, 0xae, 0xe1, 0xbe, 0x0d, 0x4b, 0xca, 0x5d, 0xcc, 0x57, 0x68, 0x39, 0x2d, 0xfa, 0x31, 0x53,
0xaf, 0xd0, 0xc4, 0xd7, 0xe3, 0x5f, 0xef, 0xc2, 0xe2, 0x71, 0x2a, 0x1c, 0xf4, 0x25, 0xb7, 0x4b,
0x4e, 0x9e, 0xc3, 0xac, 0x7c, 0x5a, 0x45, 0xd6, 0x2b, 0x6f, 0xad, 0xd0, 0xeb, 0xba, 0x1b, 0x23,
0xde, 0x60, 0xb9, 0x2b, 0xbf, 0xfc, 0xb7, 0xff, 0xf8, 0x55, 0x63, 0x81, 0x34, 0x0f, 0xae, 0xdf,
0x3f, 0x38, 0xa7, 0x2c, 0xe2, 0x54, 0x2e, 0x60, 0xc1, 0x7a, 0x0d, 0x43, 0xb6, 0xad, 0x17, 0x2d,
0x43, 0x8f, 0x64, 0xba, 0x3b, 0x63, 0xdf, 0xbb, 0xb8, 0x5d, 0x64, 0xb1, 0x4a, 0x88, 0x64, 0x51,
0x20, 0x8a, 0x20, 0xfc, 0x25, 0xb4, 0x9f, 0x62, 0x1f, 0x40, 0x53, 0x25, 0xbb, 0x25, 0xb5, 0xda,
0x57, 0x3e, 0xdd, 0xbd, 0xd1, 0x08, 0x92, 0xe3, 0x16, 0x72, 0x5c, 0x23, 0x2b, 0x9c, 0xa3, 0xe8,
0x33, 0xe8, 0xd7, 0x35, 0xa4, 0x80, 0x25, 0xf9, 0x6e, 0xe0, 0x1b, 0xe5, 0xb9, 0x8d, 0x3c, 0xd7,
0xc9, 0x2a, 0xe7, 0x19, 0x0a, 0x06, 0x25, 0xd3, 0x14, 0xcb, 0x18, 0xf3, 0x9d, 0x0b, 0xb9, 0x3b,
0xf2, 0x01, 0x8c, 0x60, 0xb9, 0x7b, 0xcb, 0x03, 0x19, 0x7b, 0x95, 0xe7, 0x94, 0xe3, 0xea, 0x37,
0x32, 0xe4, 0x57, 0x0e, 0xb6, 0x6c, 0x6a, 0x5f, 0x64, 0x91, 0xb7, 0x6e, 0x7f, 0x06, 0x26, 0x64,
0x78, 0x38, 0xe9, 0x7b, 0x31, 0xf7, 0xbb, 0x28, 0xcc, 0x5d, 0xb2, 0x2d, 0x85, 0xb1, 0xde, 0x88,
0xa9, 0x57, 0x68, 0x24, 0x80, 0x96, 0xf9, 0xb8, 0x85, 0x6c, 0xd5, 0xbc, 0x1c, 0xd1, 0xcc, 0xb7,
0xeb, 0x07, 0x25, 0xc3, 0x0e, 0x32, 0x24, 0x64, 0x49, 0x32, 0xd4, 0x6f, 0x61, 0xc8, 0x57, 0xd0,
0x1e, 0x7a, 0x18, 0x42, 0xdc, 0x21, 0xf3, 0xd5, 0x3c, 0xf2, 0xe9, 0x7e, 0x67, 0x2c, 0x8e, 0xe4,
0x7a, 0x17, 0xb9, 0x76, 0xdc, 0x15, 0xc3, 0xca, 0x8a, 0xf3, 0x0f, 0x9c, 0xb7, 0x49, 0x81, 0x76,
0x36, 0x5f, 0x97, 0x4c, 0xc4, 0x7b, 0xb7, 0x66, 0xa9, 0xd6, 0x36, 0x1d, 0xb6, 0xb5, 0xe2, 0x89,
0xdb, 0xb5, 0xc0, 0xbb, 0x6b, 0xe3, 0xe5, 0x0d, 0x46, 0x9e, 0x49, 0xf8, 0xee, 0xd4, 0xbf, 0xdc,
0x91, 0x8f, 0x87, 0x2a, 0x3b, 0x57, 0x71, 0x4d, 0x59, 0x46, 0x0a, 0xeb, 0x61, 0x93, 0x64, 0x6a,
0x7b, 0x75, 0xcd, 0xd3, 0xa2, 0xda, 0x95, 0x9a, 0x6f, 0x85, 0x46, 0xae, 0x34, 0x65, 0x59, 0x41,
0x5e, 0xc3, 0xa2, 0x08, 0x17, 0xdf, 0xbc, 0x65, 0x77, 0x90, 0xef, 0x86, 0x4b, 0xca, 0x98, 0x61,
0x1a, 0xf6, 0x73, 0x98, 0xd7, 0xef, 0x03, 0x48, 0xc7, 0x58, 0x84, 0xf5, 0x12, 0xa5, 0x3b, 0xe2,
0x9d, 0x81, 0xf2, 0x56, 0x77, 0x41, 0xae, 0x4a, 0xbc, 0x1a, 0xe0, 0x84, 0x7f, 0x01, 0x50, 0x3e,
0x3c, 0x20, 0x9b, 0x15, 0xca, 0x5a, 0x73, 0xdd, 0xba, 0x21, 0xf5, 0x7c, 0x11, 0xc9, 0x2f, 0x91,
0x45, 0x8b, 0xbc, 0xda, 0x6f, 0xfa, 0x7e, 0xd8, 0xda, 0x6f, 0xc3, 0x4f, 0x15, 0xba, 0xa3, 0xef,
0xa8, 0x95, 0x51, 0x5c, 0xb5, 0xd9, 0x74, 0xe5, 0xc3, 0x57, 0x70, 0x8e, 0xa7, 0x85, 0x71, 0x39,
0xbe, 0x5d, 0xc7, 0xa5, 0xf6, 0xb4, 0xa8, 0xde, 0x74, 0xbb, 0x9b, 0xc8, 0x6a, 0x85, 0x2c, 0x0f,
0xb3, 0x2a, 0xc8, 0x25, 0x3e, 0xdf, 0x36, 0xee, 0x76, 0x89, 0x49, 0xab, 0x7a, 0xd1, 0xdd, 0xbd,
0x3b, 0x6a, 0x78, 0xc4, 0xc9, 0x24, 0x93, 0x23, 0xdc, 0x54, 0xc2, 0xe0, 0xe2, 0x46, 0xd7, 0x32,
0xb8, 0x75, 0xf1, 0xdb, 0xdd, 0xac, 0x19, 0x91, 0xd4, 0xd7, 0x90, 0x7a, 0x9b, 0x2c, 0xe8, 0x90,
0x88, 0xb4, 0x84, 0x4d, 0x74, 0xab, 0xdd, 0xb2, 0xc9, 0xf0, 0x7d, 0xac, 0x15, 0x03, 0x2b, 0xb7,
0xb2, 0x95, 0x18, 0xa8, 0xef, 0x5d, 0xc9, 0x9f, 0xda, 0xd7, 0xbb, 0xea, 0xba, 0xc9, 0x1d, 0x7b,
0x3f, 0x54, 0xd9, 0x2d, 0x23, 0xef, 0x90, 0xdc, 0x5d, 0xe4, 0xbc, 0x49, 0x36, 0x86, 0x39, 0xcb,
0xfb, 0x28, 0xf2, 0x4b, 0x07, 0x56, 0x6a, 0x6e, 0x3b, 0x4a, 0x09, 0x46, 0xdf, 0xcd, 0x94, 0x12,
0x8c, 0xbb, 0x2e, 0x71, 0x51, 0x82, 0x6d, 0x17, 0x25, 0xf0, 0xc3, 0x50, 0x4b, 0x20, 0x73, 0x3d,
0xee, 0x99, 0x7f, 0xe1, 0xc0, 0x7a, 0xfd, 0xcd, 0x06, 0xb9, 0xaf, 0x1f, 0x84, 0x8e, 0xbb, 0x73,
0xe9, 0x3e, 0xb8, 0x0d, 0x4d, 0x4a, 0x73, 0x1f, 0xa5, 0xd9, 0x75, 0xbb, 0x5c, 0x9a, 0x1c, 0x71,
0xeb, 0x04, 0xba, 0xc1, 0x06, 0x81, 0x7d, 0x77, 0x40, 0x8c, 0xdc, 0xa2, 0xfe, 0x8a, 0xa5, 0x7b,
0x6f, 0x0c, 0x86, 0x1d, 0xbe, 0xc8, 0x9a, 0x34, 0x08, 0x36, 0xdc, 0xf5, 0x25, 0x84, 0xdc, 0xa3,
0x65, 0x6f, 0xde, 0xda, 0xa3, 0x95, 0xeb, 0x06, 0x6b, 0x8f, 0x56, 0x6f, 0x00, 0x2a, 0x7b, 0x14,
0x99, 0xe1, 0x6d, 0x00, 0xf9, 0x02, 0xb7, 0x8d, 0xec, 0x4e, 0x75, 0x86, 0xb7, 0x7a, 0x51, 0xb7,
0x6d, 0xec, 0xfe, 0x53, 0x25, 0x54, 0x8a, 0xa6, 0x17, 0xd7, 0x9e, 0x07, 0x73, 0x0a, 0x9d, 0x6c,
0x0c, 0x13, 0x50, 0x94, 0x6b, 0xdb, 0xc9, 0xee, 0x06, 0x12, 0x5d, 0x76, 0x5b, 0x26, 0x51, 0x4e,
0xf3, 0x14, 0x9a, 0x46, 0xeb, 0x94, 0xe8, 0x20, 0x5b, 0xed, 0x14, 0x77, 0xb7, 0x6a, 0xc7, 0xec,
0x50, 0xe2, 0xb6, 0x39, 0x83, 0x02, 0x11, 0x4c, 0x1e, 0x46, 0x63, 0xb1, 0xe4, 0x51, 0xed, 0xae,
0x96, 0x3c, 0xea, 0x3a, 0x91, 0x16, 0x8f, 0x00, 0x11, 0x34, 0x8f, 0x1c, 0xda, 0x43, 0x0d, 0xbd,
0xf2, 0x28, 0xae, 0x6f, 0x5f, 0x96, 0x47, 0xf1, 0x88, 0x4e, 0xa0, 0x9d, 0xec, 0x08, 0x7e, 0x7e,
0x1c, 0x97, 0xf6, 0x10, 0x21, 0x52, 0xb4, 0xbb, 0x2c, 0x5b, 0x5b, 0x7d, 0x3d, 0xcb, 0xd6, 0x76,
0x6f, 0xac, 0x12, 0x22, 0xa9, 0xa0, 0xf5, 0x0a, 0xe6, 0x54, 0x9f, 0xa5, 0x34, 0xf4, 0x50, 0x87,
0xa9, 0xdb, 0xa9, 0x0e, 0x48, 0xaa, 0x96, 0xb1, 0xfd, 0x30, 0x44, 0xaa, 0xd2, 0x10, 0x46, 0xd7,
0xa5, 0x34, 0x44, 0xb5, 0x61, 0x53, 0x1a, 0xa2, 0xae, 0x4d, 0x63, 0x19, 0x42, 0xec, 0x76, 0xcd,
0xe3, 0x1f, 0x1c, 0xb8, 0x77, 0x6b, 0xd3, 0x84, 0x7c, 0xef, 0x0d, 0xfa, 0x2b, 0x42, 0xa0, 0xf7,
0xdf, 0xb8, 0x23, 0xe3, 0x3e, 0x44, 0x31, 0x5d, 0x77, 0x47, 0x1d, 0x40, 0x38, 0x2d, 0x14, 0xe8,
0xba, 0x3d, 0xc3, 0x85, 0xfe, 0x3b, 0x47, 0xfc, 0x41, 0xcb, 0x18, 0xba, 0x64, 0x7f, 0x42, 0x01,
0x94, 0xc0, 0x07, 0x13, 0xe3, 0x4b, 0x71, 0x1f, 0xa0, 0xb8, 0x7b, 0xee, 0xd6, 0x18, 0x71, 0xb9,
0xb0, 0x7f, 0x02, 0x5b, 0xba, 0xb9, 0x62, 0xd1, 0xfd, 0xb4, 0x9f, 0x84, 0x45, 0x59, 0xcb, 0x8d,
0xe8, 0xc0, 0x94, 0x8e, 0x33, 0x5c, 0x73, 0xdb, 0x67, 0xca, 0x8d, 0x1c, 0x15, 0x62, 0x9c, 0x71,
0xda, 0x9c, 0x7b, 0x06, 0xcb, 0x6a, 0xde, 0xa7, 0x91, 0xcf, 0x7e, 0x63, 0x9e, 0x7b, 0xc8, 0xb3,
0xeb, 0xae, 0x99, 0x3c, 0xcf, 0x22, 0x9f, 0x29, 0x8e, 0xa7, 0x33, 0xf8, 0xc7, 0x6b, 0x1f, 0xfc,
0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4b, 0x08, 0xf6, 0x2c, 0xef, 0x36, 0x00, 0x00,
// 4250 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x4d, 0x6f, 0x25, 0x49,
0x52, 0xaa, 0x67, 0xb7, 0x3f, 0xe2, 0x3d, 0xfb, 0xd9, 0xe9, 0xaf, 0xd7, 0xaf, 0xed, 0xfe, 0xa8,
0xd9, 0xe9, 0xe9, 0x9e, 0x0f, 0xf7, 0x4c, 0x4f, 0x8b, 0x1d, 0x76, 0x96, 0x05, 0x8f, 0xa7, 0xc7,
0xdb, 0xec, 0xec, 0xb4, 0xa9, 0xee, 0xed, 0x96, 0x66, 0xd1, 0x16, 0xe5, 0xaa, 0xb4, 0x5d, 0x74,
0xbd, 0xaa, 0x9a, 0xaa, 0x7c, 0x76, 0x7b, 0x84, 0x84, 0xb4, 0x12, 0x88, 0x13, 0x1c, 0x56, 0x48,
0x1c, 0x38, 0x71, 0x44, 0xe2, 0x82, 0x38, 0x81, 0x34, 0xe2, 0x8a, 0x38, 0x72, 0xe1, 0x07, 0x20,
0x6e, 0x80, 0x84, 0xc4, 0x85, 0x13, 0xca, 0xc8, 0x8f, 0xca, 0x7c, 0x55, 0xef, 0xf9, 0x35, 0xdb,
0x3b, 0x97, 0xee, 0x57, 0x91, 0x91, 0x11, 0x91, 0x11, 0x91, 0x91, 0x91, 0x91, 0x61, 0x58, 0x2c,
0xf2, 0x70, 0x37, 0x2f, 0x32, 0x96, 0x91, 0xb9, 0x93, 0x90, 0x15, 0x79, 0xd8, 0xdf, 0x3e, 0xc9,
0xb2, 0x93, 0x84, 0xde, 0x0b, 0xf2, 0xf8, 0x5e, 0x90, 0xa6, 0x19, 0x0b, 0x58, 0x9c, 0xa5, 0xa5,
0xc0, 0x72, 0x57, 0x60, 0xf9, 0x80, 0xb2, 0x47, 0xe9, 0x71, 0xe6, 0xd1, 0xaf, 0x86, 0xb4, 0x64,
0xee, 0xdf, 0xcd, 0x42, 0x57, 0x83, 0xca, 0x3c, 0x4b, 0x4b, 0x4a, 0x36, 0x61, 0x6e, 0x98, 0xb3,
0x78, 0x40, 0x7b, 0xce, 0x4d, 0xe7, 0xce, 0xa2, 0x27, 0xbf, 0xc8, 0x3d, 0x58, 0x0b, 0xce, 0x82,
0x38, 0x09, 0x8e, 0x12, 0xea, 0xd3, 0x97, 0xe1, 0x69, 0x90, 0x9e, 0xd0, 0xb2, 0xd7, 0xba, 0xe9,
0xdc, 0x99, 0xf1, 0x88, 0x1e, 0x7a, 0xa8, 0x46, 0xc8, 0x3b, 0xb0, 0x4a, 0x53, 0x0e, 0x8a, 0x0c,
0xf4, 0x19, 0x44, 0x5f, 0x91, 0x03, 0x15, 0xf2, 0x03, 0xd8, 0x8c, 0xe8, 0x71, 0x30, 0x4c, 0x98,
0x7f, 0x9c, 0x15, 0xf4, 0xa5, 0x9f, 0x17, 0xd9, 0x59, 0x1c, 0xd1, 0xa2, 0x37, 0x8b, 0x52, 0xac,
0xcb, 0xd1, 0xcf, 0xf8, 0xe0, 0xa1, 0x1c, 0x23, 0xf7, 0x61, 0x43, 0xcf, 0x8a, 0x03, 0xe6, 0x87,
0xc3, 0xa2, 0xa0, 0x69, 0x78, 0xd1, 0xbb, 0x82, 0x93, 0xd6, 0xd4, 0xa4, 0x38, 0x60, 0xfb, 0x72,
0x88, 0x3c, 0x87, 0x95, 0x72, 0x78, 0x54, 0x5e, 0x94, 0x8c, 0x0e, 0xfc, 0x92, 0x05, 0x6c, 0x58,
0xf6, 0xe6, 0x6e, 0xce, 0xdc, 0x69, 0xdf, 0x7f, 0x77, 0x57, 0xa8, 0x71, 0x77, 0x44, 0x25, 0xbb,
0x4f, 0x14, 0xfe, 0x13, 0x44, 0x7f, 0x98, 0xb2, 0xe2, 0xc2, 0xeb, 0x96, 0x36, 0x94, 0x7c, 0x01,
0x4b, 0x45, 0x1e, 0xfa, 0x34, 0x8d, 0xf2, 0x2c, 0x4e, 0x59, 0xd9, 0x9b, 0x47, 0xaa, 0x77, 0xc7,
0x51, 0xf5, 0xf2, 0xf0, 0xa1, 0xc2, 0x15, 0x24, 0x3b, 0x85, 0x01, 0xea, 0x7f, 0x02, 0xeb, 0x4d,
0x8c, 0xc9, 0x0a, 0xcc, 0xbc, 0xa0, 0x17, 0xd2, 0x3a, 0xfc, 0x27, 0x59, 0x87, 0x2b, 0x67, 0x41,
0x32, 0xa4, 0x68, 0x8c, 0x05, 0x4f, 0x7c, 0x7c, 0xaf, 0xf5, 0x91, 0xd3, 0x7f, 0x0a, 0xab, 0x35,
0x36, 0x0d, 0x04, 0xee, 0x9a, 0x04, 0xda, 0xf7, 0xd7, 0x94, 0xc8, 0xde, 0xe1, 0xbe, 0x9a, 0x6b,
0x50, 0x75, 0x6f, 0xc1, 0x8d, 0x03, 0xca, 0xf6, 0xb3, 0xc1, 0x60, 0x98, 0xc6, 0x21, 0xfa, 0x98,
0x47, 0x93, 0xe0, 0x82, 0x16, 0xa5, 0xf2, 0xac, 0x2f, 0x60, 0xbd, 0x69, 0x9c, 0xf4, 0x60, 0x5e,
0xda, 0x1e, 0xf9, 0x2f, 0x78, 0xea, 0x93, 0x6c, 0xc3, 0x62, 0x98, 0xa5, 0x29, 0x0d, 0x19, 0x8d,
0xe4, 0x42, 0x2a, 0x80, 0xfb, 0xc7, 0x2d, 0xb8, 0x39, 0x9e, 0xa7, 0x74, 0xdd, 0xaf, 0x61, 0x33,
0x34, 0x11, 0xfc, 0x42, 0x62, 0xf4, 0x1c, 0x34, 0xc5, 0xbe, 0x61, 0x8a, 0x89, 0x94, 0x76, 0x1b,
0x47, 0x85, 0x91, 0x36, 0xc2, 0xa6, 0xb1, 0xfe, 0x31, 0xf4, 0xc7, 0x4f, 0x6a, 0x50, 0xf9, 0x7d,
0x5b, 0xe5, 0xdb, 0x4a, 0xb4, 0x26, 0x22, 0xa6, 0xee, 0xbf, 0x0b, 0x5b, 0x07, 0x34, 0xa5, 0x45,
0x1c, 0x6a, 0xe7, 0x90, 0x3a, 0xe7, 0x1a, 0xd4, 0x3e, 0x29, 0x59, 0x55, 0x00, 0xb7, 0x0f, 0xbd,
0xfa, 0x44, 0xb1, 0x5c, 0x77, 0x13, 0xd6, 0x0f, 0x28, 0xd3, 0x70, 0x6d, 0xc5, 0x6f, 0x1c, 0xd8,
0xc0, 0x81, 0xf2, 0xa8, 0xbc, 0x10, 0x03, 0x52, 0xd5, 0xbf, 0x07, 0xab, 0x9a, 0x74, 0xa9, 0xb6,
0x91, 0xd0, 0xf2, 0x87, 0x86, 0x96, 0xeb, 0x33, 0xab, 0xcd, 0x54, 0x9a, 0xbb, 0xa9, 0xda, 0x93,
0x12, 0xdc, 0xdf, 0x87, 0x8d, 0x46, 0xd4, 0x57, 0xf1, 0x7f, 0xb7, 0x07, 0x9b, 0x07, 0x94, 0x19,
0x6e, 0x6c, 0x38, 0x68, 0xdb, 0x00, 0x73, 0xbf, 0x2c, 0x59, 0x50, 0xb0, 0xca, 0x2f, 0xe5, 0x27,
0x79, 0x13, 0x96, 0x93, 0xb8, 0x64, 0x34, 0xf5, 0x83, 0x28, 0x2a, 0x68, 0x29, 0x42, 0xde, 0xa2,
0xb7, 0x24, 0xa0, 0x7b, 0x02, 0xe8, 0xfe, 0xbd, 0xc3, 0x0d, 0x33, 0xc2, 0x4a, 0x2a, 0xeb, 0x73,
0x58, 0xac, 0xa2, 0x82, 0x50, 0xd2, 0xae, 0xa1, 0xa4, 0xa6, 0x39, 0xbb, 0x23, 0xa1, 0xa1, 0x22,
0xd0, 0xff, 0x1d, 0x58, 0x7e, 0xdd, 0x1b, 0xfa, 0x23, 0xe8, 0x4b, 0xdf, 0x50, 0x11, 0xf9, 0x8b,
0x60, 0x40, 0x95, 0x5f, 0xf5, 0x61, 0x41, 0x05, 0x70, 0xc9, 0x43, 0x7f, 0xbb, 0x3b, 0x70, 0xad,
0x71, 0xa6, 0x74, 0xac, 0x7b, 0xb0, 0x76, 0x40, 0x99, 0x0e, 0xf3, 0x8a, 0xe2, 0xd8, 0x28, 0xe0,
0x3e, 0x40, 0x4f, 0x34, 0x26, 0x48, 0x15, 0x6e, 0xc3, 0x62, 0x75, 0x88, 0x48, 0xdf, 0xd6, 0x00,
0xf7, 0x3e, 0xba, 0xa9, 0x9a, 0xf5, 0xf8, 0xe9, 0xa1, 0x47, 0xc5, 0xb4, 0xab, 0xb0, 0x90, 0xb1,
0xdc, 0x0f, 0xb3, 0x48, 0x89, 0x3e, 0x9f, 0xb1, 0x7c, 0x3f, 0x8b, 0xa8, 0x74, 0x0d, 0x63, 0x8e,
0x76, 0x8d, 0xbf, 0x12, 0xa6, 0xb4, 0x87, 0xa4, 0x1c, 0xbf, 0x0d, 0x8b, 0x8a, 0xa0, 0x32, 0xe5,
0x7b, 0x86, 0x29, 0x9b, 0xe6, 0xec, 0x3e, 0x16, 0x1c, 0xa5, 0x25, 0x17, 0xa4, 0x00, 0x65, 0xff,
0x63, 0x58, 0xb2, 0x86, 0x2e, 0xf3, 0xec, 0x45, 0xd3, 0x64, 0x0f, 0x60, 0xf3, 0xd3, 0xb8, 0x34,
0x4f, 0xdc, 0x69, 0xcc, 0xf5, 0xcd, 0x8c, 0xb5, 0x34, 0xeb, 0xe0, 0x27, 0x30, 0x9b, 0x06, 0xfa,
0xd8, 0xc7, 0xdf, 0xa6, 0xa1, 0x5a, 0x76, 0xb8, 0xee, 0xc1, 0xfc, 0x19, 0x2d, 0x8e, 0xb2, 0x92,
0xe2, 0x99, 0xbe, 0xe0, 0xa9, 0x4f, 0xf2, 0x06, 0x2c, 0x0d, 0xcb, 0x38, 0x3d, 0xf1, 0xcb, 0x20,
0x8d, 0x8e, 0xb2, 0x97, 0x78, 0x82, 0x2f, 0x78, 0x1d, 0x04, 0x3e, 0x11, 0x30, 0x72, 0x0b, 0x3a,
0xa7, 0x8c, 0xe5, 0x3e, 0x4f, 0x2d, 0xb2, 0x21, 0x93, 0x07, 0x76, 0x9b, 0xc3, 0x9e, 0x0a, 0x10,
0xdf, 0x78, 0x88, 0x32, 0x2c, 0x69, 0x11, 0x9c, 0xd0, 0x94, 0xf5, 0xe6, 0xc4, 0xc6, 0xe3, 0xd0,
0x9f, 0x28, 0x20, 0xd9, 0x01, 0x40, 0xb4, 0xbc, 0xc8, 0x5e, 0x5e, 0xf4, 0xe6, 0x85, 0x6b, 0x70,
0xc8, 0x21, 0x07, 0x90, 0xb7, 0xa0, 0x7b, 0x14, 0x94, 0x54, 0xa5, 0x06, 0x31, 0x2d, 0x7b, 0x0b,
0x88, 0xb3, 0xcc, 0xc1, 0xfb, 0x1a, 0x4a, 0xee, 0xf2, 0xbc, 0x20, 0xcf, 0x33, 0xbe, 0xe9, 0xfd,
0xa0, 0x2c, 0x29, 0x2b, 0x7b, 0x8b, 0x88, 0xd9, 0xd5, 0xf0, 0x3d, 0x04, 0xf3, 0x15, 0xaa, 0xcc,
0x26, 0x0f, 0xe2, 0xa2, 0xec, 0x01, 0xe2, 0x75, 0x24, 0xf0, 0x90, 0xc3, 0x38, 0xe3, 0x2a, 0x5f,
0x12, 0x68, 0x6d, 0xc1, 0x58, 0x83, 0x05, 0xe2, 0x3b, 0xb0, 0x1a, 0x0c, 0xd9, 0x29, 0x4d, 0x19,
0x8f, 0xfa, 0x9c, 0x79, 0x1e, 0xf7, 0x3a, 0xa8, 0xb3, 0x15, 0x6b, 0x60, 0x2f, 0x8f, 0xdd, 0x73,
0x58, 0x39, 0xa0, 0xec, 0x69, 0x1c, 0xbe, 0xa0, 0xc5, 0x14, 0x06, 0x27, 0x77, 0x60, 0x96, 0xf3,
0x96, 0x71, 0x60, 0x5d, 0x9f, 0x32, 0x32, 0x1b, 0xe2, 0x12, 0x78, 0x88, 0xc1, 0xf5, 0x88, 0xab,
0xf6, 0xd9, 0x45, 0x2e, 0x6c, 0xba, 0xe8, 0x2d, 0x22, 0xe4, 0xe9, 0x45, 0x4e, 0xdd, 0x67, 0xd0,
0x31, 0x27, 0xf1, 0x0d, 0x19, 0xd1, 0x24, 0x1e, 0xc4, 0x8c, 0x16, 0x6a, 0x43, 0x6a, 0x00, 0xf7,
0x25, 0xae, 0x5e, 0xe9, 0xb6, 0xf8, 0x9b, 0xfb, 0xf2, 0x57, 0xc3, 0x8c, 0x29, 0xda, 0xe2, 0xc3,
0xfd, 0xf3, 0x16, 0x2c, 0xab, 0xe5, 0x48, 0x47, 0x54, 0x32, 0x3b, 0x97, 0xca, 0x7c, 0x0b, 0x3a,
0x49, 0x50, 0x32, 0x7f, 0x98, 0x47, 0x81, 0x4a, 0x1b, 0x66, 0xbc, 0x36, 0x87, 0xfd, 0x44, 0x80,
0xb8, 0xad, 0x54, 0x56, 0x88, 0x56, 0x90, 0xdc, 0x3b, 0xa1, 0xb9, 0x18, 0x02, 0xb3, 0x7c, 0x0e,
0x7a, 0xaa, 0xe3, 0xe1, 0x6f, 0x0e, 0x3b, 0x8d, 0x4f, 0x4e, 0xd1, 0x33, 0x1d, 0x0f, 0x7f, 0xf3,
0x0d, 0x9a, 0x64, 0xe7, 0xe8, 0x87, 0x8e, 0xc7, 0x7f, 0x72, 0xc8, 0x51, 0x1c, 0xa1, 0xdb, 0x39,
0x1e, 0xff, 0xc9, 0x21, 0x41, 0xf9, 0x02, 0x9d, 0xcc, 0xf1, 0xf8, 0x4f, 0x9e, 0x51, 0x9f, 0x65,
0xc9, 0x70, 0x40, 0xd1, 0x9f, 0x1c, 0x4f, 0x7e, 0x91, 0x6b, 0xb0, 0x98, 0x17, 0x71, 0x48, 0xfd,
0x80, 0x9d, 0xa2, 0x0b, 0x39, 0xde, 0x02, 0x02, 0xf6, 0xd8, 0xa9, 0xbb, 0x06, 0xab, 0xda, 0xd0,
0x3a, 0x32, 0x3d, 0x87, 0x79, 0x09, 0x99, 0x68, 0xf4, 0xf7, 0x61, 0x9e, 0x09, 0xb4, 0x5e, 0x0b,
0x43, 0xd4, 0xa6, 0xd2, 0xa1, 0xad, 0x69, 0x4f, 0xa1, 0xb9, 0xbf, 0x09, 0xc4, 0xe4, 0x26, 0x0d,
0x71, 0xb7, 0xa2, 0x23, 0x42, 0x5d, 0xd7, 0xa6, 0x53, 0x56, 0x04, 0xbe, 0xc6, 0x40, 0xff, 0xb8,
0x88, 0x78, 0x10, 0xc8, 0x5e, 0x7c, 0xab, 0xae, 0xf9, 0x63, 0x58, 0xd2, 0x8c, 0x1f, 0x31, 0x3a,
0xe0, 0x0a, 0x0f, 0x06, 0xd9, 0x30, 0x65, 0xc8, 0xd3, 0xf1, 0xe4, 0x17, 0xf7, 0x40, 0xd4, 0x2f,
0xb2, 0x74, 0x3c, 0xf1, 0x41, 0x96, 0xa1, 0x15, 0x47, 0xf2, 0x62, 0xd2, 0x8a, 0x23, 0xf7, 0x7f,
0x1d, 0x58, 0x35, 0x16, 0xf2, 0xca, 0x4e, 0x59, 0xf3, 0xb8, 0x56, 0x83, 0xc7, 0xdd, 0x85, 0xd9,
0xa3, 0x38, 0xe2, 0xf7, 0x21, 0xae, 0xd7, 0x0d, 0x45, 0xce, 0x5a, 0x87, 0x87, 0x28, 0x1c, 0x35,
0x28, 0x5f, 0x94, 0xbd, 0xd9, 0x89, 0xa8, 0x1c, 0xa5, 0xb6, 0x1f, 0xae, 0xd4, 0xf7, 0x83, 0xad,
0xcb, 0xb9, 0x51, 0x5d, 0x8a, 0x4c, 0x50, 0xd3, 0xd6, 0x9e, 0x17, 0x02, 0x54, 0xc0, 0x89, 0x66,
0xfd, 0x75, 0x80, 0x4c, 0x63, 0x4a, 0xff, 0xbb, 0x5a, 0x13, 0x5a, 0xbb, 0xa0, 0x81, 0xec, 0xfe,
0x08, 0x8f, 0x71, 0x93, 0xb9, 0x54, 0xfe, 0x7d, 0x8b, 0xa6, 0xf0, 0x45, 0x52, 0xa3, 0x59, 0x5a,
0xc4, 0x3e, 0x44, 0x62, 0x7b, 0x61, 0xc8, 0x4d, 0x6f, 0x5c, 0x7a, 0x27, 0x9e, 0x8f, 0xcf, 0x60,
0x5e, 0xce, 0x90, 0x6e, 0x21, 0x10, 0x5a, 0x71, 0x44, 0x3e, 0x06, 0x30, 0xce, 0x10, 0xb1, 0xae,
0x6b, 0x4a, 0x06, 0x39, 0x49, 0x79, 0x03, 0xb2, 0x33, 0xd0, 0xdd, 0x63, 0x58, 0x6b, 0x40, 0xe1,
0xa2, 0xe8, 0x2b, 0xab, 0x14, 0x45, 0x7d, 0x93, 0x1b, 0xd0, 0x66, 0x19, 0x0b, 0x12, 0xbf, 0x4a,
0x00, 0x1c, 0x0f, 0x10, 0xf4, 0x8c, 0x43, 0x30, 0x40, 0x65, 0x89, 0xf0, 0x5c, 0x1e, 0xa0, 0xb2,
0x24, 0x72, 0x03, 0x4c, 0x6a, 0xac, 0x45, 0x4b, 0x15, 0x4e, 0x32, 0xd9, 0x3b, 0xb0, 0x10, 0x88,
0x29, 0x6a, 0x61, 0xdd, 0x91, 0x85, 0x79, 0x1a, 0xc1, 0x25, 0x78, 0x02, 0xed, 0x67, 0xe9, 0x71,
0x7c, 0xa2, 0xbc, 0xe3, 0x2d, 0x0c, 0x56, 0x0a, 0x56, 0xe5, 0x13, 0x51, 0xc0, 0x02, 0xe4, 0xd6,
0xf1, 0xf0, 0xb7, 0xfb, 0x47, 0x0e, 0xac, 0x1c, 0x66, 0x05, 0x3b, 0xce, 0x92, 0x38, 0x93, 0xa9,
0x33, 0x4f, 0x25, 0x54, 0x6a, 0x2d, 0x73, 0x34, 0xf9, 0xc9, 0x23, 0x64, 0x98, 0xc5, 0xa9, 0xf0,
0xd5, 0x96, 0x54, 0x50, 0x16, 0xa7, 0xdc, 0x55, 0xc9, 0x4d, 0x68, 0x47, 0xb4, 0x0c, 0x8b, 0x38,
0xe7, 0x57, 0x25, 0x19, 0x16, 0x4c, 0x10, 0x27, 0x7c, 0x14, 0x24, 0x41, 0x1a, 0x52, 0x19, 0xd9,
0xd5, 0xa7, 0xbb, 0x81, 0xe1, 0x4a, 0x4b, 0x62, 0xdc, 0x5a, 0x6d, 0xb0, 0x5c, 0xca, 0xaf, 0xc1,
0x62, 0xae, 0x80, 0xd2, 0xfd, 0x7a, 0x4a, 0x43, 0xa3, 0xcb, 0xf1, 0x2a, 0x54, 0x77, 0x9b, 0xe7,
0xd5, 0x15, 0xbd, 0x27, 0xc3, 0xc1, 0x20, 0x28, 0x2e, 0x14, 0xb7, 0x14, 0x66, 0xf7, 0xb3, 0x38,
0xe5, 0x8a, 0xe2, 0x8b, 0x52, 0x89, 0x17, 0xff, 0x6d, 0x8a, 0xde, 0xb2, 0x44, 0x37, 0xb5, 0x35,
0x63, 0x6b, 0xeb, 0x3a, 0x40, 0x4e, 0x8b, 0x90, 0xa6, 0x2c, 0x38, 0x51, 0x2b, 0x36, 0x20, 0xee,
0x29, 0x90, 0xc7, 0xc7, 0xc7, 0x49, 0x9c, 0x52, 0xce, 0x56, 0x0a, 0x33, 0x41, 0xfb, 0xe3, 0x65,
0xb0, 0x39, 0xcd, 0xd4, 0x38, 0xfd, 0x18, 0x56, 0x1f, 0xa7, 0x0d, 0x8c, 0x14, 0x39, 0x67, 0x12,
0xb9, 0x56, 0x8d, 0xdc, 0x0f, 0xa1, 0x63, 0x08, 0x5e, 0x92, 0x8f, 0x60, 0x51, 0xca, 0xa8, 0x93,
0xf0, 0xbe, 0x8e, 0x06, 0xb5, 0x15, 0x7a, 0x15, 0xb2, 0xfb, 0x17, 0x0e, 0xb4, 0x2b, 0xc9, 0x4a,
0xf2, 0x00, 0xae, 0x70, 0x75, 0x2b, 0x2a, 0xd7, 0x35, 0x95, 0x0a, 0x67, 0x17, 0xff, 0x15, 0xb9,
0xbb, 0x40, 0xee, 0x3f, 0x01, 0xa8, 0x80, 0x0d, 0x59, 0xfb, 0x3d, 0xfb, 0xf6, 0x75, 0xb5, 0x4e,
0x55, 0x89, 0x66, 0x24, 0xf4, 0xff, 0x3c, 0xcb, 0xaf, 0x52, 0x0d, 0xce, 0x22, 0x7d, 0xf0, 0x3d,
0x68, 0x8b, 0xbd, 0xc0, 0x23, 0x80, 0x12, 0xb8, 0x53, 0x95, 0x0d, 0xe2, 0xd4, 0x03, 0xdc, 0x1b,
0x38, 0x4e, 0x3e, 0x80, 0x25, 0x14, 0xd6, 0xcf, 0x84, 0x42, 0xe4, 0xc6, 0xb6, 0x27, 0x74, 0x10,
0x45, 0xaa, 0x8c, 0xe4, 0xb0, 0x61, 0x4d, 0xf1, 0x4b, 0x21, 0x82, 0x3c, 0xa4, 0xbe, 0x6f, 0xdc,
0x73, 0xc6, 0x49, 0x29, 0x94, 0x25, 0x09, 0xca, 0x31, 0xa1, 0xba, 0xb5, 0xb0, 0x3e, 0x42, 0xee,
0x41, 0x47, 0x72, 0x44, 0xcd, 0xc8, 0x23, 0xce, 0x96, 0xb1, 0x2d, 0x26, 0x22, 0x02, 0x19, 0xc0,
0xba, 0x39, 0x41, 0x4b, 0x78, 0x05, 0x27, 0x7e, 0x3c, 0xbd, 0x84, 0x69, 0x4d, 0x40, 0x12, 0xd6,
0x06, 0xfa, 0xbf, 0x0b, 0xbd, 0x71, 0x0b, 0x6a, 0x30, 0xfb, 0xdb, 0xb6, 0xd9, 0xd7, 0x1b, 0x5c,
0xb2, 0x34, 0x8b, 0x73, 0x5f, 0xc2, 0xd6, 0x18, 0x61, 0x5e, 0xe1, 0x46, 0x6f, 0x78, 0xaa, 0xe9,
0x4d, 0x7f, 0xe6, 0x40, 0x7f, 0x2f, 0x8a, 0x6a, 0xc1, 0xa9, 0xba, 0x80, 0x7f, 0xdb, 0x21, 0x77,
0x07, 0xae, 0x35, 0x0a, 0x24, 0x2b, 0x05, 0x2f, 0x61, 0xc7, 0xa3, 0x83, 0xec, 0x8c, 0x7e, 0xdb,
0x22, 0xbb, 0x37, 0xe1, 0xfa, 0x38, 0xce, 0x52, 0x36, 0x2c, 0x9d, 0xd9, 0xa5, 0x67, 0x9d, 0x18,
0xfd, 0x87, 0x03, 0x4b, 0x76, 0x51, 0xfa, 0x75, 0xdd, 0xa3, 0xdf, 0x05, 0x52, 0xd0, 0x92, 0xf9,
0x45, 0x96, 0x24, 0xfc, 0x3a, 0x1d, 0xd1, 0x24, 0xb8, 0x90, 0xe5, 0xf0, 0x15, 0x3e, 0xe2, 0x89,
0x81, 0x4f, 0x39, 0x9c, 0x6c, 0xc1, 0x7c, 0x90, 0xc7, 0x3e, 0xf7, 0x1a, 0x71, 0x97, 0x9e, 0x0b,
0xf2, 0xf8, 0x47, 0xf4, 0x82, 0xb8, 0xb0, 0x24, 0x07, 0xfc, 0x84, 0x9e, 0xd1, 0x04, 0x73, 0xbe,
0x19, 0xaf, 0x2d, 0x86, 0x3f, 0xe7, 0x20, 0x7e, 0xf7, 0xcd, 0x8b, 0x98, 0xbb, 0x5f, 0x55, 0x77,
0x9f, 0x47, 0x69, 0xba, 0x12, 0xae, 0x56, 0xe7, 0xfe, 0x14, 0xae, 0x36, 0xe8, 0x42, 0xc6, 0xa8,
0x1f, 0x40, 0xd7, 0xae, 0xde, 0xab, 0x38, 0xa5, 0xb3, 0x56, 0x6b, 0xa2, 0xb7, 0x7c, 0x6c, 0xd1,
0x91, 0xd9, 0x27, 0xe2, 0x78, 0x01, 0xd3, 0xf5, 0x22, 0xf7, 0x2b, 0x58, 0xaf, 0x80, 0xfb, 0x59,
0x7a, 0x46, 0x8b, 0x92, 0x7b, 0x1b, 0x81, 0xd9, 0xe3, 0x22, 0x53, 0xc5, 0x4e, 0xfc, 0xcd, 0xf3,
0x36, 0x96, 0x49, 0x37, 0x68, 0xb1, 0x8c, 0xe3, 0x14, 0x01, 0x53, 0xa7, 0x14, 0xfe, 0xe6, 0x79,
0x72, 0x8c, 0x44, 0xa8, 0x8f, 0x63, 0xc2, 0x55, 0xdb, 0x12, 0xc6, 0xb9, 0xb8, 0xcf, 0x30, 0x7d,
0x34, 0x45, 0x91, 0x6b, 0xfc, 0x0d, 0x68, 0x8b, 0x35, 0xf2, 0x99, 0x6a, 0x7d, 0xdb, 0xd6, 0xfa,
0x46, 0xc4, 0xf4, 0xe0, 0x58, 0x43, 0xdd, 0xff, 0x6a, 0x41, 0x07, 0x33, 0xd6, 0x4f, 0x29, 0x0b,
0xe2, 0x64, 0x72, 0x2e, 0x2d, 0x72, 0xd0, 0x96, 0xce, 0x41, 0xdf, 0x80, 0x25, 0xb3, 0x98, 0x71,
0xa1, 0x2e, 0xb3, 0x46, 0x29, 0xe3, 0x82, 0xbc, 0x09, 0xcb, 0x78, 0xb5, 0xae, 0xb0, 0x84, 0xcf,
0x2c, 0x21, 0x54, 0xa3, 0xd9, 0x17, 0x81, 0x2b, 0x23, 0x17, 0x01, 0x3e, 0x8c, 0xc9, 0xb4, 0x5f,
0xc6, 0x91, 0xbe, 0x27, 0x20, 0xe4, 0x49, 0x1c, 0x19, 0xc3, 0x38, 0x7b, 0xde, 0x18, 0xc6, 0xd9,
0xfc, 0x0e, 0x54, 0x50, 0x51, 0x84, 0xc7, 0xb7, 0xa4, 0x05, 0x74, 0xba, 0x8e, 0x02, 0x3e, 0x8d,
0x07, 0xf8, 0xd2, 0x24, 0x0b, 0xc7, 0xa2, 0xce, 0x22, 0xbf, 0xaa, 0x6b, 0x1a, 0x98, 0xd7, 0xb4,
0xea, 0x52, 0xd7, 0xb6, 0x2e, 0x75, 0x37, 0xa0, 0x9d, 0xe5, 0x34, 0xf5, 0xe5, 0x15, 0xbb, 0x23,
0xb2, 0x07, 0x0e, 0x7a, 0x86, 0x10, 0x59, 0x32, 0x41, 0x9d, 0x97, 0xd3, 0xdc, 0x4b, 0x6d, 0xc5,
0xb4, 0x46, 0x15, 0xa3, 0x2e, 0x82, 0x33, 0x97, 0x5d, 0x04, 0xdd, 0x3d, 0xcc, 0x8a, 0x15, 0x63,
0xe9, 0x3e, 0xef, 0xc2, 0x1c, 0xaa, 0x49, 0x79, 0xce, 0xba, 0x75, 0x8d, 0x91, 0x4e, 0xe1, 0x49,
0x1c, 0xf7, 0x87, 0xf8, 0x3e, 0x87, 0x43, 0xd3, 0x88, 0x7e, 0x15, 0x16, 0x84, 0x55, 0xb4, 0xd7,
0xcc, 0xe3, 0xf7, 0xa3, 0xc8, 0xfd, 0x57, 0x07, 0xc8, 0x93, 0xe1, 0xd1, 0x20, 0x9e, 0x9e, 0xda,
0xf4, 0x17, 0x74, 0x02, 0xb3, 0xe8, 0x26, 0xc2, 0x1d, 0xf1, 0xf7, 0x88, 0x87, 0xcc, 0x8e, 0x7a,
0x48, 0x65, 0xce, 0x2b, 0xcd, 0x77, 0xf4, 0x39, 0xd3, 0xf8, 0x3c, 0xc4, 0x27, 0x31, 0x4d, 0x99,
0x2f, 0x8b, 0x2d, 0x3c, 0xc4, 0x23, 0xe0, 0x51, 0xe4, 0x3e, 0x81, 0x35, 0x6b, 0x65, 0x52, 0xd3,
0xb7, 0xa0, 0x23, 0x04, 0xc8, 0x93, 0x20, 0xd4, 0x95, 0xe6, 0x36, 0xc2, 0x0e, 0x11, 0x34, 0x49,
0x5f, 0x7f, 0xe2, 0xc0, 0xfa, 0x93, 0x78, 0x30, 0x4c, 0x02, 0x46, 0x7f, 0x05, 0x1a, 0xab, 0x96,
0x3f, 0x63, 0x2d, 0x5f, 0x69, 0x72, 0xb6, 0xd2, 0xa4, 0xfb, 0xdf, 0x0e, 0x6c, 0x8c, 0x88, 0xa2,
0x73, 0x42, 0xdb, 0x99, 0xc6, 0x14, 0x07, 0x24, 0x92, 0xc1, 0xb4, 0x65, 0x31, 0x7d, 0x03, 0x96,
0x06, 0x71, 0x1a, 0x0f, 0x86, 0x03, 0x5f, 0xe8, 0x5e, 0xc8, 0xd4, 0x91, 0xc0, 0x43, 0x34, 0x01,
0x47, 0x0a, 0x5e, 0x1a, 0x48, 0xb3, 0x12, 0x49, 0x00, 0x05, 0xd2, 0xfb, 0xb0, 0x5e, 0xe5, 0xed,
0xfe, 0x49, 0x10, 0xa7, 0x7e, 0x92, 0x95, 0xa5, 0xb4, 0x31, 0xa9, 0xc6, 0x0e, 0x82, 0x38, 0xfd,
0x3c, 0x2b, 0x4b, 0x23, 0x08, 0xcc, 0x99, 0x41, 0x80, 0x27, 0x30, 0x2b, 0xcf, 0x4f, 0x83, 0x84,
0x7e, 0x92, 0x0d, 0x8e, 0x5e, 0xaf, 0xee, 0x6f, 0x41, 0x47, 0xd4, 0xdd, 0x58, 0x50, 0x9c, 0x50,
0x65, 0x81, 0x36, 0xc2, 0x9e, 0x22, 0xa8, 0xd1, 0x0c, 0xff, 0xe9, 0x00, 0xd9, 0xe7, 0xa9, 0x4c,
0x32, 0xb5, 0x3f, 0xf0, 0x50, 0x22, 0xee, 0xcd, 0x95, 0x87, 0x2d, 0x4a, 0xc8, 0x23, 0xdb, 0xfd,
0x66, 0x2c, 0xf7, 0xd3, 0xab, 0x99, 0x7d, 0xc5, 0xe2, 0x58, 0x2d, 0x8e, 0xbf, 0x09, 0xcb, 0xe7,
0x41, 0x92, 0x50, 0xa6, 0x9f, 0xaf, 0x64, 0x15, 0x5d, 0x40, 0xd5, 0x1d, 0x5c, 0x2d, 0x78, 0xde,
0x58, 0xf0, 0x06, 0xac, 0x59, 0xeb, 0x95, 0xd9, 0xd0, 0x03, 0xd8, 0x14, 0xe0, 0xbd, 0x24, 0x99,
0x3a, 0xaa, 0xba, 0x7f, 0xd9, 0x82, 0xad, 0xda, 0x34, 0x9d, 0x36, 0xd8, 0x6e, 0x7c, 0x5b, 0x2f,
0xb7, 0x79, 0xc2, 0xae, 0xfc, 0x94, 0xb3, 0xfa, 0xff, 0xe8, 0xc0, 0x9c, 0x00, 0x4d, 0xb4, 0xc6,
0x97, 0x2a, 0x20, 0x48, 0x87, 0x13, 0x37, 0xa2, 0xef, 0x4e, 0xc7, 0x4c, 0xfc, 0x67, 0x3e, 0x59,
0x8a, 0x48, 0x22, 0x5f, 0x2b, 0x7f, 0x00, 0x2b, 0xa3, 0x08, 0xaf, 0xf4, 0x9c, 0x23, 0xaa, 0x2a,
0x0f, 0xcf, 0xa8, 0xf1, 0x44, 0xf9, 0x8d, 0x03, 0xdd, 0xfd, 0x2c, 0x8d, 0x62, 0x7e, 0x62, 0x1e,
0x06, 0x45, 0x30, 0x28, 0xe5, 0x2b, 0xb9, 0x00, 0xa9, 0xb2, 0xbb, 0x06, 0x8c, 0x29, 0x70, 0xee,
0x00, 0x84, 0xa7, 0x34, 0x7c, 0xe1, 0xcb, 0x8a, 0xa3, 0x78, 0x5a, 0xe7, 0x90, 0x4f, 0xe2, 0xa8,
0x24, 0xef, 0xc1, 0x5a, 0x35, 0xec, 0x07, 0x69, 0xe4, 0xcb, 0x72, 0x23, 0xbe, 0x40, 0x68, 0xbc,
0xbd, 0x34, 0xda, 0x2b, 0x5f, 0xe0, 0x3b, 0x89, 0xae, 0xb2, 0xf9, 0x56, 0x08, 0xef, 0x6a, 0xf8,
0x1e, 0x82, 0xdd, 0xff, 0x71, 0xf0, 0x04, 0x54, 0xab, 0x92, 0xd6, 0xae, 0x0a, 0x6b, 0x58, 0x6f,
0xb5, 0x4c, 0xd6, 0x1a, 0x31, 0x19, 0x81, 0xd9, 0x98, 0xd1, 0x81, 0x3a, 0x58, 0xf8, 0x6f, 0xf2,
0x09, 0xac, 0xe8, 0x15, 0xfb, 0x39, 0xaa, 0x45, 0x6e, 0x93, 0xad, 0xea, 0xe2, 0x68, 0x69, 0xcd,
0xeb, 0x86, 0x23, 0x6a, 0x54, 0xdb, 0xeb, 0xca, 0x54, 0x81, 0x3a, 0x44, 0x6d, 0xcb, 0xf8, 0x24,
0xbe, 0x84, 0xd4, 0x34, 0x1c, 0x32, 0x1a, 0xc9, 0x54, 0x59, 0x7f, 0xbb, 0xff, 0xee, 0x40, 0x77,
0x2f, 0x8a, 0x70, 0xdd, 0xd3, 0x84, 0x09, 0xb5, 0xca, 0xd6, 0x25, 0xab, 0x9c, 0xf9, 0x7f, 0xae,
0xf2, 0x97, 0x0e, 0x22, 0x63, 0x94, 0xe0, 0xba, 0xb0, 0x52, 0xad, 0xb3, 0xd9, 0xbc, 0xee, 0x77,
0x80, 0x88, 0xeb, 0x95, 0xa5, 0x8e, 0x51, 0xac, 0x0d, 0x58, 0xb3, 0xb0, 0x64, 0xac, 0xf9, 0x0c,
0xee, 0x1c, 0x50, 0xb6, 0x5f, 0x5c, 0xe4, 0x2c, 0x53, 0xe9, 0xec, 0xa7, 0x34, 0xcf, 0xca, 0x58,
0x45, 0x2e, 0x3a, 0x55, 0xf4, 0xf9, 0x27, 0x07, 0xee, 0x4e, 0x41, 0x48, 0x2e, 0xe1, 0x67, 0xf5,
0xfa, 0xd2, 0x6f, 0x99, 0xad, 0x23, 0x53, 0x51, 0xd9, 0xd5, 0x10, 0xf9, 0x82, 0xaf, 0x49, 0xf6,
0xbf, 0x0f, 0xcb, 0xf6, 0xe0, 0x2b, 0x85, 0x8a, 0x04, 0x6e, 0x5f, 0x22, 0xc4, 0x34, 0x3e, 0x77,
0x1b, 0x96, 0x43, 0x8b, 0x84, 0x64, 0x34, 0x02, 0x75, 0xf7, 0xe1, 0xad, 0x4b, 0xb9, 0x49, 0xb5,
0x8d, 0xbd, 0xa1, 0xbb, 0x7f, 0x33, 0x0b, 0x5b, 0xcf, 0x63, 0x76, 0x1a, 0x15, 0xc1, 0xb9, 0xf2,
0xbe, 0x69, 0x84, 0x1c, 0xb9, 0xbc, 0xb7, 0xea, 0xf5, 0x86, 0xb7, 0x61, 0x35, 0x4b, 0x29, 0xde,
0x31, 0xfc, 0x3c, 0x28, 0xcb, 0xf3, 0xac, 0x50, 0x67, 0x69, 0x37, 0x4b, 0x29, 0xbf, 0x67, 0x1c,
0x4a, 0xf0, 0xc8, 0x69, 0x3c, 0x3b, 0x7a, 0x1a, 0xaf, 0xc0, 0x4c, 0x1e, 0xa7, 0xf2, 0xcd, 0x84,
0xff, 0xe4, 0x67, 0x27, 0x2b, 0x82, 0xc8, 0xa0, 0x2c, 0xcf, 0x4e, 0x84, 0x6a, 0xba, 0x66, 0x15,
0x7f, 0x7e, 0xa4, 0x8a, 0x6f, 0xe8, 0x64, 0xc1, 0xae, 0x5a, 0xdc, 0x80, 0xb6, 0xfc, 0xe9, 0xb3,
0xe0, 0x44, 0x5e, 0x81, 0x40, 0x82, 0x9e, 0x06, 0x27, 0x46, 0xb6, 0x06, 0x56, 0xb6, 0xb6, 0x03,
0x70, 0x4c, 0xa9, 0x6f, 0x5d, 0x86, 0x16, 0x8f, 0x29, 0x15, 0x41, 0x97, 0xa7, 0xca, 0x47, 0x41,
0xfa, 0xc2, 0xc7, 0x1a, 0x44, 0x47, 0x88, 0xc3, 0x01, 0x5f, 0x04, 0x03, 0xcc, 0x89, 0x71, 0x50,
0xc9, 0xb4, 0x24, 0x34, 0xca, 0x61, 0x7b, 0x55, 0x35, 0x05, 0x51, 0xc2, 0x98, 0x5d, 0xf4, 0x96,
0xab, 0xf9, 0xfb, 0x31, 0xbb, 0xd0, 0xf3, 0x51, 0x67, 0xc5, 0x45, 0xaf, 0x5b, 0xcd, 0xdf, 0x17,
0x20, 0x2e, 0x5e, 0x79, 0x1e, 0x1f, 0x53, 0xd1, 0x74, 0xb1, 0x22, 0xdb, 0x90, 0x38, 0x64, 0x3f,
0x8b, 0x30, 0x8d, 0x3c, 0x8f, 0x0b, 0xe3, 0x72, 0xba, 0x2a, 0xae, 0xb0, 0x1c, 0xa8, 0x5c, 0xc3,
0x7d, 0x1b, 0x56, 0x94, 0xbb, 0x98, 0x7d, 0x89, 0x05, 0x2d, 0x87, 0x09, 0x53, 0x7d, 0x89, 0xe2,
0xeb, 0xfe, 0x3f, 0xdc, 0x82, 0xe5, 0x83, 0x4c, 0x38, 0xe8, 0x53, 0x6e, 0x97, 0x82, 0x3c, 0x86,
0x79, 0xd9, 0x6c, 0x47, 0x36, 0x6b, 0xdd, 0x77, 0xe8, 0x75, 0xfd, 0xad, 0x31, 0x5d, 0x79, 0xee,
0xda, 0xcf, 0xff, 0xe5, 0xdf, 0x7e, 0xd1, 0x5a, 0x22, 0xed, 0x7b, 0x67, 0x1f, 0xdc, 0x3b, 0xa1,
0x2c, 0xe6, 0x54, 0x4e, 0x61, 0xc9, 0xea, 0x8f, 0x22, 0xdb, 0x56, 0x8f, 0xd3, 0x48, 0xdb, 0x54,
0x7f, 0x67, 0x62, 0x07, 0x94, 0xdb, 0x47, 0x16, 0xeb, 0x84, 0x48, 0x16, 0x25, 0xa2, 0x08, 0xc2,
0x5f, 0x41, 0xf7, 0x21, 0x56, 0x86, 0x34, 0x55, 0x72, 0xa3, 0xa2, 0xd6, 0xd8, 0xf7, 0xd5, 0xbf,
0x39, 0x1e, 0x41, 0x72, 0xbc, 0x86, 0x1c, 0x37, 0xc8, 0x1a, 0xe7, 0x28, 0x2a, 0x4f, 0xba, 0xdf,
0x8a, 0x94, 0xb0, 0x22, 0x3b, 0x49, 0x5e, 0x2b, 0xcf, 0x6d, 0xe4, 0xb9, 0x49, 0xd6, 0x39, 0xcf,
0x48, 0x30, 0xa8, 0x98, 0x66, 0x78, 0xb1, 0x35, 0x3b, 0x9f, 0xc8, 0xf5, 0xb1, 0x2d, 0x51, 0x82,
0xe5, 0x8d, 0x4b, 0x5a, 0xa6, 0xec, 0x55, 0x9e, 0x50, 0x8e, 0xab, 0xbb, 0xa6, 0xc8, 0x2f, 0x1c,
0x2c, 0xe2, 0x35, 0xf6, 0xe8, 0x91, 0xb7, 0x2e, 0x6f, 0x0c, 0x14, 0x32, 0xdc, 0x99, 0xb6, 0x83,
0xd0, 0xfd, 0x0e, 0x0a, 0x73, 0x9d, 0x6c, 0x4b, 0x61, 0xac, 0xae, 0x41, 0xd5, 0x97, 0x48, 0x42,
0xe8, 0x98, 0xed, 0x4e, 0xe4, 0x5a, 0x43, 0x2f, 0x91, 0x66, 0xbe, 0xdd, 0x3c, 0x28, 0x19, 0xf6,
0x90, 0x21, 0x21, 0x2b, 0x92, 0xa1, 0xee, 0x8e, 0x22, 0x5f, 0x43, 0x77, 0xa4, 0x55, 0x88, 0xb8,
0x23, 0xe6, 0x6b, 0x68, 0xfb, 0xea, 0xbf, 0x31, 0x11, 0x47, 0x72, 0xbd, 0x8e, 0x5c, 0x7b, 0xee,
0x9a, 0x61, 0x65, 0xc5, 0xf9, 0x7b, 0xce, 0xdb, 0xa4, 0x44, 0x3b, 0x9b, 0xfd, 0x46, 0x53, 0xf1,
0xbe, 0xd1, 0xb0, 0x54, 0x6b, 0x9b, 0x8e, 0xda, 0x5a, 0xf1, 0xc4, 0xed, 0x5a, 0x62, 0x37, 0x83,
0xd1, 0x8b, 0x85, 0x91, 0x67, 0x1a, 0xbe, 0x3b, 0xcd, 0xbd, 0x5c, 0xb2, 0x9d, 0xac, 0xb6, 0x73,
0x15, 0xd7, 0x8c, 0xe5, 0xa4, 0xb4, 0x5a, 0xdd, 0x24, 0x53, 0xdb, 0xab, 0x1b, 0x9a, 0xcd, 0x1a,
0x57, 0x6a, 0x76, 0x8f, 0x8d, 0x5d, 0x69, 0xc6, 0xf2, 0x92, 0xbc, 0x84, 0x65, 0x11, 0x2e, 0x5e,
0xbf, 0x65, 0x77, 0x90, 0xef, 0x96, 0x4b, 0xaa, 0x98, 0x61, 0x1a, 0xf6, 0x39, 0x2c, 0xea, 0x8e,
0x11, 0xd2, 0x33, 0x16, 0x61, 0xf5, 0x26, 0xf5, 0xc7, 0x74, 0x9e, 0x28, 0x6f, 0x75, 0x97, 0xe4,
0xaa, 0x44, 0x1f, 0x09, 0x27, 0xfc, 0x53, 0x80, 0xaa, 0x15, 0x85, 0x5c, 0xad, 0x51, 0xd6, 0x9a,
0xeb, 0x37, 0x0d, 0xa9, 0x86, 0x56, 0x24, 0xbf, 0x42, 0x96, 0x2d, 0xf2, 0x6a, 0xbf, 0xe9, 0xea,
0x88, 0xb5, 0xdf, 0x46, 0x9b, 0x57, 0xfa, 0xe3, 0xbb, 0x16, 0x94, 0x51, 0x5c, 0xb5, 0xd9, 0xf4,
0xcd, 0x87, 0xaf, 0xe0, 0x04, 0x4f, 0x0b, 0xa3, 0x5d, 0x62, 0xbb, 0x89, 0x4b, 0xe3, 0x69, 0x51,
0xef, 0x7d, 0x70, 0xaf, 0x22, 0xab, 0x35, 0xb2, 0x3a, 0xca, 0xaa, 0x24, 0x2f, 0xb0, 0xa1, 0xdf,
0x78, 0xed, 0x27, 0x26, 0xad, 0x7a, 0xeb, 0x43, 0xff, 0xfa, 0xb8, 0xe1, 0x31, 0x27, 0x93, 0x4c,
0x8e, 0x70, 0x53, 0x09, 0x83, 0x8b, 0x37, 0x7e, 0xcb, 0xe0, 0x56, 0x2b, 0x40, 0xff, 0x6a, 0xc3,
0x88, 0xa4, 0xbe, 0x81, 0xd4, 0xbb, 0x64, 0x49, 0x87, 0x44, 0xa4, 0x25, 0x6c, 0xa2, 0x1f, 0x5f,
0x2c, 0x9b, 0x8c, 0xbe, 0xd0, 0x5b, 0x31, 0xb0, 0xf6, 0x4e, 0x5f, 0x8b, 0x81, 0xfa, 0x25, 0x9e,
0xfc, 0xa1, 0xfd, 0xe0, 0xaf, 0x1e, 0x20, 0xdd, 0x89, 0x2f, 0x86, 0xb5, 0xdd, 0x32, 0xf6, 0x55,
0xd1, 0xbd, 0x81, 0x9c, 0xaf, 0x92, 0xad, 0x51, 0xce, 0xf2, 0x85, 0x92, 0xfc, 0xdc, 0x81, 0xb5,
0x86, 0xf7, 0xaf, 0x4a, 0x82, 0xf1, 0xaf, 0x75, 0x95, 0x04, 0x93, 0x1e, 0xd0, 0x5c, 0x94, 0x60,
0xdb, 0x45, 0x09, 0x82, 0x28, 0xd2, 0x12, 0xc8, 0x5c, 0x8f, 0x7b, 0xe6, 0x9f, 0x3a, 0xb0, 0xd9,
0xfc, 0xd6, 0x45, 0xde, 0xd4, 0x2d, 0xc2, 0x93, 0x5e, 0xe1, 0xfa, 0xb7, 0x2f, 0x43, 0x93, 0xd2,
0xbc, 0x89, 0xd2, 0xdc, 0x70, 0xfb, 0x5c, 0x9a, 0x02, 0x71, 0x9b, 0x04, 0x3a, 0xc7, 0x02, 0x81,
0xfd, 0x9a, 0x44, 0x8c, 0xdc, 0xa2, 0xf9, 0xd1, 0xad, 0x7f, 0x6b, 0x02, 0x86, 0x1d, 0xbe, 0xc8,
0x86, 0x34, 0x08, 0x3e, 0xc1, 0xe8, 0x67, 0x29, 0xb9, 0x47, 0xab, 0xd7, 0x1a, 0x6b, 0x8f, 0xd6,
0x1e, 0xa0, 0xac, 0x3d, 0x5a, 0x7f, 0x13, 0xaa, 0xed, 0x51, 0x64, 0x86, 0xef, 0x43, 0xe4, 0x4b,
0xdc, 0x36, 0xb2, 0x3a, 0xd5, 0x1b, 0xdd, 0xea, 0x65, 0xd3, 0xb6, 0xb1, 0xeb, 0x4f, 0xb5, 0x50,
0x29, 0x8a, 0x5e, 0x5c, 0x7b, 0x1e, 0x2c, 0x28, 0x74, 0xb2, 0x35, 0x4a, 0x40, 0x51, 0x6e, 0x7c,
0x60, 0x70, 0xb7, 0x90, 0xe8, 0xaa, 0xdb, 0x31, 0x89, 0x72, 0x9a, 0x47, 0xd0, 0x36, 0x8a, 0xe9,
0x44, 0x07, 0xd9, 0xfa, 0xdb, 0x41, 0xff, 0x5a, 0xe3, 0x98, 0x1d, 0x4a, 0xdc, 0x2e, 0x67, 0x50,
0x22, 0x82, 0xe6, 0xf1, 0xfb, 0xb0, 0x64, 0xd5, 0xb3, 0x2b, 0xe5, 0x37, 0x55, 0xdc, 0x2b, 0xe5,
0x37, 0x16, 0xc1, 0x55, 0xa2, 0xe9, 0xa2, 0xf2, 0x4b, 0x89, 0xa2, 0x79, 0xfd, 0x0c, 0x16, 0x75,
0x19, 0xb9, 0xd2, 0xff, 0x68, 0x65, 0xf9, 0x32, 0x1e, 0x96, 0x0d, 0xce, 0xf9, 0xe4, 0xa3, 0x6c,
0x70, 0x24, 0xf5, 0x65, 0x14, 0x49, 0x2b, 0x7d, 0xd5, 0x2b, 0xc5, 0x95, 0xbe, 0x9a, 0xaa, 0xaa,
0x96, 0xbe, 0x42, 0x44, 0xd0, 0x6b, 0x28, 0xa0, 0x3b, 0x52, 0x9c, 0xac, 0xd2, 0x8a, 0xe6, 0x52,
0x6c, 0x95, 0x56, 0x8c, 0xa9, 0x6a, 0xda, 0x89, 0x9b, 0xe0, 0x17, 0x24, 0x49, 0xe5, 0x5b, 0x22,
0xdc, 0x8b, 0xd2, 0x9d, 0xe5, 0xb7, 0x56, 0x8d, 0xd2, 0xf2, 0x5b, 0xbb, 0xce, 0x57, 0x0b, 0xf7,
0x54, 0xd0, 0x7a, 0x06, 0x0b, 0xaa, 0x66, 0x54, 0x39, 0xed, 0x48, 0xb5, 0xac, 0xdf, 0xab, 0x0f,
0x48, 0xaa, 0x96, 0xe3, 0x06, 0x51, 0x84, 0x54, 0xa5, 0x21, 0x8c, 0x0a, 0x52, 0x65, 0x88, 0x7a,
0xf1, 0xa9, 0x32, 0x44, 0x53, 0xc9, 0xc9, 0x32, 0x84, 0x88, 0x5c, 0x9a, 0xc7, 0xdf, 0x3a, 0x70,
0xeb, 0xd2, 0x02, 0x10, 0x79, 0xff, 0x15, 0x6a, 0x45, 0x42, 0xa0, 0x0f, 0x5e, 0xb9, 0xba, 0xe4,
0xde, 0x41, 0x31, 0x5d, 0x77, 0x47, 0x1d, 0xa6, 0x38, 0x2d, 0x12, 0xe8, 0xba, 0xd4, 0xc4, 0x85,
0xfe, 0x6b, 0x47, 0xfc, 0xb9, 0xd6, 0x04, 0xba, 0x64, 0x77, 0x4a, 0x01, 0x94, 0xc0, 0xf7, 0xa6,
0xc6, 0x97, 0xe2, 0xde, 0x46, 0x71, 0x6f, 0xba, 0xd7, 0x26, 0x88, 0xcb, 0x85, 0xfd, 0x03, 0xb8,
0xa6, 0x0b, 0x45, 0x16, 0xdd, 0xcf, 0x86, 0x69, 0x54, 0x56, 0xf7, 0xd2, 0x31, 0xd5, 0xa4, 0xca,
0x71, 0x46, 0xeb, 0x07, 0xf6, 0xf9, 0x78, 0x2e, 0x47, 0x85, 0x18, 0xc7, 0x9c, 0x36, 0xe7, 0x9e,
0xc3, 0xaa, 0x9a, 0xf7, 0x59, 0x1c, 0xb0, 0x5f, 0x9a, 0xe7, 0x4d, 0xe4, 0xd9, 0x77, 0x37, 0x4c,
0x9e, 0xc7, 0x71, 0xc0, 0x14, 0xc7, 0xa3, 0x39, 0xfc, 0xd3, 0xcc, 0x0f, 0xff, 0x2f, 0x00, 0x00,
0xff, 0xff, 0x26, 0x18, 0xb3, 0x56, 0xcd, 0x39, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -4584,6 +4804,8 @@ type GoCryptoTraderClient interface {
GetOrders(ctx context.Context, in *GetOrdersRequest, opts ...grpc.CallOption) (*GetOrdersResponse, error)
GetOrder(ctx context.Context, in *GetOrderRequest, opts ...grpc.CallOption) (*OrderDetails, error)
SubmitOrder(ctx context.Context, in *SubmitOrderRequest, opts ...grpc.CallOption) (*SubmitOrderResponse, error)
SimulateOrder(ctx context.Context, in *SimulateOrderRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error)
WhaleBomb(ctx context.Context, in *WhaleBombRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error)
CancelOrder(ctx context.Context, in *CancelOrderRequest, opts ...grpc.CallOption) (*CancelOrderResponse, error)
CancelAllOrders(ctx context.Context, in *CancelAllOrdersRequest, opts ...grpc.CallOption) (*CancelAllOrdersResponse, error)
GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (*GetEventsResponse, error)
@@ -4846,6 +5068,24 @@ func (c *goCryptoTraderClient) SubmitOrder(ctx context.Context, in *SubmitOrderR
return out, nil
}
func (c *goCryptoTraderClient) SimulateOrder(ctx context.Context, in *SimulateOrderRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error) {
out := new(SimulateOrderResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/SimulateOrder", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WhaleBomb(ctx context.Context, in *WhaleBombRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error) {
out := new(SimulateOrderResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WhaleBomb", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) CancelOrder(ctx context.Context, in *CancelOrderRequest, opts ...grpc.CallOption) (*CancelOrderResponse, error) {
out := new(CancelOrderResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/CancelOrder", in, out, opts...)
@@ -4956,6 +5196,8 @@ type GoCryptoTraderServer interface {
GetOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error)
GetOrder(context.Context, *GetOrderRequest) (*OrderDetails, error)
SubmitOrder(context.Context, *SubmitOrderRequest) (*SubmitOrderResponse, error)
SimulateOrder(context.Context, *SimulateOrderRequest) (*SimulateOrderResponse, error)
WhaleBomb(context.Context, *WhaleBombRequest) (*SimulateOrderResponse, error)
CancelOrder(context.Context, *CancelOrderRequest) (*CancelOrderResponse, error)
CancelAllOrders(context.Context, *CancelAllOrdersRequest) (*CancelAllOrdersResponse, error)
GetEvents(context.Context, *GetEventsRequest) (*GetEventsResponse, error)
@@ -5457,6 +5699,42 @@ func _GoCryptoTrader_SubmitOrder_Handler(srv interface{}, ctx context.Context, d
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_SimulateOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SimulateOrderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).SimulateOrder(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/SimulateOrder",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).SimulateOrder(ctx, req.(*SimulateOrderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WhaleBomb_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WhaleBombRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WhaleBomb(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WhaleBomb",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WhaleBomb(ctx, req.(*WhaleBombRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_CancelOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CancelOrderRequest)
if err := dec(in); err != nil {
@@ -5731,6 +6009,14 @@ var _GoCryptoTrader_serviceDesc = grpc.ServiceDesc{
MethodName: "SubmitOrder",
Handler: _GoCryptoTrader_SubmitOrder_Handler,
},
{
MethodName: "SimulateOrder",
Handler: _GoCryptoTrader_SimulateOrder_Handler,
},
{
MethodName: "WhaleBomb",
Handler: _GoCryptoTrader_WhaleBomb_Handler,
},
{
MethodName: "CancelOrder",
Handler: _GoCryptoTrader_CancelOrder_Handler,

82
gctrpc/rpc.pb.gw.go
View File

@@ -391,6 +391,40 @@ func request_GoCryptoTrader_SubmitOrder_0(ctx context.Context, marshaler runtime
}
func request_GoCryptoTrader_SimulateOrder_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq SimulateOrderRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.SimulateOrder(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func request_GoCryptoTrader_WhaleBomb_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WhaleBombRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.WhaleBomb(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func request_GoCryptoTrader_CancelOrder_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq CancelOrderRequest
var metadata runtime.ServerMetadata
@@ -1114,6 +1148,46 @@ func RegisterGoCryptoTraderHandlerClient(ctx context.Context, mux *runtime.Serve
})
mux.Handle("POST", pattern_GoCryptoTrader_SimulateOrder_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_GoCryptoTrader_SimulateOrder_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_SimulateOrder_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_GoCryptoTrader_WhaleBomb_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_GoCryptoTrader_WhaleBomb_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_WhaleBomb_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_GoCryptoTrader_CancelOrder_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@@ -1352,6 +1426,10 @@ var (
pattern_GoCryptoTrader_SubmitOrder_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "submitorder"}, ""))
pattern_GoCryptoTrader_SimulateOrder_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "simulateorder"}, ""))
pattern_GoCryptoTrader_WhaleBomb_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "whalebomb"}, ""))
pattern_GoCryptoTrader_CancelOrder_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "cancelorder"}, ""))
pattern_GoCryptoTrader_CancelAllOrders_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "cancelallorders"}, ""))
@@ -1426,6 +1504,10 @@ var (
forward_GoCryptoTrader_SubmitOrder_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_SimulateOrder_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_WhaleBomb_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_CancelOrder_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_CancelAllOrders_0 = runtime.ForwardResponseMessage

37
gctrpc/rpc.proto
View File

@@ -327,6 +327,29 @@ message SubmitOrderResponse {
string order_id = 2;
}
message SimulateOrderRequest {
string exchange = 1;
CurrencyPair pair = 2;
double amount = 3;
string side = 4;
}
message SimulateOrderResponse {
repeated OrderbookItem orders = 1;
double amount = 2;
double minimum_price = 3;
double maximum_price = 4;
double percentage_gain_loss = 5;
string status = 6;
}
message WhaleBombRequest {
string exchange = 1;
CurrencyPair pair = 2;
double price_target = 3;
string side = 4;
}
message CancelOrderRequest {
string exchange = 1;
string account_id = 2;
@@ -605,6 +628,20 @@ service GoCryptoTrader {
};
}
rpc SimulateOrder (SimulateOrderRequest) returns (SimulateOrderResponse) {
option (google.api.http) = {
post: "/v1/simulateorder"
body: "*"
};
}
rpc WhaleBomb (WhaleBombRequest) returns (SimulateOrderResponse) {
option (google.api.http) = {
post: "/v1/whalebomb"
body: "*"
};
}
rpc CancelOrder (CancelOrderRequest) returns (CancelOrderResponse) {
option (google.api.http) = {
post: "/v1/cancelorder"

118
gctrpc/rpc.swagger.json
View File

@@ -732,6 +732,32 @@
]
}
},
"/v1/simulateorder": {
"post": {
"operationId": "SimulateOrder",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/gctrpcSimulateOrderResponse"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/gctrpcSimulateOrderRequest"
}
}
],
"tags": [
"GoCryptoTrader"
]
}
},
"/v1/submitorder": {
"post": {
"operationId": "SubmitOrder",
@@ -758,6 +784,32 @@
]
}
},
"/v1/whalebomb": {
"post": {
"operationId": "WhaleBomb",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/gctrpcSimulateOrderResponse"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/gctrpcWhaleBombRequest"
}
}
],
"tags": [
"GoCryptoTrader"
]
}
},
"/v1/withdrawcryptofunds": {
"post": {
"operationId": "WithdrawCryptocurrencyFunds",
@@ -1690,6 +1742,54 @@
"gctrpcRemovePortfolioAddressResponse": {
"type": "object"
},
"gctrpcSimulateOrderRequest": {
"type": "object",
"properties": {
"exchange": {
"type": "string"
},
"pair": {
"$ref": "#/definitions/gctrpcCurrencyPair"
},
"amount": {
"type": "number",
"format": "double"
},
"side": {
"type": "string"
}
}
},
"gctrpcSimulateOrderResponse": {
"type": "object",
"properties": {
"orders": {
"type": "array",
"items": {
"$ref": "#/definitions/gctrpcOrderbookItem"
}
},
"amount": {
"type": "number",
"format": "double"
},
"minimum_price": {
"type": "number",
"format": "double"
},
"maximum_price": {
"type": "number",
"format": "double"
},
"percentage_gain_loss": {
"type": "number",
"format": "double"
},
"status": {
"type": "string"
}
}
},
"gctrpcSubmitOrderRequest": {
"type": "object",
"properties": {
@@ -1787,6 +1887,24 @@
}
}
},
"gctrpcWhaleBombRequest": {
"type": "object",
"properties": {
"exchange": {
"type": "string"
},
"pair": {
"$ref": "#/definitions/gctrpcCurrencyPair"
},
"price_target": {
"type": "number",
"format": "double"
},
"side": {
"type": "string"
}
}
},
"gctrpcWithdrawCurrencyRequest": {
"type": "object",
"properties": {