From b7a77f68afe971e5e745957d97de720f343cfb7f Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 5 Dec 2020 11:45:21 +0300 Subject: [PATCH 01/16] feat: new grpc call for subscribing alerts and low balance alert (#864) --- docs/api.md | 75 ++ lib/Logger.ts | 3 + lib/Xud.ts | 5 + lib/alerts/Alerts.ts | 58 ++ lib/alerts/consts.ts | 2 + lib/alerts/types.ts | 19 + lib/cli/commands/streamalerts.ts | 78 +++ lib/cli/commands/streamorders.ts | 27 +- lib/cli/utils.ts | 31 + lib/connextclient/ConnextClient.ts | 19 + lib/constants/enums.ts | 9 + lib/grpc/GrpcService.ts | 31 +- lib/lndclient/LndClient.ts | 16 +- lib/proto/annotations_grpc_pb.js | 2 +- lib/proto/xudp2p_grpc_pb.js | 2 +- lib/proto/xudrpc.swagger.json | 88 +++ lib/proto/xudrpc_grpc_pb.d.ts | 15 + lib/proto/xudrpc_grpc_pb.js | 34 + lib/proto/xudrpc_pb.d.ts | 107 +++ lib/proto/xudrpc_pb.js | 624 +++++++++++++++++ lib/service/Service.ts | 23 + lib/service/types.ts | 2 + lib/swaps/SwapClient.ts | 25 +- proto/xudrpc.proto | 41 ++ test/integration/Service.spec.ts | 37 + test/jest/LndClient.spec.ts | 159 ++++- test/jest/Orderbook.spec.ts | 1 + test/jest/Service.spec.ts | 4 + test/jest/SwapClientManager.spec.ts | 1 + test/simulation/xudrpc/xudrpc.pb.go | 1014 ++++++++++++++++++--------- 30 files changed, 2174 insertions(+), 378 deletions(-) create mode 100644 lib/alerts/Alerts.ts create mode 100644 lib/alerts/consts.ts create mode 100644 lib/alerts/types.ts create mode 100644 lib/cli/commands/streamalerts.ts diff --git a/docs/api.md b/docs/api.md index 40231ec6b..b2c58a173 100644 --- a/docs/api.md +++ b/docs/api.md @@ -7,7 +7,9 @@ - [AddCurrencyResponse](#xudrpc.AddCurrencyResponse) - [AddPairRequest](#xudrpc.AddPairRequest) - [AddPairResponse](#xudrpc.AddPairResponse) + - [Alert](#xudrpc.Alert) - [Balance](#xudrpc.Balance) + - [BalanceAlert](#xudrpc.BalanceAlert) - [BanRequest](#xudrpc.BanRequest) - [BanResponse](#xudrpc.BanResponse) - [Chain](#xudrpc.Chain) @@ -75,6 +77,7 @@ - [SetLogLevelResponse](#xudrpc.SetLogLevelResponse) - [ShutdownRequest](#xudrpc.ShutdownRequest) - [ShutdownResponse](#xudrpc.ShutdownResponse) + - [SubscribeAlertsRequest](#xudrpc.SubscribeAlertsRequest) - [SubscribeOrdersRequest](#xudrpc.SubscribeOrdersRequest) - [SubscribeSwapsAcceptedRequest](#xudrpc.SubscribeSwapsAcceptedRequest) - [SubscribeSwapsRequest](#xudrpc.SubscribeSwapsRequest) @@ -95,6 +98,8 @@ - [WithdrawRequest](#xudrpc.WithdrawRequest) - [WithdrawResponse](#xudrpc.WithdrawResponse) + - [Alert.AlertType](#xudrpc.Alert.AlertType) + - [BalanceAlert.Side](#xudrpc.BalanceAlert.Side) - [Currency.SwapClient](#xudrpc.Currency.SwapClient) - [ListOrdersRequest.Owner](#xudrpc.ListOrdersRequest.Owner) - [LogLevel](#xudrpc.LogLevel) @@ -151,6 +156,23 @@ + + +### Alert + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| type | [Alert.AlertType](#xudrpc.Alert.AlertType) | | | +| message | [string](#string) | | The human readable alert message. | +| balance_alert | [BalanceAlert](#xudrpc.BalanceAlert) | | | + + + + + + ### Balance @@ -171,6 +193,25 @@ + + +### BalanceAlert + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| total_balance | [uint64](#uint64) | | The total balance. | +| side | [BalanceAlert.Side](#xudrpc.BalanceAlert.Side) | | | +| bound | [uint32](#uint32) | | The bound of the low balance in percentage. | +| side_balance | [uint64](#uint64) | | The current side balance. | +| currency | [string](#string) | | The currency of the alert. | + + + + + + ### BanRequest @@ -1201,6 +1242,16 @@ + + +### SubscribeAlertsRequest + + + + + + + ### SubscribeOrdersRequest @@ -1523,6 +1574,29 @@ + + +### Alert.AlertType +The type of the alert. + +| Name | Number | Description | +| ---- | ------ | ----------- | +| LOW_TRADING_BALANCE | 0 | | + + + + + +### BalanceAlert.Side +The side of the low balance. + +| Name | Number | Description | +| ---- | ------ | ----------- | +| REMOTE | 0 | | +| LOCAL | 1 | | + + + ### Currency.SwapClient @@ -1628,6 +1702,7 @@ The primary service for interacting with a running xud node. | RemovePair | [RemovePairRequest](#xudrpc.RemovePairRequest) | [RemovePairResponse](#xudrpc.RemovePairResponse) | Removes a trading pair from the list of currently supported trading pair. This call will effectively cancel any standing orders for that trading pair. Peers are informed when a pair is no longer supported so that they will know to stop sending orders for it. shell: xucli removepair <pair_id> | | SetLogLevel | [SetLogLevelRequest](#xudrpc.SetLogLevelRequest) | [SetLogLevelResponse](#xudrpc.SetLogLevelResponse) | Set the logging level. shell: xucli loglevel <level> | | Shutdown | [ShutdownRequest](#xudrpc.ShutdownRequest) | [ShutdownResponse](#xudrpc.ShutdownResponse) | Begin gracefully shutting down xud. shell: xucli shutdown | +| SubscribeAlerts | [SubscribeAlertsRequest](#xudrpc.SubscribeAlertsRequest) | [Alert](#xudrpc.Alert) stream | Subscribes to alerts such as low balance. | | SubscribeOrders | [SubscribeOrdersRequest](#xudrpc.SubscribeOrdersRequest) | [OrderUpdate](#xudrpc.OrderUpdate) stream | Subscribes to orders being added to and removed from the order book. This call allows the client to maintain an up-to-date view of the order book. For example, an exchange that wants to show its users a real time view of the orders available to them would subscribe to this streaming call to be alerted as new orders are added and expired orders are removed. | | SubscribeSwapFailures | [SubscribeSwapsRequest](#xudrpc.SubscribeSwapsRequest) | [SwapFailure](#xudrpc.SwapFailure) stream | Subscribes to failed swaps. By default, only swaps that are initiated by a remote peer are transmitted unless a flag is set to include swaps initiated by the local node. This call allows the client to get real-time notifications when swap attempts are failing. It can be used for status monitoring, debugging, and testing purposes. | | SubscribeSwaps | [SubscribeSwapsRequest](#xudrpc.SubscribeSwapsRequest) | [SwapSuccess](#xudrpc.SwapSuccess) stream | Subscribes to completed swaps. By default, only swaps that are initiated by a remote peer are transmitted unless a flag is set to include swaps initiated by the local node. This call allows the client to get real-time notifications when its orders are filled by a peer. It can be used for tracking order executions, updating balances, and informing a trader when one of their orders is settled through the Exchange Union network. | diff --git a/lib/Logger.ts b/lib/Logger.ts index 280770c5b..7f09f8fc4 100644 --- a/lib/Logger.ts +++ b/lib/Logger.ts @@ -45,6 +45,7 @@ export enum Context { Http = 'HTTP', Backup = 'BACKUP', Service = 'SERVICE', + Alerts = 'ALERTS', } type Loggers = { @@ -58,6 +59,7 @@ type Loggers = { swaps: Logger, http: Logger, service: Logger, + alerts: Logger, }; class Logger { @@ -133,6 +135,7 @@ class Logger { swaps: new Logger({ ...object, context: Context.Swaps }), http: new Logger({ ...object, context: Context.Http }), service: new Logger({ ...object, context: Context.Service }), + alerts: new Logger({ ...object, context: Context.Alerts }), }; } diff --git a/lib/Xud.ts b/lib/Xud.ts index 490e252c0..b820de98f 100644 --- a/lib/Xud.ts +++ b/lib/Xud.ts @@ -20,6 +20,7 @@ import SwapClientManager from './swaps/SwapClientManager'; import Swaps from './swaps/Swaps'; import { createSimnetChannels } from './utils/simnet-connext-channels'; import { UnitConverter } from './utils/UnitConverter'; +import Alerts from './alerts/Alerts'; const version: string = require('../package.json').version; @@ -46,6 +47,7 @@ class Xud extends EventEmitter { private swapClientManager?: SwapClientManager; private unitConverter?: UnitConverter; private simnetChannels$?: Subscription; + private alerts!: Alerts; /** * Create an Exchange Union daemon. @@ -203,6 +205,8 @@ class Xud extends EventEmitter { // initialize pool and start listening/connecting only once other components are initialized await this.pool.init(); + this.alerts = new Alerts({ swapClientManager: this.swapClientManager, logger: loggers.alerts }); + this.service = new Service({ version, nodeKey, @@ -212,6 +216,7 @@ class Xud extends EventEmitter { swaps: this.swaps, logger: loggers.service, shutdown: this.beginShutdown, + alerts: this.alerts, }); this.service.on('logLevel', (level) => { diff --git a/lib/alerts/Alerts.ts b/lib/alerts/Alerts.ts new file mode 100644 index 000000000..59480c63d --- /dev/null +++ b/lib/alerts/Alerts.ts @@ -0,0 +1,58 @@ +import { EventEmitter } from 'events'; +import { BalanceAlert } from './types'; +import SwapClientManager from '../swaps/SwapClientManager'; +import { MIN_BALANCE_ALERT_THRESHOLD_IN_MS } from './consts'; +import Logger from '../Logger'; +import { AlertType, ChannelSide } from '../constants/enums'; +import { satsToCoinsStr } from '../cli/utils'; + +interface Alerts { + on(event: 'alert', listener: (alert: any) => void): this; + emit(event: 'alert', alert: any): boolean; +} + +// TODO this class still requires a cleanup if alert is not being thrown anymore after a while +/** + * This class works as a middleware for thrown alerts from xud's main flow. Each alert will be caught here + * and re-thrown if last thrown time was before the minimum threshold that set in consts.ts + */ +class Alerts extends EventEmitter { + private alerts = new Map(); + private logger: Logger; + + constructor({ swapClientManager, logger }: {swapClientManager: SwapClientManager, logger: Logger}) { + super(); + this.logger = logger; + this.listenLowTradingBalanceAlerts(swapClientManager); + } + + private listenLowTradingBalanceAlerts(swapClientManager: SwapClientManager) { + const lndClients = swapClientManager.getLndClientsMap().values(); + for (const lndClient of lndClients) { + lndClient.on('lowTradingBalance', this.onLowTradingBalance); + } + swapClientManager.connextClient?.on('lowTradingBalance', this.onLowTradingBalance); + } + + private onLowTradingBalance = (balanceAlert: BalanceAlert) => { + const stringRepresentation = JSON.stringify(balanceAlert); + this.logger.trace(`received low trading balance alert ${stringRepresentation}`); + if (this.alerts.get(stringRepresentation) === undefined || this.checkAlertThreshold(stringRepresentation)) { + this.logger.trace(`triggering low balance alert ${stringRepresentation}`); + + balanceAlert.message = `${ChannelSide[balanceAlert.side || 0]} trading balance (${satsToCoinsStr(balanceAlert.sideBalance || 0)} ${balanceAlert.currency}) is lower than 10% of trading capacity (${satsToCoinsStr(balanceAlert.totalBalance || 0)} ${balanceAlert.currency})`; + balanceAlert.type = AlertType.LowTradingBalance; + + this.alerts.set(stringRepresentation, Date.now()); + this.emit('alert', balanceAlert); + } + } + + private checkAlertThreshold(stringRepresentation: string) { + const lastThrownTime = this.alerts.get(stringRepresentation) || 0; + const passedTime = Date.now() - lastThrownTime; + return passedTime > MIN_BALANCE_ALERT_THRESHOLD_IN_MS; + } +} + +export default Alerts; diff --git a/lib/alerts/consts.ts b/lib/alerts/consts.ts new file mode 100644 index 000000000..e29bb7c76 --- /dev/null +++ b/lib/alerts/consts.ts @@ -0,0 +1,2 @@ +/** The minimum time in miliseconds to be passed to rethrow a balance alert. */ +export const MIN_BALANCE_ALERT_THRESHOLD_IN_MS = 10000; diff --git a/lib/alerts/types.ts b/lib/alerts/types.ts new file mode 100644 index 000000000..e99dd6390 --- /dev/null +++ b/lib/alerts/types.ts @@ -0,0 +1,19 @@ +import { AlertType, ChannelSide } from '../constants/enums'; + +export type BalanceAlert = Alert & { + /** The total balance of the channel when the alert is triggered. */ + totalBalance: number; + /** The side of the balance either local or remote. */ + side: ChannelSide; + /** The balance that triggered the alert. */ + sideBalance: number; + /** The alert threshold in percentage, e.g. 10 means %10. */ + bound: number; + /** The currency of the channel. */ + currency: string; +}; + +export type Alert = { + type: AlertType; + message: string; +}; diff --git a/lib/cli/commands/streamalerts.ts b/lib/cli/commands/streamalerts.ts new file mode 100644 index 000000000..be05e0eef --- /dev/null +++ b/lib/cli/commands/streamalerts.ts @@ -0,0 +1,78 @@ +import { Arguments, Argv } from 'yargs'; +import { XudClient } from '../../proto/xudrpc_grpc_pb'; +import * as xudrpc from '../../proto/xudrpc_pb'; +import { loadXudClient } from '../command'; +import { AlertType, ChannelSide } from '../../constants/enums'; +import { onStreamError, waitForClient } from '../utils'; +import moment from 'moment'; + +export const command = 'streamalerts'; + +export const describe = 'stream alert notifications from xud'; + +export const builder = (argv: Argv) => argv + .option('pretty', { + type: 'boolean', + }) + .example('$0 streamalerts -j', 'prints alert payload in a JSON structure') + .example('$0 streamalerts', 'prints alert message only'); + +export const handler = async (argv: Arguments) => { + await ensureConnection(argv, true); +}; + +let client: XudClient; + +const ensureConnection = async (argv: Arguments, printError?: boolean) => { + if (!client) { + client = await loadXudClient(argv); + } + + waitForClient(client, argv, ensureConnection, streamalerts, printError); +}; + +const structAlertJson = (alertObject: xudrpc.Alert.AsObject) => { + const result: {type: string, payload: { + totalBalance?: number, + side?: string, + bound?: number, + sideBalance?: number, + channelPoint?: string, + currency?: string, + } | undefined } = { + type: AlertType[alertObject.type], + payload: undefined, + }; + + if (alertObject.type === xudrpc.Alert.AlertType.LOW_TRADING_BALANCE) { + result.payload = { + totalBalance: alertObject.balanceAlert?.totalBalance, + side: ChannelSide[alertObject.balanceAlert?.side || 0], + sideBalance: alertObject.balanceAlert?.sideBalance, + bound: alertObject.balanceAlert?.bound, + currency: alertObject.balanceAlert?.currency, + }; + } + + return result; +}; + +const streamalerts = (argv: Arguments) => { + const request = new xudrpc.SubscribeAlertsRequest(); + const alertsSubscription = client.subscribeAlerts(request); + + alertsSubscription.on('data', (alert: xudrpc.Alert) => { + if (argv.json) { + console.log(JSON.stringify(structAlertJson(alert.toObject()), undefined, 2)); + } else { + console.log(`(${moment()}) ${AlertType[alert.getType()]}: ${alert.getMessage()}`); + } + }); + alertsSubscription.on('end', reconnect.bind(undefined, argv)); + alertsSubscription.on('error', onStreamError.bind(undefined, ensureConnection.bind(undefined, argv))); +}; + +const reconnect = async (argv: Arguments) => { + console.log('Stream has closed, trying to reconnect'); + await ensureConnection(argv, false); +}; diff --git a/lib/cli/commands/streamorders.ts b/lib/cli/commands/streamorders.ts index d987a3111..e4ff418ee 100644 --- a/lib/cli/commands/streamorders.ts +++ b/lib/cli/commands/streamorders.ts @@ -1,9 +1,8 @@ -import { ServiceError, status } from 'grpc'; import { Arguments, Argv } from 'yargs'; import { XudClient } from '../../proto/xudrpc_grpc_pb'; import * as xudrpc from '../../proto/xudrpc_pb'; -import { setTimeoutPromise } from '../../utils/utils'; import { loadXudClient } from '../command'; +import { onStreamError, waitForClient } from '../utils'; export const command = 'streamorders [existing]'; @@ -26,20 +25,8 @@ const ensureConnection = async (argv: Arguments, printError?: boolean) => { if (!client) { client = await loadXudClient(argv); } - client.waitForReady(Date.now() + 3000, (error: Error | null) => { - if (error) { - if (error.message === 'Failed to connect before the deadline') { - console.error(`could not connect to xud at ${argv.rpchost}:${argv.rpcport}, is xud running?`); - process.exit(1); - } - if (printError) console.error(`${error.name}: ${error.message}`); - setTimeout(ensureConnection.bind(undefined, argv, printError), 3000); - } else { - console.log('Successfully connected, subscribing for orders'); - streamOrders(argv); - } - }); + waitForClient(client, argv, ensureConnection, streamOrders, printError); }; const streamOrders = (argv: Arguments) => { @@ -57,15 +44,7 @@ const streamOrders = (argv: Arguments) => { // adding end, close, error events only once, // since they'll be thrown for three of subscriptions in the corresponding cases, catching once is enough. ordersSubscription.on('end', reconnect.bind(undefined, argv)); - ordersSubscription.on('error', async (err: ServiceError) => { - if (err.code === status.UNIMPLEMENTED) { - console.error("xud is locked, run 'xucli unlock', 'xucli create', or 'xucli restore' then try again"); - process.exit(1); - } - console.warn(`Unexpected error occured: ${err.message}, reconnecting in 1 second`); - await setTimeoutPromise(1000); - await ensureConnection(argv); - }); + ordersSubscription.on('error', onStreamError.bind(undefined, ensureConnection.bind(undefined, argv))); const swapsRequest = new xudrpc.SubscribeSwapsRequest(); swapsRequest.setIncludeTaker(true); diff --git a/lib/cli/utils.ts b/lib/cli/utils.ts index ad1a17532..8294678b1 100644 --- a/lib/cli/utils.ts +++ b/lib/cli/utils.ts @@ -2,6 +2,10 @@ import colors from 'colors/safe'; import { accessSync, watch } from 'fs'; import os from 'os'; import path from 'path'; +import { XudClient } from '../proto/xudrpc_grpc_pb'; +import { Arguments } from 'yargs'; +import { ServiceError, status } from 'grpc'; +import { setTimeoutPromise } from '../utils/utils'; const SATOSHIS_PER_COIN = 10 ** 8; @@ -100,3 +104,30 @@ be recovered with it and must be backed up and recovered separately. Keep it \ somewhere safe, it is your ONLY backup in case of data loss. `); } + +export const waitForClient = (client: XudClient, argv: Arguments, ensureConnection: Function, successCallback: Function, printError?: boolean) => { + client.waitForReady(Date.now() + 3000, (error: Error | null) => { + if (error) { + if (error.message === 'Failed to connect before the deadline') { + console.error(`could not connect to xud at ${argv.rpchost}:${argv.rpcport}, is xud running?`); + process.exit(1); + } + + if (printError) console.error(`${error.name}: ${error.message}`); + setTimeout(ensureConnection.bind(undefined, argv, printError), 3000); + } else { + console.log('Successfully connected, streaming'); + successCallback(argv); + } + }); +}; + +export const onStreamError = async (ensureConnection: Function, err: ServiceError) => { + if (err.code === status.UNIMPLEMENTED) { + console.error("xud is locked, run 'xucli unlock', 'xucli create', or 'xucli restore' then try again"); + process.exit(1); + } + console.warn(`Unexpected error occured: ${err.message}, reconnecting in 1 second`); + await setTimeoutPromise(1000); + await ensureConnection(); +}; diff --git a/lib/connextclient/ConnextClient.ts b/lib/connextclient/ConnextClient.ts index d6ac809d3..595b42f91 100644 --- a/lib/connextclient/ConnextClient.ts +++ b/lib/connextclient/ConnextClient.ts @@ -39,6 +39,7 @@ import { parseResponseBody } from '../utils/utils'; import { Observable, fromEvent, from, combineLatest, defer, timer } from 'rxjs'; import { take, pluck, timeout, filter, catchError, mergeMapTo } from 'rxjs/operators'; import { sha256 } from '@ethersproject/solidity'; +import { BalanceAlert } from '../alerts/types'; interface ConnextClient { on(event: 'preimage', listener: (preimageRequest: ProvidePreimageEvent) => void): void; @@ -46,6 +47,7 @@ interface ConnextClient { on(event: 'htlcAccepted', listener: (rHash: string, amount: number, currency: string) => void): this; on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; on(event: 'depositConfirmed', listener: (hash: string) => void): this; + on(event: 'lowTradingBalance', listener: (alert: BalanceAlert) => void): this; once(event: 'initialized', listener: () => void): this; emit(event: 'htlcAccepted', rHash: string, amount: number, currency: string): boolean; emit(event: 'connectionVerified', swapClientInfo: SwapClientInfo): boolean; @@ -53,6 +55,7 @@ interface ConnextClient { emit(event: 'preimage', preimageRequest: ProvidePreimageEvent): void; emit(event: 'transferReceived', transferReceivedRequest: TransferReceivedEvent): void; emit(event: 'depositConfirmed', hash: string): void; + emit(event: 'lowTradingBalance', alert: BalanceAlert): boolean; } /** @@ -335,6 +338,22 @@ class ConnextClient extends SwapClient { channelBalancePromises.push(this.channelBalance(currency)); } await Promise.all(channelBalancePromises); + + for (const [currency] of this.tokenAddresses) { + const remoteBalance = this.inboundAmounts.get(currency) || 0; + const localBalance = this.outboundAmounts.get(currency) || 0; + const totalBalance = remoteBalance + localBalance; + const alertThreshold = totalBalance * 0.1; + + this.checkLowBalance( + remoteBalance, + localBalance, + totalBalance, + alertThreshold, + currency, + this.emit.bind(this), + ); + } } catch (e) { this.logger.error('failed to update total outbound capacity', e); } diff --git a/lib/constants/enums.ts b/lib/constants/enums.ts index e86a12080..1d74a1bfa 100644 --- a/lib/constants/enums.ts +++ b/lib/constants/enums.ts @@ -180,3 +180,12 @@ export enum DisconnectionReason { AuthFailureInvalidSignature = 12, WireProtocolErr = 13, } + +export enum AlertType { + LowTradingBalance = 0, +} + +export enum ChannelSide { + Remote, + Local, +} diff --git a/lib/grpc/GrpcService.ts b/lib/grpc/GrpcService.ts index 7a581cba5..0e8073bd2 100644 --- a/lib/grpc/GrpcService.ts +++ b/lib/grpc/GrpcService.ts @@ -2,7 +2,7 @@ import grpc, { ServerWritableStream, status } from 'grpc'; import { fromEvent } from 'rxjs'; import { take } from 'rxjs/operators'; -import { SwapFailureReason } from '../constants/enums'; +import { AlertType, SwapFailureReason } from '../constants/enums'; import { LndInfo } from '../lndclient/types'; import { isOwnOrder, Order, OrderPortion, PlaceOrderEventType, PlaceOrderResult } from '../orderbook/types'; import * as xudrpc from '../proto/xudrpc_pb'; @@ -10,6 +10,7 @@ import Service from '../service/Service'; import { ServiceOrder, ServicePlaceOrderEvent } from '../service/types'; import { SwapAccepted, SwapFailure, SwapSuccess } from '../swaps/types'; import getGrpcError from './getGrpcError'; +import { BalanceAlert } from '../alerts/types'; /** * Creates an xudrpc Order message from an [[Order]]. @@ -904,6 +905,34 @@ class GrpcService { } } + /* + * See [[Service.subscribeAlerts]] + */ + public subscribeAlerts: grpc.handleServerStreamingCall = (call) => { + if (!this.isReady(this.service, call)) { + return; + } + + const cancelled$ = getCancelled$(call); + this.service.subscribeAlerts((serviceAlert: any) => { + const alert = new xudrpc.Alert(); + alert.setType(serviceAlert.type as number); + alert.setMessage(serviceAlert.message); + if (serviceAlert.type === AlertType.LowTradingBalance) { + const balanceServiceAlert = serviceAlert as BalanceAlert; + const balanceAlert = new xudrpc.BalanceAlert(); + balanceAlert.setBound(balanceServiceAlert.bound); + balanceAlert.setSide(balanceServiceAlert.side as number); + balanceAlert.setSideBalance(balanceServiceAlert.sideBalance); + balanceAlert.setTotalBalance(balanceServiceAlert.totalBalance); + balanceAlert.setCurrency(balanceServiceAlert.currency); + alert.setBalanceAlert(balanceAlert); + } + call.write(alert); + }, cancelled$); + this.addStream(call); + } + /* * See [[Service.subscribeOrders]] */ diff --git a/lib/lndclient/LndClient.ts b/lib/lndclient/LndClient.ts index 583fca8b5..74266aa56 100644 --- a/lib/lndclient/LndClient.ts +++ b/lib/lndclient/LndClient.ts @@ -21,6 +21,7 @@ import { deriveChild } from '../utils/seedutil'; import { base64ToHex, hexToUint8Array } from '../utils/utils'; import errors from './errors'; import { Chain, ChannelCount, ClientMethods, LndClientConfig, LndInfo } from './types'; +import { BalanceAlert } from '../alerts/types'; interface LndClient { on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; @@ -28,6 +29,7 @@ interface LndClient { on(event: 'channelBackup', listener: (channelBackup: Uint8Array) => void): this; on(event: 'channelBackupEnd', listener: () => void): this; on(event: 'locked', listener: () => void): this; + on(event: 'lowTradingBalance', listener: (alert: BalanceAlert) => void): this; once(event: 'initialized', listener: () => void): this; @@ -37,6 +39,7 @@ interface LndClient { emit(event: 'channelBackupEnd'): boolean; emit(event: 'locked'): boolean; emit(event: 'initialized'): boolean; + emit(event: 'lowTradingBalance', alert: BalanceAlert): boolean; } const GRPC_CLIENT_OPTIONS = { @@ -239,7 +242,18 @@ class LndClient extends SwapClient { } protected updateCapacity = async () => { - await this.channelBalance().catch(async (err) => { + await this.channelBalance().then(() => { + const totalBalance = this.totalOutboundAmount + this.totalInboundAmount; + const alertThreshold = totalBalance * 0.1; + this.checkLowBalance( + this.totalInboundAmount, + this.totalOutboundAmount, + totalBalance, + alertThreshold, + this.currency, + this.emit.bind(this), + ); + }).catch(async (err) => { this.logger.error('failed to update total outbound capacity', err); }); } diff --git a/lib/proto/annotations_grpc_pb.js b/lib/proto/annotations_grpc_pb.js index 97b3a2461..51b4d6959 100644 --- a/lib/proto/annotations_grpc_pb.js +++ b/lib/proto/annotations_grpc_pb.js @@ -1 +1 @@ -// GENERATED CODE -- NO SERVICES IN PROTO \ No newline at end of file +// GENERATED CODE -- NO SERVICES IN PROTO diff --git a/lib/proto/xudp2p_grpc_pb.js b/lib/proto/xudp2p_grpc_pb.js index 97b3a2461..51b4d6959 100644 --- a/lib/proto/xudp2p_grpc_pb.js +++ b/lib/proto/xudp2p_grpc_pb.js @@ -1 +1 @@ -// GENERATED CODE -- NO SERVICES IN PROTO \ No newline at end of file +// GENERATED CODE -- NO SERVICES IN PROTO diff --git a/lib/proto/xudrpc.swagger.json b/lib/proto/xudrpc.swagger.json index ccdc5b3dc..01d5c93d4 100644 --- a/lib/proto/xudrpc.swagger.json +++ b/lib/proto/xudrpc.swagger.json @@ -636,6 +636,23 @@ ] } }, + "/v1/subscribealerts": { + "get": { + "summary": "Subscribes to alerts such as low balance.", + "operationId": "SubscribeAlerts", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "$ref": "#/x-stream-definitions/xudrpcAlert" + } + } + }, + "tags": [ + "Xud" + ] + } + }, "/v1/subscribeorders": { "get": { "summary": "Subscribes to orders being added to and removed from the order book. This call allows the client\nto maintain an up-to-date view of the order book. For example, an exchange that wants to show\nits users a real time view of the orders available to them would subscribe to this streaming\ncall to be alerted as new orders are added and expired orders are removed.", @@ -870,6 +887,23 @@ } }, "definitions": { + "AlertAlertType": { + "type": "string", + "enum": [ + "LOW_TRADING_BALANCE" + ], + "default": "LOW_TRADING_BALANCE", + "description": "The type of the alert." + }, + "BalanceAlertSide": { + "type": "string", + "enum": [ + "REMOTE", + "LOCAL" + ], + "default": "REMOTE", + "description": "The side of the low balance." + }, "CurrencySwapClient": { "type": "string", "enum": [ @@ -943,6 +977,21 @@ "xudrpcAddPairResponse": { "type": "object" }, + "xudrpcAlert": { + "type": "object", + "properties": { + "type": { + "$ref": "#/definitions/AlertAlertType" + }, + "message": { + "type": "string", + "description": "The human readable alert message." + }, + "balance_alert": { + "$ref": "#/definitions/xudrpcBalanceAlert" + } + } + }, "xudrpcBalance": { "type": "object", "properties": { @@ -978,6 +1027,33 @@ } } }, + "xudrpcBalanceAlert": { + "type": "object", + "properties": { + "total_balance": { + "type": "string", + "format": "uint64", + "description": "The total balance." + }, + "side": { + "$ref": "#/definitions/BalanceAlertSide" + }, + "bound": { + "type": "integer", + "format": "int64", + "description": "The bound of the low balance in percentage." + }, + "side_balance": { + "type": "string", + "format": "uint64", + "description": "The current side balance." + }, + "currency": { + "type": "string", + "description": "The currency of the alert." + } + } + }, "xudrpcBanRequest": { "type": "object", "properties": { @@ -2100,6 +2176,18 @@ } }, "x-stream-definitions": { + "xudrpcAlert": { + "type": "object", + "properties": { + "result": { + "$ref": "#/definitions/xudrpcAlert" + }, + "error": { + "$ref": "#/definitions/runtimeStreamError" + } + }, + "title": "Stream result of xudrpcAlert" + }, "xudrpcOrderUpdate": { "type": "object", "properties": { diff --git a/lib/proto/xudrpc_grpc_pb.d.ts b/lib/proto/xudrpc_grpc_pb.d.ts index 22051652c..23d9f31aa 100644 --- a/lib/proto/xudrpc_grpc_pb.d.ts +++ b/lib/proto/xudrpc_grpc_pb.d.ts @@ -101,6 +101,7 @@ interface IXudService extends grpc.ServiceDefinition; responseDeserialize: grpc.deserialize; } +interface IXudService_ISubscribeAlerts extends grpc.MethodDefinition { + path: string; // "/xudrpc.Xud/SubscribeAlerts" + requestStream: boolean; // false + responseStream: boolean; // true + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} interface IXudService_ISubscribeOrders extends grpc.MethodDefinition { path: string; // "/xudrpc.Xud/SubscribeOrders" requestStream: boolean; // false @@ -447,6 +457,7 @@ export interface IXudServer { removePair: grpc.handleUnaryCall; setLogLevel: grpc.handleUnaryCall; shutdown: grpc.handleUnaryCall; + subscribeAlerts: grpc.handleServerStreamingCall; subscribeOrders: grpc.handleServerStreamingCall; subscribeSwapFailures: grpc.handleServerStreamingCall; subscribeSwaps: grpc.handleServerStreamingCall; @@ -535,6 +546,8 @@ export interface IXudClient { shutdown(request: xudrpc_pb.ShutdownRequest, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.ShutdownResponse) => void): grpc.ClientUnaryCall; shutdown(request: xudrpc_pb.ShutdownRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.ShutdownResponse) => void): grpc.ClientUnaryCall; shutdown(request: xudrpc_pb.ShutdownRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.ShutdownResponse) => void): grpc.ClientUnaryCall; + subscribeAlerts(request: xudrpc_pb.SubscribeAlertsRequest, options?: Partial): grpc.ClientReadableStream; + subscribeAlerts(request: xudrpc_pb.SubscribeAlertsRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; subscribeOrders(request: xudrpc_pb.SubscribeOrdersRequest, options?: Partial): grpc.ClientReadableStream; subscribeOrders(request: xudrpc_pb.SubscribeOrdersRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; subscribeSwapFailures(request: xudrpc_pb.SubscribeSwapsRequest, options?: Partial): grpc.ClientReadableStream; @@ -636,6 +649,8 @@ export class XudClient extends grpc.Client implements IXudClient { public shutdown(request: xudrpc_pb.ShutdownRequest, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.ShutdownResponse) => void): grpc.ClientUnaryCall; public shutdown(request: xudrpc_pb.ShutdownRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.ShutdownResponse) => void): grpc.ClientUnaryCall; public shutdown(request: xudrpc_pb.ShutdownRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.ShutdownResponse) => void): grpc.ClientUnaryCall; + public subscribeAlerts(request: xudrpc_pb.SubscribeAlertsRequest, options?: Partial): grpc.ClientReadableStream; + public subscribeAlerts(request: xudrpc_pb.SubscribeAlertsRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; public subscribeOrders(request: xudrpc_pb.SubscribeOrdersRequest, options?: Partial): grpc.ClientReadableStream; public subscribeOrders(request: xudrpc_pb.SubscribeOrdersRequest, metadata?: grpc.Metadata, options?: Partial): grpc.ClientReadableStream; public subscribeSwapFailures(request: xudrpc_pb.SubscribeSwapsRequest, options?: Partial): grpc.ClientReadableStream; diff --git a/lib/proto/xudrpc_grpc_pb.js b/lib/proto/xudrpc_grpc_pb.js index 8d359ad92..1303cde7f 100644 --- a/lib/proto/xudrpc_grpc_pb.js +++ b/lib/proto/xudrpc_grpc_pb.js @@ -59,6 +59,17 @@ function deserialize_xudrpc_AddPairResponse(buffer_arg) { return xudrpc_pb.AddPairResponse.deserializeBinary(new Uint8Array(buffer_arg)); } +function serialize_xudrpc_Alert(arg) { + if (!(arg instanceof xudrpc_pb.Alert)) { + throw new Error('Expected argument of type xudrpc.Alert'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_xudrpc_Alert(buffer_arg) { + return xudrpc_pb.Alert.deserializeBinary(new Uint8Array(buffer_arg)); +} + function serialize_xudrpc_BanRequest(arg) { if (!(arg instanceof xudrpc_pb.BanRequest)) { throw new Error('Expected argument of type xudrpc.BanRequest'); @@ -631,6 +642,17 @@ function deserialize_xudrpc_ShutdownResponse(buffer_arg) { return xudrpc_pb.ShutdownResponse.deserializeBinary(new Uint8Array(buffer_arg)); } +function serialize_xudrpc_SubscribeAlertsRequest(arg) { + if (!(arg instanceof xudrpc_pb.SubscribeAlertsRequest)) { + throw new Error('Expected argument of type xudrpc.SubscribeAlertsRequest'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_xudrpc_SubscribeAlertsRequest(buffer_arg) { + return xudrpc_pb.SubscribeAlertsRequest.deserializeBinary(new Uint8Array(buffer_arg)); +} + function serialize_xudrpc_SubscribeOrdersRequest(arg) { if (!(arg instanceof xudrpc_pb.SubscribeOrdersRequest)) { throw new Error('Expected argument of type xudrpc.SubscribeOrdersRequest'); @@ -1212,6 +1234,18 @@ var XudService = exports.XudService = { responseSerialize: serialize_xudrpc_ShutdownResponse, responseDeserialize: deserialize_xudrpc_ShutdownResponse, }, + // Subscribes to alerts such as low balance. + subscribeAlerts: { + path: '/xudrpc.Xud/SubscribeAlerts', + requestStream: false, + responseStream: true, + requestType: xudrpc_pb.SubscribeAlertsRequest, + responseType: xudrpc_pb.Alert, + requestSerialize: serialize_xudrpc_SubscribeAlertsRequest, + requestDeserialize: deserialize_xudrpc_SubscribeAlertsRequest, + responseSerialize: serialize_xudrpc_Alert, + responseDeserialize: deserialize_xudrpc_Alert, + }, // Subscribes to orders being added to and removed from the order book. This call allows the client // to maintain an up-to-date view of the order book. For example, an exchange that wants to show // its users a real time view of the orders available to them would subscribe to this streaming diff --git a/lib/proto/xudrpc_pb.d.ts b/lib/proto/xudrpc_pb.d.ts index bd4afaa62..3999dc547 100644 --- a/lib/proto/xudrpc_pb.d.ts +++ b/lib/proto/xudrpc_pb.d.ts @@ -65,6 +65,53 @@ export namespace AddPairResponse { } } +export class Alert extends jspb.Message { + getType(): Alert.AlertType; + setType(value: Alert.AlertType): void; + + getMessage(): string; + setMessage(value: string): void; + + + hasBalanceAlert(): boolean; + clearBalanceAlert(): void; + getBalanceAlert(): BalanceAlert | undefined; + setBalanceAlert(value?: BalanceAlert): void; + + + getPayloadCase(): Alert.PayloadCase; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): Alert.AsObject; + static toObject(includeInstance: boolean, msg: Alert): Alert.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: Alert, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): Alert; + static deserializeBinaryFromReader(message: Alert, reader: jspb.BinaryReader): Alert; +} + +export namespace Alert { + export type AsObject = { + type: Alert.AlertType, + message: string, + balanceAlert?: BalanceAlert.AsObject, + } + + export enum AlertType { + LOW_TRADING_BALANCE = 0, + } + + + export enum PayloadCase { + PAYLOAD_NOT_SET = 0, + + BALANCE_ALERT = 3, + + } + +} + export class Balance extends jspb.Message { getTotalBalance(): number; setTotalBalance(value: number): void; @@ -106,6 +153,49 @@ export namespace Balance { } } +export class BalanceAlert extends jspb.Message { + getTotalBalance(): number; + setTotalBalance(value: number): void; + + getSide(): BalanceAlert.Side; + setSide(value: BalanceAlert.Side): void; + + getBound(): number; + setBound(value: number): void; + + getSideBalance(): number; + setSideBalance(value: number): void; + + getCurrency(): string; + setCurrency(value: string): void; + + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): BalanceAlert.AsObject; + static toObject(includeInstance: boolean, msg: BalanceAlert): BalanceAlert.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: BalanceAlert, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): BalanceAlert; + static deserializeBinaryFromReader(message: BalanceAlert, reader: jspb.BinaryReader): BalanceAlert; +} + +export namespace BalanceAlert { + export type AsObject = { + totalBalance: number, + side: BalanceAlert.Side, + bound: number, + sideBalance: number, + currency: string, + } + + export enum Side { + REMOTE = 0, + LOCAL = 1, + } + +} + export class BanRequest extends jspb.Message { getNodeIdentifier(): string; setNodeIdentifier(value: string): void; @@ -1861,6 +1951,23 @@ export namespace SubscribeOrdersRequest { } } +export class SubscribeAlertsRequest extends jspb.Message { + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): SubscribeAlertsRequest.AsObject; + static toObject(includeInstance: boolean, msg: SubscribeAlertsRequest): SubscribeAlertsRequest.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: SubscribeAlertsRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): SubscribeAlertsRequest; + static deserializeBinaryFromReader(message: SubscribeAlertsRequest, reader: jspb.BinaryReader): SubscribeAlertsRequest; +} + +export namespace SubscribeAlertsRequest { + export type AsObject = { + } +} + export class SubscribeSwapsAcceptedRequest extends jspb.Message { serializeBinary(): Uint8Array; diff --git a/lib/proto/xudrpc_pb.js b/lib/proto/xudrpc_pb.js index fd01ace0c..c190e4abc 100644 --- a/lib/proto/xudrpc_pb.js +++ b/lib/proto/xudrpc_pb.js @@ -16,7 +16,11 @@ goog.object.extend(proto, annotations_pb); goog.exportSymbol('proto.xudrpc.AddCurrencyResponse', null, global); goog.exportSymbol('proto.xudrpc.AddPairRequest', null, global); goog.exportSymbol('proto.xudrpc.AddPairResponse', null, global); +goog.exportSymbol('proto.xudrpc.Alert', null, global); +goog.exportSymbol('proto.xudrpc.Alert.AlertType', null, global); goog.exportSymbol('proto.xudrpc.Balance', null, global); +goog.exportSymbol('proto.xudrpc.BalanceAlert', null, global); +goog.exportSymbol('proto.xudrpc.BalanceAlert.Side', null, global); goog.exportSymbol('proto.xudrpc.BanRequest', null, global); goog.exportSymbol('proto.xudrpc.BanResponse', null, global); goog.exportSymbol('proto.xudrpc.Chain', null, global); @@ -84,6 +88,7 @@ goog.exportSymbol('proto.xudrpc.SetLogLevelRequest', null, global); goog.exportSymbol('proto.xudrpc.SetLogLevelResponse', null, global); goog.exportSymbol('proto.xudrpc.ShutdownRequest', null, global); goog.exportSymbol('proto.xudrpc.ShutdownResponse', null, global); +goog.exportSymbol('proto.xudrpc.SubscribeAlertsRequest', null, global); goog.exportSymbol('proto.xudrpc.SubscribeOrdersRequest', null, global); goog.exportSymbol('proto.xudrpc.SubscribeSwapsAcceptedRequest', null, global); goog.exportSymbol('proto.xudrpc.SubscribeSwapsRequest', null, global); @@ -504,6 +509,251 @@ proto.xudrpc.AddPairResponse.serializeBinaryToWriter = function(message, writer) +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.xudrpc.Alert = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, proto.xudrpc.Alert.oneofGroups_); +}; +goog.inherits(proto.xudrpc.Alert, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.xudrpc.Alert.displayName = 'proto.xudrpc.Alert'; +} +/** + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const + */ +proto.xudrpc.Alert.oneofGroups_ = [[3]]; + +/** + * @enum {number} + */ +proto.xudrpc.Alert.PayloadCase = { + PAYLOAD_NOT_SET: 0, + BALANCE_ALERT: 3 +}; + +/** + * @return {proto.xudrpc.Alert.PayloadCase} + */ +proto.xudrpc.Alert.prototype.getPayloadCase = function() { + return /** @type {proto.xudrpc.Alert.PayloadCase} */(jspb.Message.computeOneofCase(this, proto.xudrpc.Alert.oneofGroups_[0])); +}; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.xudrpc.Alert.prototype.toObject = function(opt_includeInstance) { + return proto.xudrpc.Alert.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.xudrpc.Alert} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.Alert.toObject = function(includeInstance, msg) { + var f, obj = { + type: jspb.Message.getFieldWithDefault(msg, 1, 0), + message: jspb.Message.getFieldWithDefault(msg, 2, ""), + balanceAlert: (f = msg.getBalanceAlert()) && proto.xudrpc.BalanceAlert.toObject(includeInstance, f) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.xudrpc.Alert} + */ +proto.xudrpc.Alert.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.xudrpc.Alert; + return proto.xudrpc.Alert.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.xudrpc.Alert} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.xudrpc.Alert} + */ +proto.xudrpc.Alert.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!proto.xudrpc.Alert.AlertType} */ (reader.readEnum()); + msg.setType(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setMessage(value); + break; + case 3: + var value = new proto.xudrpc.BalanceAlert; + reader.readMessage(value,proto.xudrpc.BalanceAlert.deserializeBinaryFromReader); + msg.setBalanceAlert(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.xudrpc.Alert.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.xudrpc.Alert.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.xudrpc.Alert} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.Alert.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getType(); + if (f !== 0.0) { + writer.writeEnum( + 1, + f + ); + } + f = message.getMessage(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getBalanceAlert(); + if (f != null) { + writer.writeMessage( + 3, + f, + proto.xudrpc.BalanceAlert.serializeBinaryToWriter + ); + } +}; + + +/** + * @enum {number} + */ +proto.xudrpc.Alert.AlertType = { + LOW_TRADING_BALANCE: 0 +}; + +/** + * optional AlertType type = 1; + * @return {!proto.xudrpc.Alert.AlertType} + */ +proto.xudrpc.Alert.prototype.getType = function() { + return /** @type {!proto.xudrpc.Alert.AlertType} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** @param {!proto.xudrpc.Alert.AlertType} value */ +proto.xudrpc.Alert.prototype.setType = function(value) { + jspb.Message.setProto3EnumField(this, 1, value); +}; + + +/** + * optional string message = 2; + * @return {string} + */ +proto.xudrpc.Alert.prototype.getMessage = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** @param {string} value */ +proto.xudrpc.Alert.prototype.setMessage = function(value) { + jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional BalanceAlert balance_alert = 3; + * @return {?proto.xudrpc.BalanceAlert} + */ +proto.xudrpc.Alert.prototype.getBalanceAlert = function() { + return /** @type{?proto.xudrpc.BalanceAlert} */ ( + jspb.Message.getWrapperField(this, proto.xudrpc.BalanceAlert, 3)); +}; + + +/** @param {?proto.xudrpc.BalanceAlert|undefined} value */ +proto.xudrpc.Alert.prototype.setBalanceAlert = function(value) { + jspb.Message.setOneofWrapperField(this, 3, proto.xudrpc.Alert.oneofGroups_[0], value); +}; + + +proto.xudrpc.Alert.prototype.clearBalanceAlert = function() { + this.setBalanceAlert(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {boolean} + */ +proto.xudrpc.Alert.prototype.hasBalanceAlert = function() { + return jspb.Message.getField(this, 3) != null; +}; + + + /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a @@ -781,6 +1031,264 @@ proto.xudrpc.Balance.prototype.setUnconfirmedWalletBalance = function(value) { +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.xudrpc.BalanceAlert = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.xudrpc.BalanceAlert, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.xudrpc.BalanceAlert.displayName = 'proto.xudrpc.BalanceAlert'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.xudrpc.BalanceAlert.prototype.toObject = function(opt_includeInstance) { + return proto.xudrpc.BalanceAlert.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.xudrpc.BalanceAlert} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.BalanceAlert.toObject = function(includeInstance, msg) { + var f, obj = { + totalBalance: jspb.Message.getFieldWithDefault(msg, 1, 0), + side: jspb.Message.getFieldWithDefault(msg, 2, 0), + bound: jspb.Message.getFieldWithDefault(msg, 3, 0), + sideBalance: jspb.Message.getFieldWithDefault(msg, 4, 0), + currency: jspb.Message.getFieldWithDefault(msg, 5, "") + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.xudrpc.BalanceAlert} + */ +proto.xudrpc.BalanceAlert.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.xudrpc.BalanceAlert; + return proto.xudrpc.BalanceAlert.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.xudrpc.BalanceAlert} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.xudrpc.BalanceAlert} + */ +proto.xudrpc.BalanceAlert.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {number} */ (reader.readUint64()); + msg.setTotalBalance(value); + break; + case 2: + var value = /** @type {!proto.xudrpc.BalanceAlert.Side} */ (reader.readEnum()); + msg.setSide(value); + break; + case 3: + var value = /** @type {number} */ (reader.readUint32()); + msg.setBound(value); + break; + case 4: + var value = /** @type {number} */ (reader.readUint64()); + msg.setSideBalance(value); + break; + case 5: + var value = /** @type {string} */ (reader.readString()); + msg.setCurrency(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.xudrpc.BalanceAlert.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.xudrpc.BalanceAlert.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.xudrpc.BalanceAlert} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.BalanceAlert.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getTotalBalance(); + if (f !== 0) { + writer.writeUint64( + 1, + f + ); + } + f = message.getSide(); + if (f !== 0.0) { + writer.writeEnum( + 2, + f + ); + } + f = message.getBound(); + if (f !== 0) { + writer.writeUint32( + 3, + f + ); + } + f = message.getSideBalance(); + if (f !== 0) { + writer.writeUint64( + 4, + f + ); + } + f = message.getCurrency(); + if (f.length > 0) { + writer.writeString( + 5, + f + ); + } +}; + + +/** + * @enum {number} + */ +proto.xudrpc.BalanceAlert.Side = { + REMOTE: 0, + LOCAL: 1 +}; + +/** + * optional uint64 total_balance = 1; + * @return {number} + */ +proto.xudrpc.BalanceAlert.prototype.getTotalBalance = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** @param {number} value */ +proto.xudrpc.BalanceAlert.prototype.setTotalBalance = function(value) { + jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional Side side = 2; + * @return {!proto.xudrpc.BalanceAlert.Side} + */ +proto.xudrpc.BalanceAlert.prototype.getSide = function() { + return /** @type {!proto.xudrpc.BalanceAlert.Side} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** @param {!proto.xudrpc.BalanceAlert.Side} value */ +proto.xudrpc.BalanceAlert.prototype.setSide = function(value) { + jspb.Message.setProto3EnumField(this, 2, value); +}; + + +/** + * optional uint32 bound = 3; + * @return {number} + */ +proto.xudrpc.BalanceAlert.prototype.getBound = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** @param {number} value */ +proto.xudrpc.BalanceAlert.prototype.setBound = function(value) { + jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * optional uint64 side_balance = 4; + * @return {number} + */ +proto.xudrpc.BalanceAlert.prototype.getSideBalance = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** @param {number} value */ +proto.xudrpc.BalanceAlert.prototype.setSideBalance = function(value) { + jspb.Message.setProto3IntField(this, 4, value); +}; + + +/** + * optional string currency = 5; + * @return {string} + */ +proto.xudrpc.BalanceAlert.prototype.getCurrency = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +}; + + +/** @param {string} value */ +proto.xudrpc.BalanceAlert.prototype.setCurrency = function(value) { + jspb.Message.setProto3StringField(this, 5, value); +}; + + + /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a @@ -12537,6 +13045,122 @@ proto.xudrpc.SubscribeOrdersRequest.prototype.setExisting = function(value) { +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.xudrpc.SubscribeAlertsRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.xudrpc.SubscribeAlertsRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.xudrpc.SubscribeAlertsRequest.displayName = 'proto.xudrpc.SubscribeAlertsRequest'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.xudrpc.SubscribeAlertsRequest.prototype.toObject = function(opt_includeInstance) { + return proto.xudrpc.SubscribeAlertsRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.xudrpc.SubscribeAlertsRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.SubscribeAlertsRequest.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.xudrpc.SubscribeAlertsRequest} + */ +proto.xudrpc.SubscribeAlertsRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.xudrpc.SubscribeAlertsRequest; + return proto.xudrpc.SubscribeAlertsRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.xudrpc.SubscribeAlertsRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.xudrpc.SubscribeAlertsRequest} + */ +proto.xudrpc.SubscribeAlertsRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.xudrpc.SubscribeAlertsRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.xudrpc.SubscribeAlertsRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.xudrpc.SubscribeAlertsRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.SubscribeAlertsRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a diff --git a/lib/service/Service.ts b/lib/service/Service.ts index f9ded99a7..87be0d16b 100644 --- a/lib/service/Service.ts +++ b/lib/service/Service.ts @@ -20,6 +20,7 @@ import commitHash from '../Version'; import errors from './errors'; import { NodeIdentifier, ServiceComponents, ServiceOrder, ServiceOrderSidesArrays, ServicePlaceOrderEvent, ServiceTrade, XudInfo } from './types'; import NodeKey from 'lib/nodekey/NodeKey'; +import Alerts from '../alerts/Alerts'; /** Functions to check argument validity and throw [[INVALID_ARGUMENT]] when invalid. */ const argChecks = { @@ -71,6 +72,7 @@ class Service extends EventEmitter { private swaps: Swaps; private logger: Logger; private nodekey: NodeKey; + private alerts: Alerts; /** Create an instance of available RPC methods and bind all exposed functions. */ constructor(components: ServiceComponents) { @@ -83,6 +85,7 @@ class Service extends EventEmitter { this.swaps = components.swaps; this.logger = components.logger; this.nodekey = components.nodeKey; + this.alerts = components.alerts; this.version = components.version; } @@ -704,6 +707,26 @@ class Service extends EventEmitter { const nodePubKey = isNodePubKey(args.nodeIdentifier) ? args.nodeIdentifier : this.pool.resolveAlias(args.nodeIdentifier); return this.pool.discoverNodes(nodePubKey); } + /* + * Subscribe to alerts. + */ + public subscribeAlerts = (callback: (payload: any) => void, cancelled$: Observable) => { + const observables: Observable[] = []; + observables.push(fromEvent(this.alerts, 'alert')); + + const mergedObservable$ = this.getMergedObservable$(observables, cancelled$); + + mergedObservable$.subscribe({ + next: (alert) => { + callback(alert); + }, + error: this.logger.error, + }); + } + + private getMergedObservable$(observables: Observable[], cancelled$: Observable) { + return merge(...observables).pipe(takeUntil(cancelled$)); + } /* * Subscribe to orders being added to the order book. diff --git a/lib/service/types.ts b/lib/service/types.ts index 816e00865..28c005d87 100644 --- a/lib/service/types.ts +++ b/lib/service/types.ts @@ -8,6 +8,7 @@ import Pool from '../p2p/Pool'; import SwapClientManager from '../swaps/SwapClientManager'; import Swaps from '../swaps/Swaps'; import NodeKey from '../nodekey/NodeKey'; +import Alerts from '../alerts/Alerts'; /** * The components required by the API service layer. @@ -21,6 +22,7 @@ export type ServiceComponents = { swaps: Swaps; logger: Logger; nodeKey: NodeKey; + alerts: Alerts; /** The function to be called to shutdown the parent process */ shutdown: () => void; }; diff --git a/lib/swaps/SwapClient.ts b/lib/swaps/SwapClient.ts index a60b22d37..bbc2bf713 100644 --- a/lib/swaps/SwapClient.ts +++ b/lib/swaps/SwapClient.ts @@ -1,5 +1,5 @@ import { EventEmitter } from 'events'; -import { SwapClientType } from '../constants/enums'; +import { ChannelSide, SwapClientType } from '../constants/enums'; import Logger from '../Logger'; import { setTimeoutPromise } from '../utils/utils'; import { CloseChannelParams, OpenChannelParams, Route, SwapCapacities, SwapDeal } from './types'; @@ -223,6 +223,29 @@ abstract class SwapClient extends EventEmitter { } } + protected checkLowBalance = (remoteBalance: number, localBalance: number, totalBalance: number, + alertThreshold: number, currency: string, emit: Function) => { + if (localBalance < alertThreshold) { + emit('lowTradingBalance', { + totalBalance, + currency, + side: ChannelSide.Local, + sideBalance: localBalance, + bound: 10, + }); + } + + if (remoteBalance < alertThreshold) { + emit('lowTradingBalance', { + totalBalance, + currency, + side: ChannelSide.Remote, + sideBalance: remoteBalance, + bound: 10, + }); + } + } + private updateCapacityTimerCallback = async () => { if (this.isConnected()) { await this.updateCapacity(); diff --git a/proto/xudrpc.proto b/proto/xudrpc.proto index c53c746c7..312581bf5 100644 --- a/proto/xudrpc.proto +++ b/proto/xudrpc.proto @@ -285,6 +285,13 @@ service Xud { }; } + /* Subscribes to alerts such as low balance. */ + rpc SubscribeAlerts(SubscribeAlertsRequest) returns (stream Alert) { + option (google.api.http) = { + get: "/v1/subscribealerts" + }; + } + /* Subscribes to orders being added to and removed from the order book. This call allows the client * to maintain an up-to-date view of the order book. For example, an exchange that wants to show * its users a real time view of the orders available to them would subscribe to this streaming @@ -392,6 +399,20 @@ message AddPairRequest { } message AddPairResponse {} +message Alert { + // The type of the alert. + enum AlertType { + LOW_TRADING_BALANCE = 0; + } + AlertType type = 1 [json_name = "type"]; + // The human readable alert message. + string message = 2 [json_name = "message"]; + // The structured payload. + oneof payload { + BalanceAlert balance_alert = 3 [json_name = "balance_alert"]; + } +} + message Balance { // Total balance denominated in satoshis. uint64 total_balance = 1 [json_name = "total_balance"]; @@ -407,6 +428,23 @@ message Balance { uint64 unconfirmed_wallet_balance = 6 [json_name = "unconfirmed_wallet_balance"]; } +message BalanceAlert { + // The total balance. + uint64 total_balance = 1 [json_name = "total_balance"]; + // The side of the low balance. + enum Side { + REMOTE = 0; + LOCAL = 1; + } + Side side = 2 [json_name = "side"]; + // The bound of the low balance in percentage. + uint32 bound = 3 [json_name = "bound"]; + // The current side balance. + uint64 side_balance = 4 [json_name = "side_balance"]; + // The currency of the alert. + string currency = 5 [json_name = "currency"]; +} + message BanRequest { // The node pub key or alias of the node to ban. string node_identifier = 1 [json_name = "node_identifier"]; @@ -851,6 +889,9 @@ message SubscribeOrdersRequest { bool existing = 1 [json_name = "existing"]; } +message SubscribeAlertsRequest { +} + message SubscribeSwapsAcceptedRequest { } message SubscribeSwapsRequest { diff --git a/test/integration/Service.spec.ts b/test/integration/Service.spec.ts index 128511dbc..b1d90c7a8 100644 --- a/test/integration/Service.spec.ts +++ b/test/integration/Service.spec.ts @@ -5,6 +5,9 @@ import p2pErrors from '../../lib/p2p/errors'; import Service from '../../lib/service/Service'; import Xud from '../../lib/Xud'; import { getTempDir } from '../utils'; +import { TestScheduler } from 'rxjs/testing'; +import { Observable } from 'rxjs'; +import { BalanceAlert } from '../../lib/alerts/types'; chai.use(chaiAsPromised); @@ -186,4 +189,38 @@ describe('API Service', () => { }); await expect(shutdownPromise).to.be.fulfilled; }); + + let testScheduler: TestScheduler; + + describe('getMergedObservable$', () => { + beforeEach(() => { + testScheduler = new TestScheduler((actual, expected) => { + expect(actual).to.deep.equal(expected); + }); + }); + + it('should continue without cancelled$', async () => { + testScheduler.run(({ cold, expectObservable }) => { + const firstLowBalanceEvent = cold('-a--b---c---') as Observable; + const secondLowBalanceEvent = cold('--a-b|') as Observable; + const cancelled = cold('-') as Observable; + + const lowBalanceObservables: Observable[] = [firstLowBalanceEvent, secondLowBalanceEvent]; + const finalObservable = service['getMergedObservable$'](lowBalanceObservables, cancelled); + expectObservable(finalObservable).toBe('-aa-(bb)c---'); + }); + }); + + it('should cancelled with cancelled$', async () => { + testScheduler.run(({ cold, expectObservable }) => { + const firstLowBalanceEvent = cold('-a--b---c---') as Observable; + const secondLowBalanceEvent = cold('--a-b|') as Observable; + const cancelled = cold('---a') as Observable; + + const lowBalanceObservables: Observable[] = [firstLowBalanceEvent, secondLowBalanceEvent]; + const finalObservable = service['getMergedObservable$'](lowBalanceObservables, cancelled); + expectObservable(finalObservable).toBe('-aa|'); + }); + }); + }); }); diff --git a/test/jest/LndClient.spec.ts b/test/jest/LndClient.spec.ts index c2aee5fa7..a7912e162 100644 --- a/test/jest/LndClient.spec.ts +++ b/test/jest/LndClient.spec.ts @@ -2,7 +2,7 @@ import LndClient from '../../lib/lndclient/LndClient'; import { LndClientConfig } from '../../lib/lndclient/types'; import Logger from '../../lib/Logger'; import { getValidDeal } from '../utils'; -import { SwapRole } from '../../lib/constants/enums'; +import { ChannelSide, SwapRole } from '../../lib/constants/enums'; import { ClientStatus } from '../../lib/swaps/SwapClient'; const openChannelSyncResponse = { @@ -282,4 +282,161 @@ describe('LndClient', () => { expect(lnd['maxChannelInboundAmount']).toEqual(295); }); }); + + describe('checkLowBalance', () => { + test('emits lowTradingBalance on local balance is less than alert threshold of total balance ', async () => { + const emit = jest.fn().mockImplementation(); + const totalBalance = 120; + const localBalance = 10; + const alertThreshold = totalBalance * 0.1; + const remoteBalance = 110; + + const currency = 'BTC'; + lnd['checkLowBalance']( + remoteBalance, + localBalance, + totalBalance, + alertThreshold, + currency, + emit, + ); + + expect(emit).toHaveBeenCalledTimes(1); + expect(emit).toHaveBeenCalledWith('lowTradingBalance', { + totalBalance, + currency, + side: ChannelSide.Local, + sideBalance: localBalance, + bound: 10, + }); + }); + test('emits lowBalance on local balance is less than alert threshold of total balance ', async () => { + const emit = jest.fn().mockImplementation(); + const totalBalance = 120; + const localBalance = 10; + const alertThreshold = totalBalance * 0.1; + const remoteBalance = 110; + + const currency = 'BTC'; + lnd['checkLowBalance']( + remoteBalance, + localBalance, + totalBalance, + alertThreshold, + currency, + emit, + ); + + expect(emit).toHaveBeenCalledTimes(1); + expect(emit).toHaveBeenCalledWith('lowTradingBalance', { + totalBalance, + currency, + side: ChannelSide.Local, + sideBalance: localBalance, + bound: 10, + }); + }); + test('dont emit on local balance equals alert threshold of total balance ', async () => { + const emit = jest.fn().mockImplementation(); + const totalBalance = 120; + const localBalance = 12; + const alertThreshold = totalBalance * 0.1; + const remoteBalance = 110; + + const currency = 'BTC'; + lnd['checkLowBalance']( + remoteBalance, + localBalance, + totalBalance, + alertThreshold, + currency, + emit, + ); + + expect(emit).toHaveBeenCalledTimes(0); + }); + test('dont emit on local balance is higher than alert threshold of total balance ', async () => { + const emit = jest.fn().mockImplementation(); + const totalBalance = 120; + const localBalance = 12.5; + const alertThreshold = totalBalance * 0.1; + const remoteBalance = 110; + + const currency = 'BTC'; + lnd['checkLowBalance']( + remoteBalance, + localBalance, + totalBalance, + alertThreshold, + currency, + emit, + ); + + expect(emit).toHaveBeenCalledTimes(0); + }); + test('emits on remote balance is less than alert threshold of total balance ', async () => { + const emit = jest.fn().mockImplementation(); + const totalBalance = 120; + const localBalance = 110; + const alertThreshold = totalBalance * 0.1; + const remoteBalance = 10; + + const currency = 'BTC'; + lnd['checkLowBalance']( + remoteBalance, + localBalance, + totalBalance, + alertThreshold, + currency, + emit, + ); + + expect(emit).toHaveBeenCalledTimes(1); + expect(emit).toHaveBeenCalledWith('lowTradingBalance', { + totalBalance, + currency, + side: ChannelSide.Remote, + sideBalance: remoteBalance, + bound: 10, + }); + }); + test('dont emit on remote balance equals alert threshold of total balance ', async () => { + const emit = jest.fn().mockImplementation(); + const totalBalance = 120; + const localBalance = 110; + const alertThreshold = totalBalance * 0.1; + const remoteBalance = 12; + + const currency = 'BTC'; + lnd['checkLowBalance']( + remoteBalance, + localBalance, + totalBalance, + alertThreshold, + currency, + emit, + ); + + expect(emit).toHaveBeenCalledTimes(0); + }); + test('dont emit on remote balance is higher than alert threshold of total balance ', async () => { + const emit = jest.fn().mockImplementation(); + const totalBalance = 120; + const localBalance = 110; + const alertThreshold = totalBalance * 0.1; + const remoteBalance = 12.5; + + const currency = 'BTC'; + lnd['checkLowBalance']( + remoteBalance, + localBalance, + totalBalance, + alertThreshold, + currency, + emit, + ); + + expect(emit).toHaveBeenCalledTimes(0); + }); + }); }); diff --git a/test/jest/Orderbook.spec.ts b/test/jest/Orderbook.spec.ts index 6db0e0cf2..3a3e65f72 100644 --- a/test/jest/Orderbook.spec.ts +++ b/test/jest/Orderbook.spec.ts @@ -126,6 +126,7 @@ const loggers = { swaps: logger, http: logger, service: logger, + alerts: logger, }; const localId = '97945230-8144-11e9-beb7-49ba94e5bd74'; diff --git a/test/jest/Service.spec.ts b/test/jest/Service.spec.ts index 298ee3a65..58b832576 100644 --- a/test/jest/Service.spec.ts +++ b/test/jest/Service.spec.ts @@ -9,6 +9,7 @@ import SwapClient from '../../lib/swaps/SwapClient'; import SwapClientManager from '../../lib/swaps/SwapClientManager'; import Swaps from '../../lib/swaps/Swaps'; import NodeKey from '../../lib/nodekey/NodeKey'; +import Alerts from '../../lib/alerts/Alerts'; jest.mock('../../lib/nodekey/NodeKey'); const mockedNodeKey = >NodeKey; @@ -16,6 +17,8 @@ jest.mock('../../lib/orderbook/OrderBook'); const mockedOrderbook = >Orderbook; jest.mock('../../lib/swaps/Swaps'); const mockedSwaps = >Swaps; +jest.mock('../../lib/alerts/Alerts'); +const mockedAlerts = >Alerts; jest.mock('../../lib/swaps/SwapClientManager', () => { return jest.fn().mockImplementation(() => { return { @@ -67,6 +70,7 @@ describe('Service', () => { shutdown: jest.fn(), nodeKey: new mockedNodeKey(), logger: new mockedLogger(), + alerts: new mockedAlerts(), }; peer = new mockedPeer(); components.pool.getPeer = jest.fn().mockReturnValue(peer); diff --git a/test/jest/SwapClientManager.spec.ts b/test/jest/SwapClientManager.spec.ts index 9e9e2f4d8..d6686d116 100644 --- a/test/jest/SwapClientManager.spec.ts +++ b/test/jest/SwapClientManager.spec.ts @@ -67,6 +67,7 @@ const loggers = { swaps: logger, http: logger, service: logger, + alerts: logger, }; describe('Swaps.SwapClientManager', () => { diff --git a/test/simulation/xudrpc/xudrpc.pb.go b/test/simulation/xudrpc/xudrpc.pb.go index 2c4caacab..8846dfc34 100644 --- a/test/simulation/xudrpc/xudrpc.pb.go +++ b/test/simulation/xudrpc/xudrpc.pb.go @@ -119,6 +119,55 @@ func (LogLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor_6960a02cc0a63cf6, []int{2} } +// The type of the alert. +type Alert_AlertType int32 + +const ( + Alert_LOW_TRADING_BALANCE Alert_AlertType = 0 +) + +var Alert_AlertType_name = map[int32]string{ + 0: "LOW_TRADING_BALANCE", +} + +var Alert_AlertType_value = map[string]int32{ + "LOW_TRADING_BALANCE": 0, +} + +func (x Alert_AlertType) String() string { + return proto.EnumName(Alert_AlertType_name, int32(x)) +} + +func (Alert_AlertType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{3, 0} +} + +// The side of the low balance. +type BalanceAlert_Side int32 + +const ( + BalanceAlert_REMOTE BalanceAlert_Side = 0 + BalanceAlert_LOCAL BalanceAlert_Side = 1 +) + +var BalanceAlert_Side_name = map[int32]string{ + 0: "REMOTE", + 1: "LOCAL", +} + +var BalanceAlert_Side_value = map[string]int32{ + "REMOTE": 0, + "LOCAL": 1, +} + +func (x BalanceAlert_Side) String() string { + return proto.EnumName(BalanceAlert_Side_name, int32(x)) +} + +func (BalanceAlert_Side) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{5, 0} +} + type Currency_SwapClient int32 const ( @@ -141,7 +190,7 @@ func (x Currency_SwapClient) String() string { } func (Currency_SwapClient) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{16, 0} + return fileDescriptor_6960a02cc0a63cf6, []int{18, 0} } type ListOrdersRequest_Owner int32 @@ -169,7 +218,7 @@ func (x ListOrdersRequest_Owner) String() string { } func (ListOrdersRequest_Owner) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{32, 0} + return fileDescriptor_6960a02cc0a63cf6, []int{34, 0} } type AddCurrencyResponse struct { @@ -283,6 +332,90 @@ func (m *AddPairResponse) XXX_DiscardUnknown() { var xxx_messageInfo_AddPairResponse proto.InternalMessageInfo +type Alert struct { + Type Alert_AlertType `protobuf:"varint,1,opt,name=type,proto3,enum=xudrpc.Alert_AlertType" json:"type,omitempty"` + // The human readable alert message. + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + // The structured payload. + // + // Types that are valid to be assigned to Payload: + // *Alert_BalanceAlert + Payload isAlert_Payload `protobuf_oneof:"payload"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Alert) Reset() { *m = Alert{} } +func (m *Alert) String() string { return proto.CompactTextString(m) } +func (*Alert) ProtoMessage() {} +func (*Alert) Descriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{3} +} + +func (m *Alert) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Alert.Unmarshal(m, b) +} +func (m *Alert) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Alert.Marshal(b, m, deterministic) +} +func (m *Alert) XXX_Merge(src proto.Message) { + xxx_messageInfo_Alert.Merge(m, src) +} +func (m *Alert) XXX_Size() int { + return xxx_messageInfo_Alert.Size(m) +} +func (m *Alert) XXX_DiscardUnknown() { + xxx_messageInfo_Alert.DiscardUnknown(m) +} + +var xxx_messageInfo_Alert proto.InternalMessageInfo + +func (m *Alert) GetType() Alert_AlertType { + if m != nil { + return m.Type + } + return Alert_LOW_TRADING_BALANCE +} + +func (m *Alert) GetMessage() string { + if m != nil { + return m.Message + } + return "" +} + +type isAlert_Payload interface { + isAlert_Payload() +} + +type Alert_BalanceAlert struct { + BalanceAlert *BalanceAlert `protobuf:"bytes,3,opt,name=balance_alert,proto3,oneof"` +} + +func (*Alert_BalanceAlert) isAlert_Payload() {} + +func (m *Alert) GetPayload() isAlert_Payload { + if m != nil { + return m.Payload + } + return nil +} + +func (m *Alert) GetBalanceAlert() *BalanceAlert { + if x, ok := m.GetPayload().(*Alert_BalanceAlert); ok { + return x.BalanceAlert + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*Alert) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*Alert_BalanceAlert)(nil), + } +} + type Balance struct { // Total balance denominated in satoshis. TotalBalance uint64 `protobuf:"varint,1,opt,name=total_balance,proto3" json:"total_balance,omitempty"` @@ -305,7 +438,7 @@ func (m *Balance) Reset() { *m = Balance{} } func (m *Balance) String() string { return proto.CompactTextString(m) } func (*Balance) ProtoMessage() {} func (*Balance) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{3} + return fileDescriptor_6960a02cc0a63cf6, []int{4} } func (m *Balance) XXX_Unmarshal(b []byte) error { @@ -368,6 +501,81 @@ func (m *Balance) GetUnconfirmedWalletBalance() uint64 { return 0 } +type BalanceAlert struct { + // The total balance. + TotalBalance uint64 `protobuf:"varint,1,opt,name=total_balance,proto3" json:"total_balance,omitempty"` + Side BalanceAlert_Side `protobuf:"varint,2,opt,name=side,proto3,enum=xudrpc.BalanceAlert_Side" json:"side,omitempty"` + // The bound of the low balance in percentage. + Bound uint32 `protobuf:"varint,3,opt,name=bound,proto3" json:"bound,omitempty"` + // The current side balance. + SideBalance uint64 `protobuf:"varint,4,opt,name=side_balance,proto3" json:"side_balance,omitempty"` + // The currency of the alert. + Currency string `protobuf:"bytes,5,opt,name=currency,proto3" json:"currency,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BalanceAlert) Reset() { *m = BalanceAlert{} } +func (m *BalanceAlert) String() string { return proto.CompactTextString(m) } +func (*BalanceAlert) ProtoMessage() {} +func (*BalanceAlert) Descriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{5} +} + +func (m *BalanceAlert) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BalanceAlert.Unmarshal(m, b) +} +func (m *BalanceAlert) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BalanceAlert.Marshal(b, m, deterministic) +} +func (m *BalanceAlert) XXX_Merge(src proto.Message) { + xxx_messageInfo_BalanceAlert.Merge(m, src) +} +func (m *BalanceAlert) XXX_Size() int { + return xxx_messageInfo_BalanceAlert.Size(m) +} +func (m *BalanceAlert) XXX_DiscardUnknown() { + xxx_messageInfo_BalanceAlert.DiscardUnknown(m) +} + +var xxx_messageInfo_BalanceAlert proto.InternalMessageInfo + +func (m *BalanceAlert) GetTotalBalance() uint64 { + if m != nil { + return m.TotalBalance + } + return 0 +} + +func (m *BalanceAlert) GetSide() BalanceAlert_Side { + if m != nil { + return m.Side + } + return BalanceAlert_REMOTE +} + +func (m *BalanceAlert) GetBound() uint32 { + if m != nil { + return m.Bound + } + return 0 +} + +func (m *BalanceAlert) GetSideBalance() uint64 { + if m != nil { + return m.SideBalance + } + return 0 +} + +func (m *BalanceAlert) GetCurrency() string { + if m != nil { + return m.Currency + } + return "" +} + type BanRequest struct { // The node pub key or alias of the node to ban. NodeIdentifier string `protobuf:"bytes,1,opt,name=node_identifier,proto3" json:"node_identifier,omitempty"` @@ -380,7 +588,7 @@ func (m *BanRequest) Reset() { *m = BanRequest{} } func (m *BanRequest) String() string { return proto.CompactTextString(m) } func (*BanRequest) ProtoMessage() {} func (*BanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{4} + return fileDescriptor_6960a02cc0a63cf6, []int{6} } func (m *BanRequest) XXX_Unmarshal(b []byte) error { @@ -418,7 +626,7 @@ func (m *BanResponse) Reset() { *m = BanResponse{} } func (m *BanResponse) String() string { return proto.CompactTextString(m) } func (*BanResponse) ProtoMessage() {} func (*BanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{5} + return fileDescriptor_6960a02cc0a63cf6, []int{7} } func (m *BanResponse) XXX_Unmarshal(b []byte) error { @@ -453,7 +661,7 @@ func (m *Chain) Reset() { *m = Chain{} } func (m *Chain) String() string { return proto.CompactTextString(m) } func (*Chain) ProtoMessage() {} func (*Chain) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{6} + return fileDescriptor_6960a02cc0a63cf6, []int{8} } func (m *Chain) XXX_Unmarshal(b []byte) error { @@ -506,7 +714,7 @@ func (m *Channels) Reset() { *m = Channels{} } func (m *Channels) String() string { return proto.CompactTextString(m) } func (*Channels) ProtoMessage() {} func (*Channels) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{7} + return fileDescriptor_6960a02cc0a63cf6, []int{9} } func (m *Channels) XXX_Unmarshal(b []byte) error { @@ -567,7 +775,7 @@ func (m *ChangePasswordRequest) Reset() { *m = ChangePasswordRequest{} } func (m *ChangePasswordRequest) String() string { return proto.CompactTextString(m) } func (*ChangePasswordRequest) ProtoMessage() {} func (*ChangePasswordRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{8} + return fileDescriptor_6960a02cc0a63cf6, []int{10} } func (m *ChangePasswordRequest) XXX_Unmarshal(b []byte) error { @@ -612,7 +820,7 @@ func (m *ChangePasswordResponse) Reset() { *m = ChangePasswordResponse{} func (m *ChangePasswordResponse) String() string { return proto.CompactTextString(m) } func (*ChangePasswordResponse) ProtoMessage() {} func (*ChangePasswordResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{9} + return fileDescriptor_6960a02cc0a63cf6, []int{11} } func (m *ChangePasswordResponse) XXX_Unmarshal(b []byte) error { @@ -658,7 +866,7 @@ func (m *CloseChannelRequest) Reset() { *m = CloseChannelRequest{} } func (m *CloseChannelRequest) String() string { return proto.CompactTextString(m) } func (*CloseChannelRequest) ProtoMessage() {} func (*CloseChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{10} + return fileDescriptor_6960a02cc0a63cf6, []int{12} } func (m *CloseChannelRequest) XXX_Unmarshal(b []byte) error { @@ -733,7 +941,7 @@ func (m *CloseChannelResponse) Reset() { *m = CloseChannelResponse{} } func (m *CloseChannelResponse) String() string { return proto.CompactTextString(m) } func (*CloseChannelResponse) ProtoMessage() {} func (*CloseChannelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{11} + return fileDescriptor_6960a02cc0a63cf6, []int{13} } func (m *CloseChannelResponse) XXX_Unmarshal(b []byte) error { @@ -773,7 +981,7 @@ func (m *ConnectRequest) Reset() { *m = ConnectRequest{} } func (m *ConnectRequest) String() string { return proto.CompactTextString(m) } func (*ConnectRequest) ProtoMessage() {} func (*ConnectRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{12} + return fileDescriptor_6960a02cc0a63cf6, []int{14} } func (m *ConnectRequest) XXX_Unmarshal(b []byte) error { @@ -811,7 +1019,7 @@ func (m *ConnectResponse) Reset() { *m = ConnectResponse{} } func (m *ConnectResponse) String() string { return proto.CompactTextString(m) } func (*ConnectResponse) ProtoMessage() {} func (*ConnectResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{13} + return fileDescriptor_6960a02cc0a63cf6, []int{15} } func (m *ConnectResponse) XXX_Unmarshal(b []byte) error { @@ -845,7 +1053,7 @@ func (m *CreateNodeRequest) Reset() { *m = CreateNodeRequest{} } func (m *CreateNodeRequest) String() string { return proto.CompactTextString(m) } func (*CreateNodeRequest) ProtoMessage() {} func (*CreateNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{14} + return fileDescriptor_6960a02cc0a63cf6, []int{16} } func (m *CreateNodeRequest) XXX_Unmarshal(b []byte) error { @@ -889,7 +1097,7 @@ func (m *CreateNodeResponse) Reset() { *m = CreateNodeResponse{} } func (m *CreateNodeResponse) String() string { return proto.CompactTextString(m) } func (*CreateNodeResponse) ProtoMessage() {} func (*CreateNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{15} + return fileDescriptor_6960a02cc0a63cf6, []int{17} } func (m *CreateNodeResponse) XXX_Unmarshal(b []byte) error { @@ -953,7 +1161,7 @@ func (m *Currency) Reset() { *m = Currency{} } func (m *Currency) String() string { return proto.CompactTextString(m) } func (*Currency) ProtoMessage() {} func (*Currency) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{16} + return fileDescriptor_6960a02cc0a63cf6, []int{18} } func (m *Currency) XXX_Unmarshal(b []byte) error { @@ -1014,7 +1222,7 @@ func (m *DepositRequest) Reset() { *m = DepositRequest{} } func (m *DepositRequest) String() string { return proto.CompactTextString(m) } func (*DepositRequest) ProtoMessage() {} func (*DepositRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{17} + return fileDescriptor_6960a02cc0a63cf6, []int{19} } func (m *DepositRequest) XXX_Unmarshal(b []byte) error { @@ -1054,7 +1262,7 @@ func (m *DepositResponse) Reset() { *m = DepositResponse{} } func (m *DepositResponse) String() string { return proto.CompactTextString(m) } func (*DepositResponse) ProtoMessage() {} func (*DepositResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{18} + return fileDescriptor_6960a02cc0a63cf6, []int{20} } func (m *DepositResponse) XXX_Unmarshal(b []byte) error { @@ -1094,7 +1302,7 @@ func (m *DiscoverNodesRequest) Reset() { *m = DiscoverNodesRequest{} } func (m *DiscoverNodesRequest) String() string { return proto.CompactTextString(m) } func (*DiscoverNodesRequest) ProtoMessage() {} func (*DiscoverNodesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{19} + return fileDescriptor_6960a02cc0a63cf6, []int{21} } func (m *DiscoverNodesRequest) XXX_Unmarshal(b []byte) error { @@ -1133,7 +1341,7 @@ func (m *DiscoverNodesResponse) Reset() { *m = DiscoverNodesResponse{} } func (m *DiscoverNodesResponse) String() string { return proto.CompactTextString(m) } func (*DiscoverNodesResponse) ProtoMessage() {} func (*DiscoverNodesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{20} + return fileDescriptor_6960a02cc0a63cf6, []int{22} } func (m *DiscoverNodesResponse) XXX_Unmarshal(b []byte) error { @@ -1179,7 +1387,7 @@ func (m *ExecuteSwapRequest) Reset() { *m = ExecuteSwapRequest{} } func (m *ExecuteSwapRequest) String() string { return proto.CompactTextString(m) } func (*ExecuteSwapRequest) ProtoMessage() {} func (*ExecuteSwapRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{21} + return fileDescriptor_6960a02cc0a63cf6, []int{23} } func (m *ExecuteSwapRequest) XXX_Unmarshal(b []byte) error { @@ -1241,7 +1449,7 @@ func (m *GetBalanceRequest) Reset() { *m = GetBalanceRequest{} } func (m *GetBalanceRequest) String() string { return proto.CompactTextString(m) } func (*GetBalanceRequest) ProtoMessage() {} func (*GetBalanceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{22} + return fileDescriptor_6960a02cc0a63cf6, []int{24} } func (m *GetBalanceRequest) XXX_Unmarshal(b []byte) error { @@ -1281,7 +1489,7 @@ func (m *GetBalanceResponse) Reset() { *m = GetBalanceResponse{} } func (m *GetBalanceResponse) String() string { return proto.CompactTextString(m) } func (*GetBalanceResponse) ProtoMessage() {} func (*GetBalanceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{23} + return fileDescriptor_6960a02cc0a63cf6, []int{25} } func (m *GetBalanceResponse) XXX_Unmarshal(b []byte) error { @@ -1319,7 +1527,7 @@ func (m *GetInfoRequest) Reset() { *m = GetInfoRequest{} } func (m *GetInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetInfoRequest) ProtoMessage() {} func (*GetInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{24} + return fileDescriptor_6960a02cc0a63cf6, []int{26} } func (m *GetInfoRequest) XXX_Unmarshal(b []byte) error { @@ -1369,7 +1577,7 @@ func (m *GetInfoResponse) Reset() { *m = GetInfoResponse{} } func (m *GetInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetInfoResponse) ProtoMessage() {} func (*GetInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{25} + return fileDescriptor_6960a02cc0a63cf6, []int{27} } func (m *GetInfoResponse) XXX_Unmarshal(b []byte) error { @@ -1477,7 +1685,7 @@ func (m *GetMnemonicRequest) Reset() { *m = GetMnemonicRequest{} } func (m *GetMnemonicRequest) String() string { return proto.CompactTextString(m) } func (*GetMnemonicRequest) ProtoMessage() {} func (*GetMnemonicRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{26} + return fileDescriptor_6960a02cc0a63cf6, []int{28} } func (m *GetMnemonicRequest) XXX_Unmarshal(b []byte) error { @@ -1509,7 +1717,7 @@ func (m *GetMnemonicResponse) Reset() { *m = GetMnemonicResponse{} } func (m *GetMnemonicResponse) String() string { return proto.CompactTextString(m) } func (*GetMnemonicResponse) ProtoMessage() {} func (*GetMnemonicResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{27} + return fileDescriptor_6960a02cc0a63cf6, []int{29} } func (m *GetMnemonicResponse) XXX_Unmarshal(b []byte) error { @@ -1549,7 +1757,7 @@ func (m *GetNodeInfoRequest) Reset() { *m = GetNodeInfoRequest{} } func (m *GetNodeInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetNodeInfoRequest) ProtoMessage() {} func (*GetNodeInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{28} + return fileDescriptor_6960a02cc0a63cf6, []int{30} } func (m *GetNodeInfoRequest) XXX_Unmarshal(b []byte) error { @@ -1592,7 +1800,7 @@ func (m *GetNodeInfoResponse) Reset() { *m = GetNodeInfoResponse{} } func (m *GetNodeInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetNodeInfoResponse) ProtoMessage() {} func (*GetNodeInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{29} + return fileDescriptor_6960a02cc0a63cf6, []int{31} } func (m *GetNodeInfoResponse) XXX_Unmarshal(b []byte) error { @@ -1637,7 +1845,7 @@ func (m *ListCurrenciesRequest) Reset() { *m = ListCurrenciesRequest{} } func (m *ListCurrenciesRequest) String() string { return proto.CompactTextString(m) } func (*ListCurrenciesRequest) ProtoMessage() {} func (*ListCurrenciesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{30} + return fileDescriptor_6960a02cc0a63cf6, []int{32} } func (m *ListCurrenciesRequest) XXX_Unmarshal(b []byte) error { @@ -1670,7 +1878,7 @@ func (m *ListCurrenciesResponse) Reset() { *m = ListCurrenciesResponse{} func (m *ListCurrenciesResponse) String() string { return proto.CompactTextString(m) } func (*ListCurrenciesResponse) ProtoMessage() {} func (*ListCurrenciesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{31} + return fileDescriptor_6960a02cc0a63cf6, []int{33} } func (m *ListCurrenciesResponse) XXX_Unmarshal(b []byte) error { @@ -1716,7 +1924,7 @@ func (m *ListOrdersRequest) Reset() { *m = ListOrdersRequest{} } func (m *ListOrdersRequest) String() string { return proto.CompactTextString(m) } func (*ListOrdersRequest) ProtoMessage() {} func (*ListOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{32} + return fileDescriptor_6960a02cc0a63cf6, []int{34} } func (m *ListOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -1777,7 +1985,7 @@ func (m *ListOrdersResponse) Reset() { *m = ListOrdersResponse{} } func (m *ListOrdersResponse) String() string { return proto.CompactTextString(m) } func (*ListOrdersResponse) ProtoMessage() {} func (*ListOrdersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{33} + return fileDescriptor_6960a02cc0a63cf6, []int{35} } func (m *ListOrdersResponse) XXX_Unmarshal(b []byte) error { @@ -1815,7 +2023,7 @@ func (m *ListPairsRequest) Reset() { *m = ListPairsRequest{} } func (m *ListPairsRequest) String() string { return proto.CompactTextString(m) } func (*ListPairsRequest) ProtoMessage() {} func (*ListPairsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{34} + return fileDescriptor_6960a02cc0a63cf6, []int{36} } func (m *ListPairsRequest) XXX_Unmarshal(b []byte) error { @@ -1848,7 +2056,7 @@ func (m *ListPairsResponse) Reset() { *m = ListPairsResponse{} } func (m *ListPairsResponse) String() string { return proto.CompactTextString(m) } func (*ListPairsResponse) ProtoMessage() {} func (*ListPairsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{35} + return fileDescriptor_6960a02cc0a63cf6, []int{37} } func (m *ListPairsResponse) XXX_Unmarshal(b []byte) error { @@ -1886,7 +2094,7 @@ func (m *ListPeersRequest) Reset() { *m = ListPeersRequest{} } func (m *ListPeersRequest) String() string { return proto.CompactTextString(m) } func (*ListPeersRequest) ProtoMessage() {} func (*ListPeersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{36} + return fileDescriptor_6960a02cc0a63cf6, []int{38} } func (m *ListPeersRequest) XXX_Unmarshal(b []byte) error { @@ -1919,7 +2127,7 @@ func (m *ListPeersResponse) Reset() { *m = ListPeersResponse{} } func (m *ListPeersResponse) String() string { return proto.CompactTextString(m) } func (*ListPeersResponse) ProtoMessage() {} func (*ListPeersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{37} + return fileDescriptor_6960a02cc0a63cf6, []int{39} } func (m *ListPeersResponse) XXX_Unmarshal(b []byte) error { @@ -1964,7 +2172,7 @@ func (m *LndInfo) Reset() { *m = LndInfo{} } func (m *LndInfo) String() string { return proto.CompactTextString(m) } func (*LndInfo) ProtoMessage() {} func (*LndInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{38} + return fileDescriptor_6960a02cc0a63cf6, []int{40} } func (m *LndInfo) XXX_Unmarshal(b []byte) error { @@ -2048,7 +2256,7 @@ func (m *NodeIdentifier) Reset() { *m = NodeIdentifier{} } func (m *NodeIdentifier) String() string { return proto.CompactTextString(m) } func (*NodeIdentifier) ProtoMessage() {} func (*NodeIdentifier) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{39} + return fileDescriptor_6960a02cc0a63cf6, []int{41} } func (m *NodeIdentifier) XXX_Unmarshal(b []byte) error { @@ -2103,7 +2311,7 @@ func (m *OpenChannelRequest) Reset() { *m = OpenChannelRequest{} } func (m *OpenChannelRequest) String() string { return proto.CompactTextString(m) } func (*OpenChannelRequest) ProtoMessage() {} func (*OpenChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{40} + return fileDescriptor_6960a02cc0a63cf6, []int{42} } func (m *OpenChannelRequest) XXX_Unmarshal(b []byte) error { @@ -2171,7 +2379,7 @@ func (m *OpenChannelResponse) Reset() { *m = OpenChannelResponse{} } func (m *OpenChannelResponse) String() string { return proto.CompactTextString(m) } func (*OpenChannelResponse) ProtoMessage() {} func (*OpenChannelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{41} + return fileDescriptor_6960a02cc0a63cf6, []int{43} } func (m *OpenChannelResponse) XXX_Unmarshal(b []byte) error { @@ -2229,7 +2437,7 @@ func (m *Order) Reset() { *m = Order{} } func (m *Order) String() string { return proto.CompactTextString(m) } func (*Order) ProtoMessage() {} func (*Order) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{42} + return fileDescriptor_6960a02cc0a63cf6, []int{44} } func (m *Order) XXX_Unmarshal(b []byte) error { @@ -2340,7 +2548,7 @@ func (m *OrderRemoval) Reset() { *m = OrderRemoval{} } func (m *OrderRemoval) String() string { return proto.CompactTextString(m) } func (*OrderRemoval) ProtoMessage() {} func (*OrderRemoval) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{43} + return fileDescriptor_6960a02cc0a63cf6, []int{45} } func (m *OrderRemoval) XXX_Unmarshal(b []byte) error { @@ -2410,7 +2618,7 @@ func (m *Orders) Reset() { *m = Orders{} } func (m *Orders) String() string { return proto.CompactTextString(m) } func (*Orders) ProtoMessage() {} func (*Orders) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{44} + return fileDescriptor_6960a02cc0a63cf6, []int{46} } func (m *Orders) XXX_Unmarshal(b []byte) error { @@ -2459,7 +2667,7 @@ func (m *OrdersCount) Reset() { *m = OrdersCount{} } func (m *OrdersCount) String() string { return proto.CompactTextString(m) } func (*OrdersCount) ProtoMessage() {} func (*OrdersCount) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{45} + return fileDescriptor_6960a02cc0a63cf6, []int{47} } func (m *OrdersCount) XXX_Unmarshal(b []byte) error { @@ -2508,7 +2716,7 @@ func (m *OrderUpdate) Reset() { *m = OrderUpdate{} } func (m *OrderUpdate) String() string { return proto.CompactTextString(m) } func (*OrderUpdate) ProtoMessage() {} func (*OrderUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{46} + return fileDescriptor_6960a02cc0a63cf6, []int{48} } func (m *OrderUpdate) XXX_Unmarshal(b []byte) error { @@ -2600,7 +2808,7 @@ func (m *Peer) Reset() { *m = Peer{} } func (m *Peer) String() string { return proto.CompactTextString(m) } func (*Peer) ProtoMessage() {} func (*Peer) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{47} + return fileDescriptor_6960a02cc0a63cf6, []int{49} } func (m *Peer) XXX_Unmarshal(b []byte) error { @@ -2702,7 +2910,7 @@ func (m *PlaceOrderRequest) Reset() { *m = PlaceOrderRequest{} } func (m *PlaceOrderRequest) String() string { return proto.CompactTextString(m) } func (*PlaceOrderRequest) ProtoMessage() {} func (*PlaceOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{48} + return fileDescriptor_6960a02cc0a63cf6, []int{50} } func (m *PlaceOrderRequest) XXX_Unmarshal(b []byte) error { @@ -2790,7 +2998,7 @@ func (m *PlaceOrderResponse) Reset() { *m = PlaceOrderResponse{} } func (m *PlaceOrderResponse) String() string { return proto.CompactTextString(m) } func (*PlaceOrderResponse) ProtoMessage() {} func (*PlaceOrderResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{49} + return fileDescriptor_6960a02cc0a63cf6, []int{51} } func (m *PlaceOrderResponse) XXX_Unmarshal(b []byte) error { @@ -2855,7 +3063,7 @@ func (m *PlaceOrderEvent) Reset() { *m = PlaceOrderEvent{} } func (m *PlaceOrderEvent) String() string { return proto.CompactTextString(m) } func (*PlaceOrderEvent) ProtoMessage() {} func (*PlaceOrderEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{50} + return fileDescriptor_6960a02cc0a63cf6, []int{52} } func (m *PlaceOrderEvent) XXX_Unmarshal(b []byte) error { @@ -2963,7 +3171,7 @@ func (m *ConnextInfo) Reset() { *m = ConnextInfo{} } func (m *ConnextInfo) String() string { return proto.CompactTextString(m) } func (*ConnextInfo) ProtoMessage() {} func (*ConnextInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{51} + return fileDescriptor_6960a02cc0a63cf6, []int{53} } func (m *ConnextInfo) XXX_Unmarshal(b []byte) error { @@ -3024,7 +3232,7 @@ func (m *RemoveCurrencyRequest) Reset() { *m = RemoveCurrencyRequest{} } func (m *RemoveCurrencyRequest) String() string { return proto.CompactTextString(m) } func (*RemoveCurrencyRequest) ProtoMessage() {} func (*RemoveCurrencyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{52} + return fileDescriptor_6960a02cc0a63cf6, []int{54} } func (m *RemoveCurrencyRequest) XXX_Unmarshal(b []byte) error { @@ -3062,7 +3270,7 @@ func (m *RemoveCurrencyResponse) Reset() { *m = RemoveCurrencyResponse{} func (m *RemoveCurrencyResponse) String() string { return proto.CompactTextString(m) } func (*RemoveCurrencyResponse) ProtoMessage() {} func (*RemoveCurrencyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{53} + return fileDescriptor_6960a02cc0a63cf6, []int{55} } func (m *RemoveCurrencyResponse) XXX_Unmarshal(b []byte) error { @@ -3098,7 +3306,7 @@ func (m *RemoveOrderRequest) Reset() { *m = RemoveOrderRequest{} } func (m *RemoveOrderRequest) String() string { return proto.CompactTextString(m) } func (*RemoveOrderRequest) ProtoMessage() {} func (*RemoveOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{54} + return fileDescriptor_6960a02cc0a63cf6, []int{56} } func (m *RemoveOrderRequest) XXX_Unmarshal(b []byte) error { @@ -3152,7 +3360,7 @@ func (m *RemoveOrderResponse) Reset() { *m = RemoveOrderResponse{} } func (m *RemoveOrderResponse) String() string { return proto.CompactTextString(m) } func (*RemoveOrderResponse) ProtoMessage() {} func (*RemoveOrderResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{55} + return fileDescriptor_6960a02cc0a63cf6, []int{57} } func (m *RemoveOrderResponse) XXX_Unmarshal(b []byte) error { @@ -3211,7 +3419,7 @@ func (m *RemoveAllOrdersRequest) Reset() { *m = RemoveAllOrdersRequest{} func (m *RemoveAllOrdersRequest) String() string { return proto.CompactTextString(m) } func (*RemoveAllOrdersRequest) ProtoMessage() {} func (*RemoveAllOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{56} + return fileDescriptor_6960a02cc0a63cf6, []int{58} } func (m *RemoveAllOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -3246,7 +3454,7 @@ func (m *RemoveAllOrdersResponse) Reset() { *m = RemoveAllOrdersResponse func (m *RemoveAllOrdersResponse) String() string { return proto.CompactTextString(m) } func (*RemoveAllOrdersResponse) ProtoMessage() {} func (*RemoveAllOrdersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{57} + return fileDescriptor_6960a02cc0a63cf6, []int{59} } func (m *RemoveAllOrdersResponse) XXX_Unmarshal(b []byte) error { @@ -3293,7 +3501,7 @@ func (m *RemovePairRequest) Reset() { *m = RemovePairRequest{} } func (m *RemovePairRequest) String() string { return proto.CompactTextString(m) } func (*RemovePairRequest) ProtoMessage() {} func (*RemovePairRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{58} + return fileDescriptor_6960a02cc0a63cf6, []int{60} } func (m *RemovePairRequest) XXX_Unmarshal(b []byte) error { @@ -3331,7 +3539,7 @@ func (m *RemovePairResponse) Reset() { *m = RemovePairResponse{} } func (m *RemovePairResponse) String() string { return proto.CompactTextString(m) } func (*RemovePairResponse) ProtoMessage() {} func (*RemovePairResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{59} + return fileDescriptor_6960a02cc0a63cf6, []int{61} } func (m *RemovePairResponse) XXX_Unmarshal(b []byte) error { @@ -3371,7 +3579,7 @@ func (m *RestoreNodeRequest) Reset() { *m = RestoreNodeRequest{} } func (m *RestoreNodeRequest) String() string { return proto.CompactTextString(m) } func (*RestoreNodeRequest) ProtoMessage() {} func (*RestoreNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{60} + return fileDescriptor_6960a02cc0a63cf6, []int{62} } func (m *RestoreNodeRequest) XXX_Unmarshal(b []byte) error { @@ -3434,7 +3642,7 @@ func (m *RestoreNodeResponse) Reset() { *m = RestoreNodeResponse{} } func (m *RestoreNodeResponse) String() string { return proto.CompactTextString(m) } func (*RestoreNodeResponse) ProtoMessage() {} func (*RestoreNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{61} + return fileDescriptor_6960a02cc0a63cf6, []int{63} } func (m *RestoreNodeResponse) XXX_Unmarshal(b []byte) error { @@ -3480,7 +3688,7 @@ func (m *SetLogLevelRequest) Reset() { *m = SetLogLevelRequest{} } func (m *SetLogLevelRequest) String() string { return proto.CompactTextString(m) } func (*SetLogLevelRequest) ProtoMessage() {} func (*SetLogLevelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{62} + return fileDescriptor_6960a02cc0a63cf6, []int{64} } func (m *SetLogLevelRequest) XXX_Unmarshal(b []byte) error { @@ -3518,7 +3726,7 @@ func (m *SetLogLevelResponse) Reset() { *m = SetLogLevelResponse{} } func (m *SetLogLevelResponse) String() string { return proto.CompactTextString(m) } func (*SetLogLevelResponse) ProtoMessage() {} func (*SetLogLevelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{63} + return fileDescriptor_6960a02cc0a63cf6, []int{65} } func (m *SetLogLevelResponse) XXX_Unmarshal(b []byte) error { @@ -3549,7 +3757,7 @@ func (m *ShutdownRequest) Reset() { *m = ShutdownRequest{} } func (m *ShutdownRequest) String() string { return proto.CompactTextString(m) } func (*ShutdownRequest) ProtoMessage() {} func (*ShutdownRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{64} + return fileDescriptor_6960a02cc0a63cf6, []int{66} } func (m *ShutdownRequest) XXX_Unmarshal(b []byte) error { @@ -3580,7 +3788,7 @@ func (m *ShutdownResponse) Reset() { *m = ShutdownResponse{} } func (m *ShutdownResponse) String() string { return proto.CompactTextString(m) } func (*ShutdownResponse) ProtoMessage() {} func (*ShutdownResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{65} + return fileDescriptor_6960a02cc0a63cf6, []int{67} } func (m *ShutdownResponse) XXX_Unmarshal(b []byte) error { @@ -3613,7 +3821,7 @@ func (m *SubscribeOrdersRequest) Reset() { *m = SubscribeOrdersRequest{} func (m *SubscribeOrdersRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeOrdersRequest) ProtoMessage() {} func (*SubscribeOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{66} + return fileDescriptor_6960a02cc0a63cf6, []int{68} } func (m *SubscribeOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -3641,6 +3849,37 @@ func (m *SubscribeOrdersRequest) GetExisting() bool { return false } +type SubscribeAlertsRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SubscribeAlertsRequest) Reset() { *m = SubscribeAlertsRequest{} } +func (m *SubscribeAlertsRequest) String() string { return proto.CompactTextString(m) } +func (*SubscribeAlertsRequest) ProtoMessage() {} +func (*SubscribeAlertsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{69} +} + +func (m *SubscribeAlertsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SubscribeAlertsRequest.Unmarshal(m, b) +} +func (m *SubscribeAlertsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SubscribeAlertsRequest.Marshal(b, m, deterministic) +} +func (m *SubscribeAlertsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SubscribeAlertsRequest.Merge(m, src) +} +func (m *SubscribeAlertsRequest) XXX_Size() int { + return xxx_messageInfo_SubscribeAlertsRequest.Size(m) +} +func (m *SubscribeAlertsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SubscribeAlertsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SubscribeAlertsRequest proto.InternalMessageInfo + type SubscribeSwapsAcceptedRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -3651,7 +3890,7 @@ func (m *SubscribeSwapsAcceptedRequest) Reset() { *m = SubscribeSwapsAcc func (m *SubscribeSwapsAcceptedRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeSwapsAcceptedRequest) ProtoMessage() {} func (*SubscribeSwapsAcceptedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{67} + return fileDescriptor_6960a02cc0a63cf6, []int{70} } func (m *SubscribeSwapsAcceptedRequest) XXX_Unmarshal(b []byte) error { @@ -3685,7 +3924,7 @@ func (m *SubscribeSwapsRequest) Reset() { *m = SubscribeSwapsRequest{} } func (m *SubscribeSwapsRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeSwapsRequest) ProtoMessage() {} func (*SubscribeSwapsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{68} + return fileDescriptor_6960a02cc0a63cf6, []int{71} } func (m *SubscribeSwapsRequest) XXX_Unmarshal(b []byte) error { @@ -3745,7 +3984,7 @@ func (m *SwapAccepted) Reset() { *m = SwapAccepted{} } func (m *SwapAccepted) String() string { return proto.CompactTextString(m) } func (*SwapAccepted) ProtoMessage() {} func (*SwapAccepted) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{69} + return fileDescriptor_6960a02cc0a63cf6, []int{72} } func (m *SwapAccepted) XXX_Unmarshal(b []byte) error { @@ -3863,7 +4102,7 @@ func (m *SwapFailure) Reset() { *m = SwapFailure{} } func (m *SwapFailure) String() string { return proto.CompactTextString(m) } func (*SwapFailure) ProtoMessage() {} func (*SwapFailure) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{70} + return fileDescriptor_6960a02cc0a63cf6, []int{73} } func (m *SwapFailure) XXX_Unmarshal(b []byte) error { @@ -3955,7 +4194,7 @@ func (m *SwapSuccess) Reset() { *m = SwapSuccess{} } func (m *SwapSuccess) String() string { return proto.CompactTextString(m) } func (*SwapSuccess) ProtoMessage() {} func (*SwapSuccess) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{71} + return fileDescriptor_6960a02cc0a63cf6, []int{74} } func (m *SwapSuccess) XXX_Unmarshal(b []byte) error { @@ -4099,7 +4338,7 @@ func (m *Trade) Reset() { *m = Trade{} } func (m *Trade) String() string { return proto.CompactTextString(m) } func (*Trade) ProtoMessage() {} func (*Trade) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{72} + return fileDescriptor_6960a02cc0a63cf6, []int{75} } func (m *Trade) XXX_Unmarshal(b []byte) error { @@ -4202,7 +4441,7 @@ func (m *TradeHistoryRequest) Reset() { *m = TradeHistoryRequest{} } func (m *TradeHistoryRequest) String() string { return proto.CompactTextString(m) } func (*TradeHistoryRequest) ProtoMessage() {} func (*TradeHistoryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{73} + return fileDescriptor_6960a02cc0a63cf6, []int{76} } func (m *TradeHistoryRequest) XXX_Unmarshal(b []byte) error { @@ -4241,7 +4480,7 @@ func (m *TradeHistoryResponse) Reset() { *m = TradeHistoryResponse{} } func (m *TradeHistoryResponse) String() string { return proto.CompactTextString(m) } func (*TradeHistoryResponse) ProtoMessage() {} func (*TradeHistoryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{74} + return fileDescriptor_6960a02cc0a63cf6, []int{77} } func (m *TradeHistoryResponse) XXX_Unmarshal(b []byte) error { @@ -4287,7 +4526,7 @@ func (m *TradingLimits) Reset() { *m = TradingLimits{} } func (m *TradingLimits) String() string { return proto.CompactTextString(m) } func (*TradingLimits) ProtoMessage() {} func (*TradingLimits) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{75} + return fileDescriptor_6960a02cc0a63cf6, []int{78} } func (m *TradingLimits) XXX_Unmarshal(b []byte) error { @@ -4349,7 +4588,7 @@ func (m *TradingLimitsRequest) Reset() { *m = TradingLimitsRequest{} } func (m *TradingLimitsRequest) String() string { return proto.CompactTextString(m) } func (*TradingLimitsRequest) ProtoMessage() {} func (*TradingLimitsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{76} + return fileDescriptor_6960a02cc0a63cf6, []int{79} } func (m *TradingLimitsRequest) XXX_Unmarshal(b []byte) error { @@ -4389,7 +4628,7 @@ func (m *TradingLimitsResponse) Reset() { *m = TradingLimitsResponse{} } func (m *TradingLimitsResponse) String() string { return proto.CompactTextString(m) } func (*TradingLimitsResponse) ProtoMessage() {} func (*TradingLimitsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{77} + return fileDescriptor_6960a02cc0a63cf6, []int{80} } func (m *TradingLimitsResponse) XXX_Unmarshal(b []byte) error { @@ -4431,7 +4670,7 @@ func (m *UnbanRequest) Reset() { *m = UnbanRequest{} } func (m *UnbanRequest) String() string { return proto.CompactTextString(m) } func (*UnbanRequest) ProtoMessage() {} func (*UnbanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{78} + return fileDescriptor_6960a02cc0a63cf6, []int{81} } func (m *UnbanRequest) XXX_Unmarshal(b []byte) error { @@ -4476,7 +4715,7 @@ func (m *UnbanResponse) Reset() { *m = UnbanResponse{} } func (m *UnbanResponse) String() string { return proto.CompactTextString(m) } func (*UnbanResponse) ProtoMessage() {} func (*UnbanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{79} + return fileDescriptor_6960a02cc0a63cf6, []int{82} } func (m *UnbanResponse) XXX_Unmarshal(b []byte) error { @@ -4510,7 +4749,7 @@ func (m *UnlockNodeRequest) Reset() { *m = UnlockNodeRequest{} } func (m *UnlockNodeRequest) String() string { return proto.CompactTextString(m) } func (*UnlockNodeRequest) ProtoMessage() {} func (*UnlockNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{80} + return fileDescriptor_6960a02cc0a63cf6, []int{83} } func (m *UnlockNodeRequest) XXX_Unmarshal(b []byte) error { @@ -4552,7 +4791,7 @@ func (m *UnlockNodeResponse) Reset() { *m = UnlockNodeResponse{} } func (m *UnlockNodeResponse) String() string { return proto.CompactTextString(m) } func (*UnlockNodeResponse) ProtoMessage() {} func (*UnlockNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{81} + return fileDescriptor_6960a02cc0a63cf6, []int{84} } func (m *UnlockNodeResponse) XXX_Unmarshal(b []byte) error { @@ -4608,7 +4847,7 @@ func (m *WithdrawRequest) Reset() { *m = WithdrawRequest{} } func (m *WithdrawRequest) String() string { return proto.CompactTextString(m) } func (*WithdrawRequest) ProtoMessage() {} func (*WithdrawRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{82} + return fileDescriptor_6960a02cc0a63cf6, []int{85} } func (m *WithdrawRequest) XXX_Unmarshal(b []byte) error { @@ -4676,7 +4915,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_6960a02cc0a63cf6, []int{83} + return fileDescriptor_6960a02cc0a63cf6, []int{86} } func (m *WithdrawResponse) XXX_Unmarshal(b []byte) error { @@ -4708,12 +4947,16 @@ func init() { proto.RegisterEnum("xudrpc.OrderSide", OrderSide_name, OrderSide_value) proto.RegisterEnum("xudrpc.Role", Role_name, Role_value) proto.RegisterEnum("xudrpc.LogLevel", LogLevel_name, LogLevel_value) + proto.RegisterEnum("xudrpc.Alert_AlertType", Alert_AlertType_name, Alert_AlertType_value) + proto.RegisterEnum("xudrpc.BalanceAlert_Side", BalanceAlert_Side_name, BalanceAlert_Side_value) proto.RegisterEnum("xudrpc.Currency_SwapClient", Currency_SwapClient_name, Currency_SwapClient_value) proto.RegisterEnum("xudrpc.ListOrdersRequest_Owner", ListOrdersRequest_Owner_name, ListOrdersRequest_Owner_value) proto.RegisterType((*AddCurrencyResponse)(nil), "xudrpc.AddCurrencyResponse") proto.RegisterType((*AddPairRequest)(nil), "xudrpc.AddPairRequest") proto.RegisterType((*AddPairResponse)(nil), "xudrpc.AddPairResponse") + proto.RegisterType((*Alert)(nil), "xudrpc.Alert") proto.RegisterType((*Balance)(nil), "xudrpc.Balance") + proto.RegisterType((*BalanceAlert)(nil), "xudrpc.BalanceAlert") proto.RegisterType((*BanRequest)(nil), "xudrpc.BanRequest") proto.RegisterType((*BanResponse)(nil), "xudrpc.BanResponse") proto.RegisterType((*Chain)(nil), "xudrpc.Chain") @@ -4782,6 +5025,7 @@ func init() { proto.RegisterType((*ShutdownRequest)(nil), "xudrpc.ShutdownRequest") proto.RegisterType((*ShutdownResponse)(nil), "xudrpc.ShutdownResponse") proto.RegisterType((*SubscribeOrdersRequest)(nil), "xudrpc.SubscribeOrdersRequest") + proto.RegisterType((*SubscribeAlertsRequest)(nil), "xudrpc.SubscribeAlertsRequest") proto.RegisterType((*SubscribeSwapsAcceptedRequest)(nil), "xudrpc.SubscribeSwapsAcceptedRequest") proto.RegisterType((*SubscribeSwapsRequest)(nil), "xudrpc.SubscribeSwapsRequest") proto.RegisterType((*SwapAccepted)(nil), "xudrpc.SwapAccepted") @@ -4805,268 +5049,280 @@ func init() { func init() { proto.RegisterFile("xudrpc.proto", fileDescriptor_6960a02cc0a63cf6) } var fileDescriptor_6960a02cc0a63cf6 = []byte{ - // 4162 bytes of a gzipped FileDescriptorProto + // 4367 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x4d, 0x8f, 0x1c, 0x49, - 0x56, 0x9d, 0xd5, 0x5d, 0xdd, 0xd5, 0xaf, 0x3e, 0x3b, 0xfa, 0xc3, 0xe5, 0x1a, 0xcf, 0x8c, 0x37, - 0x18, 0x8f, 0x3c, 0x9e, 0x59, 0xdb, 0x78, 0x58, 0x66, 0xc7, 0x8b, 0x47, 0xd3, 0xdd, 0xee, 0x1d, - 0x7b, 0xa6, 0xd7, 0xb6, 0xb2, 0xed, 0xb1, 0x59, 0xc1, 0xa6, 0xb2, 0x32, 0xc3, 0xdd, 0x89, 0xb3, - 0x33, 0x6b, 0x32, 0xb3, 0xdc, 0x36, 0x5c, 0xd0, 0x8a, 0x13, 0x1c, 0x38, 0x20, 0xce, 0x70, 0x42, - 0x48, 0x20, 0xae, 0x9c, 0x90, 0x38, 0x73, 0xe5, 0x00, 0x02, 0x2e, 0x48, 0xfc, 0x02, 0xc4, 0x15, - 0x09, 0xbd, 0xf8, 0xc8, 0x88, 0xc8, 0xcc, 0xea, 0xb5, 0x57, 0xc0, 0xad, 0xe2, 0xc5, 0xcb, 0xf7, - 0x22, 0xde, 0x57, 0xbc, 0xf7, 0x22, 0x0a, 0x7a, 0xaf, 0xe6, 0x61, 0x36, 0x0b, 0xae, 0xcf, 0xb2, - 0xb4, 0x48, 0xc9, 0xaa, 0x18, 0x4d, 0x36, 0xfc, 0x24, 0x49, 0x0b, 0xbf, 0x88, 0xd2, 0x24, 0x17, - 0x53, 0x74, 0x1b, 0x36, 0x77, 0xc3, 0x70, 0x7f, 0x9e, 0x65, 0x2c, 0x09, 0x5e, 0xbb, 0x2c, 0x9f, - 0xa5, 0x49, 0xce, 0xe8, 0xcf, 0x60, 0xb0, 0x1b, 0x86, 0x8f, 0xfc, 0x28, 0x73, 0xd9, 0x77, 0x73, - 0x96, 0x17, 0xe4, 0x03, 0xe8, 0x4f, 0xfd, 0x9c, 0x79, 0x81, 0x44, 0x1d, 0x3b, 0x97, 0x9d, 0xab, - 0xeb, 0xae, 0x0d, 0x24, 0x1f, 0xc2, 0xe0, 0xbb, 0x79, 0x5a, 0x18, 0x68, 0x2d, 0x8e, 0x56, 0x81, - 0xd2, 0x0d, 0x18, 0x96, 0xf4, 0x25, 0xcb, 0xbf, 0x6d, 0xc1, 0xda, 0x9e, 0x1f, 0xfb, 0x49, 0xc0, - 0x90, 0x59, 0x91, 0x16, 0x7e, 0xec, 0x4d, 0x05, 0x80, 0x33, 0x5b, 0x71, 0x6d, 0x20, 0xb9, 0x0a, - 0xc3, 0xe0, 0xc4, 0x4f, 0x12, 0xa6, 0xf1, 0x5a, 0x1c, 0xaf, 0x0a, 0x26, 0x3f, 0x84, 0x0b, 0x33, - 0x96, 0x84, 0x51, 0x72, 0xec, 0x55, 0xbf, 0x58, 0xe6, 0x5f, 0x2c, 0x9a, 0x26, 0xb7, 0x61, 0x1c, - 0x25, 0x7e, 0x50, 0x44, 0x2f, 0x59, 0xed, 0xd3, 0x15, 0xfe, 0xe9, 0xc2, 0x79, 0x14, 0xc6, 0x99, - 0x1f, 0xc7, 0xac, 0x28, 0xbf, 0x68, 0xf3, 0x2f, 0x2a, 0x50, 0xf2, 0x05, 0x4c, 0xe6, 0x49, 0x90, - 0x26, 0xcf, 0xa3, 0xec, 0x94, 0x85, 0x5e, 0xe5, 0x9b, 0x55, 0xfe, 0xcd, 0x39, 0x18, 0xf4, 0xd7, - 0x01, 0xf6, 0xfc, 0x44, 0x29, 0xea, 0x2a, 0x0c, 0x93, 0x34, 0x64, 0x5e, 0x14, 0xb2, 0xa4, 0x88, - 0x9e, 0x47, 0x2c, 0x93, 0xaa, 0xaa, 0x82, 0x69, 0x1f, 0xba, 0xfc, 0x3b, 0xa9, 0x80, 0xcf, 0xa0, - 0xbd, 0x7f, 0xe2, 0x47, 0x09, 0xd9, 0x82, 0x76, 0x80, 0x3f, 0xe4, 0x77, 0x62, 0x40, 0xc6, 0xb0, - 0x96, 0xb0, 0xe2, 0x2c, 0xcd, 0x5e, 0x48, 0x9d, 0xaa, 0x21, 0x9d, 0x41, 0x67, 0x5f, 0x6c, 0x3d, - 0x27, 0x3b, 0xb0, 0x2a, 0xa4, 0xc1, 0x3f, 0xee, 0xbb, 0x72, 0x44, 0x26, 0xd0, 0x51, 0x72, 0xe2, - 0x9f, 0xf7, 0xdd, 0x72, 0x8c, 0x94, 0xa5, 0xf8, 0xb9, 0x36, 0xfa, 0xae, 0x1a, 0x22, 0xb5, 0x20, - 0x4e, 0x73, 0x16, 0x72, 0x59, 0xf7, 0x5d, 0x39, 0xa2, 0x1e, 0x6c, 0x23, 0xc7, 0x63, 0xf6, 0xc8, - 0xcf, 0xf3, 0xb3, 0x34, 0x0b, 0xd5, 0xe6, 0x29, 0xf4, 0x12, 0x76, 0xe6, 0xcd, 0x24, 0x58, 0xee, - 0xc0, 0x82, 0x21, 0x4e, 0x1a, 0x87, 0x1a, 0x47, 0xec, 0xc6, 0x82, 0xd1, 0x31, 0xec, 0x54, 0x19, - 0x48, 0x29, 0xfd, 0x9d, 0x03, 0x9b, 0xfb, 0xb8, 0x0a, 0xb9, 0xe5, 0xb7, 0x16, 0x3b, 0x8a, 0xa2, - 0xe2, 0x1d, 0xe5, 0x18, 0x45, 0xff, 0x3c, 0xcd, 0xa4, 0x59, 0x76, 0x5c, 0x31, 0x20, 0x97, 0xa1, - 0x1b, 0xb2, 0xbc, 0x88, 0x12, 0xee, 0xba, 0x5c, 0x16, 0xeb, 0xae, 0x09, 0xe2, 0x62, 0x3f, 0x4d, - 0xe7, 0x49, 0x21, 0x4d, 0x4c, 0x8e, 0xc8, 0x08, 0x96, 0x9f, 0x33, 0x65, 0x43, 0xf8, 0x93, 0x7e, - 0x09, 0x5b, 0xf6, 0xf2, 0xc5, 0xbe, 0x70, 0xfd, 0x45, 0xe6, 0x27, 0x39, 0xea, 0x24, 0x4d, 0xbc, - 0x28, 0xcc, 0xc7, 0xce, 0xe5, 0x65, 0x5c, 0x7f, 0x05, 0x4c, 0x3f, 0x81, 0xc1, 0x7e, 0x9a, 0x24, - 0x2c, 0x28, 0xd4, 0xde, 0x27, 0xd0, 0xe1, 0x9b, 0x9c, 0x67, 0x91, 0xdc, 0x74, 0x39, 0x46, 0x4f, - 0x2f, 0xb1, 0xa5, 0x08, 0x6f, 0xc0, 0xc6, 0x7e, 0xc6, 0xfc, 0x82, 0x3d, 0x48, 0x43, 0x66, 0xd0, - 0xa8, 0x68, 0xad, 0x1c, 0xd3, 0x3f, 0x75, 0x80, 0x98, 0x5f, 0xc8, 0x25, 0xff, 0x0a, 0xf4, 0x73, - 0xc6, 0x42, 0xef, 0x34, 0x61, 0xa7, 0x69, 0x12, 0x05, 0x72, 0xc1, 0x3d, 0x04, 0xfe, 0x44, 0xc2, - 0xc8, 0x47, 0x30, 0x8a, 0x92, 0xa8, 0x88, 0xfc, 0x38, 0xfa, 0x5d, 0x16, 0x7a, 0x71, 0x12, 0xe6, - 0xe3, 0x96, 0xd8, 0x98, 0x01, 0x3f, 0x4c, 0xc2, 0x9c, 0xdc, 0x80, 0x4d, 0x13, 0x35, 0xc0, 0x65, - 0xbf, 0x2a, 0xa4, 0x2a, 0x88, 0x31, 0xb5, 0x2f, 0x66, 0xe8, 0x3f, 0x39, 0xd0, 0x51, 0xa1, 0xd3, - 0x52, 0xab, 0x53, 0x51, 0xeb, 0x1d, 0xe8, 0xe6, 0x67, 0xfe, 0xcc, 0x0b, 0xe2, 0x88, 0x25, 0x05, - 0xd7, 0xfa, 0xe0, 0xd6, 0x3b, 0xd7, 0x65, 0x90, 0x56, 0x24, 0xae, 0x1f, 0x9d, 0xf9, 0xb3, 0x7d, - 0x8e, 0xe2, 0x9a, 0xf8, 0x22, 0x1c, 0xbe, 0x60, 0x89, 0xe7, 0x87, 0x61, 0xc6, 0xf2, 0x9c, 0x2f, - 0x69, 0xdd, 0xb5, 0x81, 0x18, 0x6e, 0x42, 0x16, 0x44, 0xa7, 0x7e, 0xec, 0xcd, 0x62, 0x3f, 0x60, - 0xb9, 0x74, 0x9a, 0x0a, 0x94, 0x52, 0x00, 0xcd, 0x88, 0xac, 0xc1, 0xf2, 0xe1, 0x83, 0xbb, 0xa3, - 0x25, 0xd2, 0x85, 0xb5, 0xfd, 0x87, 0x0f, 0x1e, 0x1c, 0x3c, 0x7b, 0x3c, 0x6a, 0xa1, 0x8e, 0xef, - 0xb2, 0x59, 0x9a, 0x47, 0xa6, 0x8e, 0x17, 0x6d, 0x8f, 0x7e, 0x0c, 0xc3, 0x12, 0x5b, 0xea, 0x66, - 0x0c, 0x6b, 0x6a, 0xb1, 0x02, 0x5b, 0x0d, 0xd1, 0x00, 0xef, 0x46, 0x79, 0x90, 0xbe, 0x64, 0x19, - 0x6a, 0x33, 0x7f, 0xfb, 0xb8, 0xf5, 0x03, 0xd8, 0xae, 0x50, 0x90, 0x4c, 0x2f, 0xc1, 0x7a, 0x32, - 0x3f, 0xf5, 0x10, 0x3f, 0x97, 0xf1, 0x47, 0x03, 0xe8, 0x1f, 0x3a, 0x40, 0x0e, 0x5e, 0xb1, 0x60, - 0x5e, 0x30, 0xdc, 0xbf, 0xb1, 0xb1, 0x34, 0x0b, 0x59, 0xe6, 0x45, 0xa5, 0xe1, 0xa9, 0x31, 0x8f, - 0x4c, 0x7e, 0xc4, 0xa7, 0x64, 0xcc, 0x93, 0x43, 0x0c, 0x22, 0x33, 0xc6, 0x32, 0x6f, 0x36, 0x9f, - 0x7a, 0x2f, 0xd8, 0x6b, 0xa9, 0x11, 0x0b, 0x86, 0x94, 0xbf, 0x9b, 0xfb, 0x49, 0x11, 0x15, 0xaf, - 0xe5, 0x59, 0x51, 0x8e, 0xd1, 0x07, 0xbe, 0x62, 0x85, 0x3c, 0xef, 0xde, 0x44, 0xc6, 0x7f, 0xe9, - 0x00, 0x31, 0xbf, 0x90, 0x5b, 0xbe, 0x0b, 0x1d, 0x79, 0x0c, 0x08, 0x7f, 0xed, 0xde, 0xba, 0xaa, - 0xcc, 0xaa, 0x8e, 0x7d, 0x5d, 0x8e, 0xf3, 0x83, 0xa4, 0xc8, 0x5e, 0xbb, 0xe5, 0x97, 0x93, 0x43, - 0xe8, 0x5b, 0x53, 0x18, 0x37, 0x70, 0x57, 0x62, 0x11, 0xf8, 0x93, 0x5c, 0x81, 0xf6, 0x4b, 0x3f, - 0x9e, 0x8b, 0xe8, 0xdd, 0xbd, 0x35, 0x54, 0x5c, 0x14, 0x0b, 0x31, 0x7b, 0xbb, 0xf5, 0x43, 0x87, - 0x8e, 0x60, 0xf0, 0x15, 0x2b, 0xee, 0x27, 0xcf, 0x53, 0xb9, 0x31, 0xfa, 0x2f, 0xcb, 0x30, 0x2c, - 0x41, 0xda, 0x42, 0x5e, 0xb2, 0x2c, 0xc7, 0x80, 0x26, 0x2d, 0x44, 0x0e, 0x79, 0x10, 0x47, 0x95, - 0x2b, 0xd9, 0xca, 0x00, 0x6d, 0xc2, 0x08, 0x81, 0x95, 0x79, 0x16, 0xa1, 0x27, 0xa0, 0x2b, 0xf3, - 0xdf, 0x4a, 0xfd, 0xa8, 0x03, 0x65, 0xfb, 0x1a, 0x50, 0xce, 0xfa, 0x51, 0x96, 0xf3, 0x28, 0xa9, - 0x66, 0x11, 0x40, 0x3e, 0x86, 0x55, 0xae, 0xf5, 0x9c, 0xc7, 0xca, 0xee, 0xad, 0x4d, 0xb5, 0xbf, - 0x87, 0x1c, 0xba, 0x8f, 0xd1, 0xd4, 0x95, 0x28, 0xe4, 0x16, 0x2c, 0xc7, 0x49, 0x38, 0x5e, 0xe3, - 0xf2, 0xbe, 0x6c, 0xc8, 0xdb, 0xdc, 0xe0, 0xf5, 0xc3, 0x24, 0x14, 0x72, 0x46, 0x64, 0x8c, 0xec, - 0x7e, 0x1c, 0xf9, 0xf9, 0x78, 0x5d, 0x1c, 0xaa, 0x7c, 0x60, 0x1e, 0xaa, 0x60, 0x1d, 0xaa, 0xe4, - 0x26, 0x6c, 0xaa, 0x9c, 0x84, 0x87, 0x82, 0x13, 0x3f, 0x3f, 0x61, 0xf9, 0xb8, 0xcb, 0xf7, 0xdb, - 0x34, 0x45, 0xbe, 0x0f, 0x6b, 0x2a, 0x64, 0xf5, 0xec, 0x3d, 0xc8, 0x78, 0xc5, 0x57, 0xa7, 0x70, - 0x26, 0x5f, 0x41, 0x47, 0xad, 0xf0, 0x2d, 0xd4, 0x7d, 0x98, 0x84, 0x9c, 0x8c, 0xa1, 0xee, 0x2d, - 0x6e, 0x98, 0x2a, 0xe0, 0x2a, 0x95, 0xff, 0x08, 0x36, 0x2d, 0xa8, 0xd4, 0xfa, 0x07, 0xcd, 0x31, - 0xdb, 0x06, 0xd2, 0x2f, 0x38, 0x49, 0x74, 0x6e, 0xc3, 0x8a, 0xde, 0x22, 0x42, 0xb8, 0x9c, 0xb9, - 0xfe, 0xbe, 0x3c, 0x30, 0x86, 0x19, 0x9b, 0xcd, 0x45, 0x06, 0x7c, 0x14, 0xa4, 0x99, 0xc8, 0x52, - 0x36, 0x5c, 0xd0, 0x60, 0x3c, 0x4a, 0xa7, 0x78, 0x34, 0x0a, 0x97, 0xef, 0xb8, 0x72, 0x44, 0x2f, - 0xc0, 0xf6, 0x61, 0x94, 0x17, 0x32, 0x58, 0x47, 0x65, 0xe0, 0xa2, 0x5f, 0xc3, 0x4e, 0x75, 0x42, - 0xf2, 0xbb, 0x09, 0x10, 0x94, 0x50, 0xe9, 0x9e, 0xa3, 0x6a, 0xd4, 0x77, 0x0d, 0x1c, 0xfa, 0x0f, - 0x0e, 0x6c, 0x20, 0x31, 0x61, 0x75, 0x6a, 0xe3, 0x46, 0x18, 0x72, 0xec, 0x30, 0xf4, 0x03, 0x68, - 0xa7, 0x67, 0x09, 0xcb, 0xe4, 0x91, 0xf2, 0x7e, 0xa9, 0xa6, 0x2a, 0x8d, 0xeb, 0x0f, 0x11, 0xcd, - 0x15, 0xd8, 0x68, 0x8c, 0x71, 0x74, 0x1a, 0x15, 0x32, 0xdf, 0x12, 0x03, 0x94, 0x6f, 0x94, 0x04, - 0xf1, 0x3c, 0x64, 0x1e, 0xb7, 0x4e, 0x79, 0x82, 0x74, 0xdc, 0x2a, 0x98, 0x7e, 0x00, 0x6d, 0x4e, - 0x8f, 0x74, 0x60, 0x65, 0xef, 0xe1, 0xe3, 0x7b, 0xa3, 0x25, 0x3c, 0x47, 0x1e, 0x3e, 0x7d, 0x30, - 0x72, 0x10, 0xf4, 0xe8, 0xe0, 0xc0, 0x1d, 0xb5, 0xe8, 0x9f, 0x39, 0x40, 0xcc, 0x85, 0x48, 0xa9, - 0x7c, 0x51, 0xba, 0x9a, 0x90, 0xc8, 0x87, 0x4d, 0x8b, 0x96, 0x3e, 0x24, 0x86, 0xc2, 0x8d, 0xe4, - 0x57, 0x93, 0xfb, 0xd0, 0x35, 0xc0, 0x0d, 0xb6, 0xfb, 0x81, 0x6d, 0xbb, 0x03, 0xdb, 0x95, 0x4d, - 0xd3, 0x25, 0x30, 0x42, 0xa6, 0x58, 0x87, 0x94, 0xea, 0xfc, 0x48, 0x68, 0x40, 0xc2, 0xe4, 0x9a, - 0xb7, 0xa0, 0x2d, 0x02, 0x87, 0x30, 0x57, 0x31, 0x28, 0x3f, 0x67, 0x5a, 0xce, 0xf4, 0x33, 0xf9, - 0x39, 0x33, 0xb7, 0x4c, 0xa1, 0x2d, 0xa2, 0x92, 0xd8, 0x71, 0x4f, 0xad, 0x08, 0xb1, 0x5c, 0x31, - 0x45, 0xff, 0xcd, 0x81, 0x35, 0xe9, 0x5d, 0x68, 0x83, 0x79, 0xe1, 0x17, 0x73, 0x75, 0x78, 0xca, - 0x11, 0xf9, 0x04, 0x3a, 0xb2, 0xc8, 0xc8, 0xe5, 0xe6, 0xb4, 0x39, 0x49, 0xb8, 0x5b, 0x62, 0x90, - 0x2b, 0xb0, 0xca, 0x53, 0x77, 0x11, 0x25, 0xbb, 0xb7, 0xfa, 0x06, 0x6e, 0x94, 0xb8, 0x72, 0x12, - 0xb3, 0xcb, 0x69, 0x9c, 0x06, 0x2f, 0x4e, 0x58, 0x74, 0x7c, 0x52, 0xc8, 0xc0, 0x69, 0x82, 0xca, - 0x60, 0xdb, 0x36, 0x82, 0xad, 0x11, 0xbe, 0x57, 0xed, 0xf0, 0x5d, 0x46, 0xba, 0x35, 0x23, 0xd2, - 0xd1, 0xaf, 0x61, 0xc0, 0xfd, 0x51, 0xe7, 0xc1, 0xd5, 0x30, 0xef, 0x34, 0x84, 0xf9, 0x92, 0x56, - 0xcb, 0xa4, 0xf5, 0x17, 0x0e, 0x90, 0x87, 0x33, 0x96, 0xfc, 0x9f, 0xa4, 0xe0, 0x3a, 0x95, 0x5e, - 0xb6, 0x52, 0xe9, 0xcb, 0xd0, 0x9d, 0xcd, 0xf3, 0x13, 0x4f, 0x4e, 0x8a, 0x03, 0xdd, 0x04, 0xa9, - 0x64, 0xbb, 0xad, 0x93, 0xed, 0x3b, 0xb0, 0x69, 0xad, 0x53, 0x9a, 0xc3, 0x87, 0x30, 0xb0, 0x93, - 0x6a, 0xb9, 0xce, 0x0a, 0x94, 0xfe, 0x7d, 0x0b, 0xda, 0xdc, 0x68, 0xb9, 0xfd, 0x65, 0x91, 0x2c, - 0x84, 0x1d, 0x57, 0x0c, 0xac, 0x04, 0xa3, 0x65, 0x27, 0x18, 0x66, 0xcc, 0x58, 0xb6, 0x63, 0xc6, - 0x00, 0x5a, 0x51, 0x28, 0x8b, 0x88, 0x56, 0x14, 0x92, 0x2f, 0xeb, 0x62, 0x6b, 0x73, 0xdb, 0xda, - 0x51, 0xf6, 0x62, 0x2b, 0xae, 0x51, 0x9c, 0x71, 0x1a, 0xf8, 0x31, 0x32, 0x13, 0xc6, 0x50, 0x8e, - 0xc9, 0x7b, 0x00, 0x01, 0x4f, 0xdd, 0x43, 0xcf, 0x2f, 0xb8, 0x49, 0xac, 0xb8, 0x06, 0x84, 0x5c, - 0x81, 0x95, 0x3c, 0x0a, 0xd9, 0xb8, 0xc3, 0x03, 0xd8, 0x86, 0xe5, 0xab, 0x47, 0x51, 0xc8, 0x5c, - 0x3e, 0x8d, 0xc6, 0x12, 0xe5, 0x5e, 0x7a, 0x96, 0x78, 0x3c, 0x0a, 0xf0, 0x53, 0xb4, 0xe3, 0x5a, - 0x30, 0x34, 0xd3, 0x93, 0x34, 0x0e, 0xf9, 0x49, 0xba, 0xe2, 0xf2, 0xdf, 0xf4, 0xcf, 0x1d, 0xe8, - 0x71, 0x5a, 0x2e, 0x3b, 0x4d, 0x5f, 0xfa, 0xb1, 0x25, 0x33, 0x67, 0xb1, 0xcc, 0x2a, 0xe9, 0x9e, - 0x99, 0x24, 0x2e, 0x57, 0x92, 0x44, 0x73, 0xf7, 0x2b, 0x95, 0xdd, 0x57, 0x97, 0xdd, 0xae, 0x2f, - 0x9b, 0x9e, 0xc0, 0xaa, 0x88, 0x4c, 0xe4, 0xfb, 0x00, 0xd3, 0xf9, 0x6b, 0xcf, 0x8a, 0x8e, 0x7d, - 0x4b, 0x22, 0xae, 0x81, 0x40, 0x6e, 0x40, 0x37, 0x67, 0x71, 0xac, 0xf0, 0x5b, 0x4d, 0xf8, 0x26, - 0x06, 0xfd, 0x54, 0x45, 0x4e, 0x9e, 0xce, 0xa0, 0xbc, 0x30, 0xf4, 0xc8, 0x4c, 0x99, 0xff, 0x46, - 0x1b, 0x4e, 0xcf, 0x12, 0x59, 0xa2, 0xe3, 0x4f, 0xfa, 0x73, 0x47, 0x7e, 0xf5, 0x64, 0x16, 0xfa, - 0x05, 0xc3, 0xcc, 0x40, 0xec, 0xc5, 0xe1, 0x46, 0x62, 0xf3, 0xbb, 0xb7, 0xe4, 0x8a, 0x59, 0xf2, - 0x1b, 0xd0, 0x17, 0x12, 0xca, 0x84, 0xe0, 0x65, 0xbc, 0xda, 0xb2, 0x97, 0x27, 0xe6, 0xee, 0x2d, - 0xb9, 0x36, 0xf2, 0xde, 0x00, 0x7a, 0x02, 0x30, 0xe7, 0x4c, 0xe9, 0xbf, 0xb6, 0x60, 0x05, 0x83, - 0xe5, 0xe2, 0xba, 0xe2, 0x8d, 0xb2, 0xc6, 0x2f, 0xa1, 0x17, 0x27, 0xa1, 0x1a, 0xaa, 0xb8, 0x78, - 0xc9, 0x0c, 0xc7, 0x98, 0xe1, 0x3c, 0x9a, 0x4f, 0xbf, 0x61, 0xaf, 0xe5, 0xb1, 0x63, 0x7d, 0x81, - 0xfc, 0xa3, 0x64, 0x9a, 0xce, 0x93, 0x50, 0x9e, 0x8d, 0x6a, 0xa8, 0x8f, 0x88, 0xb6, 0x71, 0x44, - 0x60, 0xd4, 0x78, 0x35, 0x0f, 0x3d, 0x3b, 0x54, 0x9a, 0x20, 0xf2, 0x09, 0x6c, 0xe4, 0x2c, 0x48, - 0x93, 0x30, 0x17, 0x15, 0x67, 0x50, 0xb0, 0x90, 0xfb, 0x49, 0xdf, 0xad, 0x4f, 0x34, 0xa7, 0x91, - 0x93, 0x3b, 0x30, 0xac, 0x2c, 0xbb, 0xe1, 0x58, 0xdc, 0x32, 0x8f, 0xc5, 0x75, 0xf3, 0x18, 0xfc, - 0xfd, 0x16, 0x6c, 0x3c, 0xc2, 0xe2, 0x50, 0x2a, 0x45, 0x84, 0xd3, 0xff, 0xcd, 0x98, 0x63, 0xfa, - 0xcf, 0x4a, 0xc5, 0x7f, 0x54, 0x04, 0x68, 0x9f, 0x1f, 0x01, 0xae, 0xc1, 0x28, 0x63, 0xbc, 0x84, - 0xf5, 0x4a, 0x52, 0x42, 0x9c, 0x35, 0x38, 0x26, 0xcf, 0xd1, 0xe9, 0x29, 0x0b, 0x23, 0xbf, 0x40, - 0xa8, 0x17, 0x60, 0x89, 0x12, 0x73, 0xa9, 0x76, 0xdc, 0xa6, 0x29, 0x14, 0x01, 0x31, 0x45, 0x20, - 0x23, 0xf5, 0xe7, 0x30, 0x8a, 0x92, 0x82, 0x65, 0x89, 0x1f, 0x7b, 0xa7, 0x7e, 0x11, 0x9c, 0xb0, - 0x05, 0x7e, 0x59, 0x43, 0x23, 0x3f, 0x82, 0x01, 0xcf, 0xce, 0xf3, 0x79, 0x10, 0xb0, 0x1c, 0x93, - 0x29, 0xe1, 0xa0, 0x65, 0x56, 0x8e, 0x45, 0xe8, 0x91, 0x98, 0x74, 0x2b, 0xa8, 0xe4, 0x33, 0xcc, - 0x54, 0x4f, 0xfd, 0x28, 0xc1, 0x24, 0x5f, 0xb8, 0xdb, 0x72, 0x83, 0xbb, 0xb9, 0x55, 0x2c, 0xf2, - 0x39, 0xf4, 0x39, 0xa9, 0xe7, 0x7e, 0x14, 0xcf, 0x33, 0x9e, 0xc1, 0xd5, 0x98, 0xfe, 0x58, 0xcc, - 0xb9, 0x36, 0x26, 0xfd, 0x4f, 0x07, 0x86, 0x5a, 0x04, 0x07, 0x2f, 0x59, 0x82, 0xd1, 0xb9, 0xcd, - 0xf7, 0xb3, 0xd0, 0xd9, 0xf9, 0x2c, 0xf9, 0x1c, 0x7a, 0xe6, 0x06, 0xa4, 0xaf, 0x37, 0xed, 0xf4, - 0xde, 0x92, 0x6b, 0xa1, 0x92, 0xcf, 0xdf, 0x6c, 0xa7, 0xf7, 0x96, 0x9a, 0xf6, 0xda, 0x33, 0x77, - 0xc0, 0x0d, 0xab, 0x79, 0xab, 0x25, 0x57, 0x89, 0xba, 0xb7, 0x06, 0x6d, 0x86, 0x1b, 0xa4, 0x29, - 0x74, 0x8d, 0xea, 0x68, 0x61, 0xe2, 0x65, 0x84, 0x9d, 0x96, 0x1d, 0x76, 0x8c, 0x3c, 0x68, 0xa5, - 0x96, 0x07, 0x89, 0x36, 0x6a, 0xdb, 0x68, 0xa3, 0xd2, 0x4f, 0x61, 0x9b, 0x47, 0x3d, 0xa6, 0x7b, - 0xee, 0xbf, 0xb8, 0xf8, 0x1f, 0xc3, 0x4e, 0xf5, 0x23, 0xd9, 0x4b, 0x3b, 0x04, 0x22, 0x66, 0x2c, - 0xd7, 0x3d, 0xaf, 0xa7, 0x71, 0x8e, 0x03, 0xd3, 0xbf, 0x72, 0x60, 0xd3, 0x22, 0x27, 0xdd, 0xe0, - 0x3d, 0x18, 0x29, 0x1c, 0x2f, 0x4d, 0x3c, 0x7e, 0xca, 0x3a, 0xfa, 0x94, 0x25, 0xd7, 0x81, 0x68, - 0xe5, 0x54, 0xa8, 0x37, 0xcc, 0x08, 0x5f, 0x46, 0x36, 0xa1, 0xc6, 0x16, 0xd9, 0x56, 0x0d, 0x6e, - 0x06, 0x95, 0x15, 0x2b, 0xa8, 0x68, 0xa9, 0xec, 0xc6, 0xb1, 0x55, 0xec, 0xd0, 0x39, 0x5c, 0xa8, - 0xcd, 0xc8, 0xad, 0x7c, 0x02, 0x1b, 0x8a, 0x85, 0x12, 0x89, 0xca, 0xea, 0xeb, 0x13, 0x88, 0x2d, - 0xf7, 0x6b, 0x60, 0x8b, 0xf6, 0x61, 0x7d, 0x82, 0x7e, 0x1f, 0x36, 0x04, 0x5b, 0xf3, 0xe2, 0x64, - 0x61, 0xf1, 0x86, 0x85, 0xb3, 0x89, 0x2e, 0x35, 0xfa, 0x07, 0x2d, 0x04, 0xe7, 0x45, 0x9a, 0x59, - 0xfd, 0xd1, 0x37, 0x6a, 0x76, 0x9a, 0x4d, 0xd4, 0x96, 0xdd, 0x44, 0x25, 0xdf, 0x40, 0x17, 0x4f, - 0xb2, 0xa9, 0x1f, 0xbc, 0x98, 0xcf, 0xd4, 0xd1, 0x77, 0x4d, 0x39, 0x4b, 0x9d, 0x23, 0x1e, 0x84, - 0x7b, 0x02, 0x59, 0x1c, 0x84, 0x10, 0x97, 0x00, 0xf2, 0x3d, 0x7e, 0xc3, 0xe4, 0x85, 0x7e, 0xe1, - 0x4f, 0xfd, 0x5c, 0x34, 0x98, 0x7b, 0xfc, 0x5c, 0xbb, 0x2b, 0x41, 0xf2, 0x4c, 0x32, 0x29, 0xfc, - 0xa2, 0x33, 0xa9, 0x67, 0x9e, 0x49, 0x0c, 0x2d, 0xd1, 0x58, 0x93, 0xee, 0xf9, 0x66, 0x02, 0x2c, - 0x7b, 0xb9, 0x52, 0x0c, 0x0a, 0xc8, 0x1b, 0xb9, 0x1f, 0xa1, 0x79, 0x49, 0x24, 0xd5, 0x12, 0x11, - 0xc5, 0xfc, 0x50, 0xc1, 0x55, 0x0b, 0xf7, 0x2e, 0x90, 0x23, 0x56, 0x1c, 0xa6, 0xc7, 0x87, 0xec, - 0xa5, 0xae, 0x24, 0xae, 0xc3, 0x7a, 0x9c, 0x1e, 0x7b, 0x31, 0xc2, 0xf8, 0x72, 0x07, 0xba, 0xd0, - 0x2a, 0x71, 0x35, 0x0a, 0xdd, 0x86, 0x4d, 0x8b, 0x8a, 0x54, 0xe5, 0x06, 0x0c, 0x8f, 0x4e, 0xe6, - 0x45, 0x98, 0x9e, 0xa9, 0xdb, 0x19, 0x2c, 0x19, 0x35, 0x48, 0xa2, 0xfd, 0x1a, 0xec, 0x1c, 0xcd, - 0xa7, 0x79, 0x90, 0x45, 0x53, 0x66, 0x17, 0xfe, 0x13, 0xe8, 0xb0, 0x57, 0x51, 0x5e, 0x44, 0xc9, - 0x31, 0x5f, 0x46, 0xc7, 0x2d, 0xc7, 0xf4, 0x7d, 0x78, 0xb7, 0xfc, 0x0a, 0x43, 0x5d, 0xbe, 0x1b, - 0x04, 0x6c, 0x56, 0x30, 0x75, 0x17, 0x42, 0xef, 0xc0, 0xb6, 0x8d, 0x60, 0x5c, 0xe5, 0xa9, 0x82, - 0xbe, 0xf0, 0x5f, 0xc8, 0x4c, 0xae, 0xe3, 0xda, 0x40, 0xfa, 0xdf, 0x2d, 0xe8, 0xe1, 0x67, 0x8a, - 0x2c, 0xb9, 0x58, 0x0b, 0x2a, 0x6b, 0x7c, 0x7c, 0xdf, 0x4e, 0x81, 0x5b, 0x95, 0x14, 0xf8, 0xdc, - 0xa4, 0x60, 0x51, 0x7f, 0x54, 0x27, 0x1f, 0x6d, 0x33, 0xf9, 0xa8, 0x76, 0x5d, 0x57, 0x1b, 0xba, - 0xae, 0x3b, 0xb0, 0x9a, 0xf1, 0x96, 0x98, 0xac, 0x3f, 0xe5, 0x08, 0x63, 0x8e, 0xa8, 0xd3, 0xbc, - 0x8c, 0x05, 0x2c, 0x7a, 0x89, 0x32, 0xed, 0x88, 0x98, 0x53, 0x85, 0x63, 0x81, 0x26, 0x61, 0xb9, - 0xbc, 0x98, 0x5a, 0x17, 0x37, 0x77, 0x36, 0x14, 0xe3, 0x9e, 0x8a, 0xd1, 0x06, 0x55, 0xd1, 0xc9, - 0x6b, 0x98, 0xc1, 0x35, 0x94, 0x50, 0x45, 0xb9, 0x2b, 0x72, 0x98, 0x2a, 0x1c, 0x63, 0x71, 0xd7, - 0x38, 0xc2, 0x7e, 0xc9, 0x3e, 0xb5, 0x29, 0xe3, 0xe5, 0x8a, 0x8c, 0xab, 0xd2, 0x5c, 0x69, 0x90, - 0xe6, 0x87, 0x30, 0x90, 0x67, 0xa6, 0x97, 0x31, 0x3f, 0x4f, 0xd5, 0x69, 0x56, 0x81, 0xd2, 0xbf, - 0x59, 0x16, 0xab, 0x95, 0xc7, 0xfc, 0xff, 0xaf, 0xb1, 0x68, 0x95, 0xb7, 0x2d, 0x95, 0x5f, 0x85, - 0xa1, 0xa5, 0x5a, 0x16, 0x4a, 0x8d, 0x57, 0xc1, 0x98, 0xa6, 0x6b, 0xd5, 0x16, 0x52, 0xdb, 0x26, - 0xa8, 0x26, 0x2c, 0x68, 0x10, 0xd6, 0x65, 0x58, 0xc9, 0xd2, 0x98, 0x71, 0x95, 0x0e, 0x74, 0x97, - 0xc7, 0x4d, 0x63, 0xe6, 0xf2, 0x19, 0x3c, 0x4f, 0x2a, 0x66, 0xc1, 0x42, 0xde, 0xad, 0x5d, 0x77, - 0xeb, 0x13, 0xe8, 0xa8, 0xa6, 0x59, 0x14, 0xe3, 0xbe, 0xb8, 0xf7, 0xb1, 0x80, 0x58, 0x61, 0x67, - 0xde, 0x2c, 0x63, 0xd1, 0xa9, 0x7f, 0xcc, 0xc6, 0x03, 0x8e, 0x62, 0x40, 0xb4, 0x2b, 0x0d, 0x0d, - 0x57, 0xa2, 0xff, 0xd5, 0x82, 0xf6, 0xe3, 0xcc, 0x0f, 0x19, 0x96, 0x91, 0xa7, 0xe8, 0xf1, 0xde, - 0xe2, 0xb2, 0xce, 0x35, 0x31, 0xf0, 0x83, 0xc2, 0xf8, 0xa0, 0xd5, 0xf8, 0x81, 0x81, 0x61, 0xe8, - 0x67, 0xd9, 0xd2, 0xcf, 0x79, 0x3a, 0x35, 0x2c, 0xa1, 0x6d, 0x5b, 0x42, 0xb9, 0x9f, 0x55, 0x33, - 0x34, 0x28, 0xd9, 0xaf, 0x2d, 0x94, 0xfd, 0x65, 0xe8, 0x32, 0x71, 0xfd, 0xc3, 0x5b, 0x11, 0xc2, - 0x12, 0x4c, 0x50, 0x59, 0x89, 0xac, 0x9f, 0x5f, 0x89, 0xdc, 0x86, 0x5e, 0x80, 0x86, 0xc1, 0xb2, - 0x99, 0x9f, 0x15, 0xc2, 0x14, 0x16, 0x77, 0x4b, 0x2c, 0x5c, 0xfa, 0x31, 0x6c, 0x72, 0xa9, 0xdf, - 0x8b, 0xf0, 0x1c, 0x7a, 0x6d, 0xd4, 0x5a, 0xa2, 0x21, 0xeb, 0x18, 0x0d, 0x59, 0x7a, 0x07, 0xb6, - 0x6c, 0x64, 0x79, 0x08, 0x5e, 0x81, 0xd5, 0x02, 0xe1, 0xb5, 0x5a, 0x84, 0x63, 0xbb, 0x72, 0x92, - 0xfe, 0xb1, 0x03, 0x7d, 0x84, 0x44, 0xc9, 0xf1, 0x21, 0xd2, 0xcb, 0x51, 0xe0, 0xa7, 0xfe, 0x2b, - 0x2f, 0x67, 0x71, 0xac, 0x9a, 0x1f, 0x6a, 0x8c, 0x02, 0xc7, 0xdf, 0xd3, 0xb9, 0x4a, 0xdc, 0xd4, - 0x10, 0xcd, 0x30, 0x63, 0x39, 0xcb, 0x30, 0x35, 0xe2, 0x9f, 0x8a, 0x40, 0x62, 0x03, 0xd1, 0x41, - 0x4a, 0x00, 0x12, 0x11, 0x0a, 0xb5, 0x60, 0xf4, 0x96, 0xd8, 0x50, 0xb9, 0xa0, 0x37, 0xc9, 0x7d, - 0xff, 0xda, 0x81, 0xed, 0xca, 0x47, 0x52, 0x0c, 0xbb, 0xb0, 0xca, 0xe5, 0xa4, 0xc4, 0xf0, 0x91, - 0x29, 0x86, 0x1a, 0xfa, 0x75, 0x31, 0x94, 0xbd, 0x64, 0xf1, 0xe1, 0xe4, 0x11, 0x74, 0x0d, 0x70, - 0x43, 0x82, 0xf2, 0xb1, 0xdd, 0x4b, 0xde, 0x6e, 0x66, 0x61, 0xe4, 0x2d, 0xdf, 0x42, 0xef, 0x49, - 0x32, 0xfd, 0x25, 0x9e, 0x63, 0x90, 0x4b, 0xb0, 0x9e, 0x31, 0x59, 0xe9, 0xcb, 0x74, 0x45, 0x03, - 0xe8, 0x10, 0xfa, 0x92, 0xae, 0xbe, 0x45, 0x7f, 0x92, 0xc4, 0x69, 0xf0, 0xe2, 0x4d, 0x6f, 0xd1, - 0x7f, 0x0a, 0xc4, 0xfc, 0x40, 0x27, 0x54, 0x73, 0x0e, 0xad, 0x24, 0x54, 0x0a, 0xc8, 0x13, 0xaa, - 0xf7, 0xa1, 0x6b, 0xa2, 0x88, 0x4b, 0x37, 0xd0, 0x08, 0xf4, 0x8f, 0x1c, 0x18, 0x3e, 0x8d, 0x8a, - 0x93, 0x30, 0xf3, 0xcf, 0xde, 0x40, 0xa9, 0xd5, 0x17, 0x0d, 0xad, 0xf3, 0x5e, 0x34, 0x2c, 0x57, - 0x5f, 0x34, 0xf8, 0x71, 0x2c, 0x9b, 0x2f, 0xf8, 0xd3, 0x6c, 0xbb, 0xf6, 0x45, 0xdb, 0xf5, 0x36, - 0x8c, 0xf4, 0x62, 0xde, 0xae, 0xe7, 0x7a, 0xed, 0x2a, 0xac, 0x97, 0xfe, 0x4e, 0xd6, 0x60, 0x79, - 0xef, 0xc9, 0x6f, 0x8e, 0x96, 0x48, 0x07, 0x56, 0x8e, 0x0e, 0x0e, 0x0f, 0xc5, 0xf5, 0x06, 0xbf, - 0xf1, 0x68, 0x5d, 0xbb, 0x06, 0x2b, 0x18, 0x5d, 0xc8, 0x3a, 0xb4, 0x1f, 0xef, 0x7e, 0x73, 0xe0, - 0x8e, 0x96, 0xf0, 0xe7, 0x4f, 0xf8, 0x4f, 0x87, 0xf4, 0xa0, 0x73, 0xff, 0xc1, 0xe3, 0x03, 0xf7, - 0xc1, 0xee, 0xe1, 0xa8, 0x75, 0xed, 0x29, 0x74, 0x54, 0x76, 0x88, 0x48, 0xbb, 0x87, 0x07, 0xee, - 0x63, 0x81, 0x7f, 0xe0, 0xba, 0x0f, 0x5d, 0x41, 0xf7, 0xe9, 0xae, 0xfb, 0x60, 0xd4, 0xc2, 0x5f, - 0xf7, 0x1f, 0xfc, 0xf8, 0xe1, 0x68, 0x99, 0x74, 0x61, 0xed, 0xdb, 0x03, 0x77, 0xef, 0xe1, 0xd1, - 0xc1, 0x68, 0x05, 0x71, 0xef, 0x1e, 0xec, 0x3d, 0xf9, 0x6a, 0xd4, 0xe6, 0x1c, 0xdd, 0xdd, 0xfd, - 0x83, 0xd1, 0xea, 0xad, 0x7f, 0x77, 0x60, 0xed, 0xd9, 0x3c, 0xbc, 0x9f, 0x44, 0x05, 0x39, 0x00, - 0xd0, 0xaf, 0x24, 0xc8, 0xc5, 0xb2, 0xdb, 0x5f, 0x7d, 0x6b, 0x31, 0x99, 0x34, 0x4d, 0x49, 0xb3, - 0x5a, 0x22, 0xf7, 0xa0, 0x6b, 0x64, 0xde, 0x64, 0xb2, 0xb8, 0x44, 0x98, 0xbc, 0xd3, 0x38, 0x57, - 0x52, 0x3a, 0x00, 0xd0, 0x16, 0xa7, 0x17, 0x54, 0x33, 0x5b, 0xbd, 0xa0, 0xba, 0x81, 0xd2, 0xa5, - 0x5b, 0xff, 0x7c, 0x11, 0x96, 0x9f, 0xcd, 0x43, 0xf2, 0x0c, 0xba, 0xc6, 0x5b, 0x35, 0x52, 0xbb, - 0x49, 0xd3, 0xcb, 0x69, 0x7a, 0xd2, 0x36, 0xf9, 0xf9, 0x3f, 0xfe, 0xc7, 0x9f, 0xb4, 0xb6, 0xe8, - 0xf0, 0xc6, 0xcb, 0x5f, 0xbd, 0xe1, 0x87, 0xa1, 0xb2, 0xc5, 0xdb, 0xce, 0x35, 0xe2, 0xc2, 0x9a, - 0x7c, 0x8e, 0x46, 0x76, 0x0c, 0x1a, 0x46, 0x19, 0x37, 0xb9, 0x50, 0x83, 0x4b, 0xba, 0x3b, 0x9c, - 0xee, 0x88, 0x76, 0x25, 0x5d, 0x3c, 0xa6, 0x90, 0xe6, 0x1e, 0x2c, 0xef, 0xf9, 0x09, 0x21, 0xfa, - 0xa2, 0x5c, 0xc5, 0x84, 0xc9, 0xa6, 0x05, 0x93, 0x74, 0x08, 0xa7, 0xd3, 0xa3, 0x6b, 0x48, 0x67, - 0xea, 0x27, 0x48, 0xe3, 0x18, 0x06, 0xf6, 0x33, 0x24, 0xf2, 0xae, 0x79, 0xdf, 0x53, 0x7b, 0xff, - 0x34, 0x79, 0x6f, 0xd1, 0x74, 0x65, 0xb1, 0x03, 0x64, 0x12, 0x70, 0x1c, 0x8c, 0x0f, 0x24, 0x80, - 0x9e, 0xf9, 0x2a, 0x88, 0xe8, 0xb7, 0x29, 0xf5, 0xa7, 0x4e, 0x93, 0x4b, 0xcd, 0x93, 0x92, 0xc5, - 0x98, 0xb3, 0x20, 0x74, 0xc4, 0x59, 0x20, 0x86, 0xbc, 0x90, 0x42, 0x29, 0xcb, 0xa7, 0x40, 0x5a, - 0xca, 0xf6, 0x4b, 0x22, 0x2d, 0xe5, 0xea, 0x9b, 0x21, 0x4b, 0xca, 0x32, 0x26, 0xa2, 0x84, 0x7e, - 0x06, 0xfd, 0xa7, 0xfc, 0x35, 0x9c, 0x7c, 0x80, 0xa2, 0x29, 0xdb, 0xef, 0x57, 0x34, 0xe5, 0xca, - 0x4b, 0x15, 0x7a, 0x89, 0x53, 0xde, 0xa1, 0x1b, 0x48, 0x59, 0xbc, 0xac, 0x0b, 0x05, 0x0a, 0xd2, - 0xff, 0x1d, 0xe8, 0x5b, 0x6f, 0x4d, 0x48, 0xb9, 0xf9, 0xa6, 0x47, 0x2c, 0x93, 0x77, 0x17, 0xcc, - 0x36, 0xf1, 0x0a, 0x25, 0x0a, 0x7f, 0x9d, 0x82, 0xbc, 0x9e, 0x01, 0xe8, 0x37, 0x1b, 0xda, 0x5d, - 0x6a, 0xef, 0x44, 0xb4, 0xbb, 0xd4, 0x9f, 0x78, 0xd0, 0x4d, 0xce, 0xa2, 0x4f, 0xba, 0xc2, 0x8c, - 0x04, 0xad, 0x43, 0x58, 0x93, 0xaf, 0x13, 0xb4, 0x7c, 0xec, 0x27, 0x1a, 0x5a, 0x3e, 0x95, 0x67, - 0x0c, 0x74, 0xc4, 0x09, 0x02, 0xe9, 0x20, 0xc1, 0x08, 0x49, 0xfc, 0x16, 0x74, 0x8d, 0xab, 0x7d, - 0x62, 0xae, 0xa6, 0xf2, 0x0a, 0x40, 0x7b, 0x64, 0xc3, 0x5b, 0x00, 0xba, 0xc5, 0x29, 0x0f, 0x48, - 0x0f, 0x29, 0xab, 0xbe, 0x86, 0xa4, 0xae, 0xee, 0xee, 0x2d, 0xea, 0x95, 0x07, 0x01, 0x16, 0xf5, - 0xea, 0x65, 0xbf, 0x4d, 0x1d, 0x65, 0xcc, 0xd7, 0xfe, 0x14, 0x40, 0x5f, 0x33, 0x6b, 0x19, 0xd7, - 0xee, 0xcb, 0xb5, 0x8c, 0xeb, 0xb7, 0xd2, 0xca, 0x55, 0x09, 0x20, 0x69, 0x79, 0x19, 0x73, 0x0c, - 0x03, 0xfb, 0x15, 0x80, 0x76, 0xd5, 0xc6, 0x67, 0x03, 0xda, 0x55, 0x9b, 0x1f, 0x0f, 0x28, 0x8b, - 0x27, 0xc2, 0x55, 0x35, 0xd9, 0x23, 0x58, 0x2f, 0xef, 0xa7, 0xc9, 0xd8, 0x24, 0x62, 0x5e, 0x63, - 0x4f, 0x2e, 0x36, 0xcc, 0xa8, 0xb6, 0x04, 0xa7, 0xdc, 0x25, 0xeb, 0x48, 0x59, 0x5c, 0x53, 0x28, - 0xa2, 0xfc, 0xa5, 0x8c, 0x4d, 0xd4, 0xb8, 0xdc, 0xae, 0x10, 0x35, 0xaf, 0xb8, 0x2b, 0x44, 0x39, - 0x1d, 0x0f, 0xba, 0xc6, 0xed, 0xa7, 0xd6, 0x64, 0xfd, 0xea, 0x56, 0x6b, 0xb2, 0xe1, 0xba, 0x94, - 0x5e, 0xe0, 0xa4, 0x37, 0x44, 0xe4, 0x4e, 0x67, 0x2c, 0x51, 0x01, 0xe5, 0xb7, 0x01, 0x74, 0xc3, - 0x5a, 0x2b, 0xb3, 0x76, 0x95, 0xa1, 0x8d, 0xbb, 0xd2, 0xdf, 0xa6, 0x17, 0x39, 0xe9, 0x4d, 0x11, - 0x0f, 0xf9, 0x25, 0x02, 0x57, 0xe7, 0x6d, 0xe7, 0xda, 0x4d, 0x87, 0x3c, 0x87, 0x81, 0xc6, 0x3f, - 0x7a, 0x9d, 0x04, 0xe7, 0xb1, 0x98, 0x34, 0x4d, 0xc9, 0x0d, 0xbc, 0xcb, 0xb9, 0x5c, 0xa0, 0xc4, - 0xe6, 0x92, 0xbf, 0x4e, 0x02, 0xf4, 0xfb, 0x9f, 0x42, 0xd7, 0x78, 0x97, 0xa6, 0xe5, 0x54, 0x7f, - 0xac, 0x36, 0x69, 0x6a, 0xa9, 0xdb, 0x27, 0x9b, 0xac, 0x67, 0xf2, 0x33, 0x7f, 0x86, 0xb4, 0x13, - 0x18, 0xd8, 0x9d, 0x63, 0x6d, 0x96, 0x8d, 0x6d, 0x68, 0x6d, 0x96, 0x0b, 0x1a, 0xce, 0xd6, 0x5e, - 0x44, 0xc3, 0xd4, 0x3c, 0x49, 0xa7, 0x98, 0x3c, 0x94, 0x0d, 0x64, 0x33, 0x79, 0xa8, 0x36, 0xa9, - 0xcd, 0xe4, 0xa1, 0xd6, 0x71, 0xb6, 0xf7, 0x24, 0xd8, 0x28, 0xcd, 0x90, 0x0c, 0x86, 0x95, 0xee, - 0x2e, 0xa9, 0xac, 0xba, 0xda, 0x10, 0x9e, 0xbc, 0xbf, 0x70, 0x5e, 0xf2, 0x7b, 0x8f, 0xf3, 0x1b, - 0xd3, 0x4d, 0xcd, 0xcf, 0x8f, 0x63, 0xa1, 0x26, 0x71, 0xce, 0x80, 0xee, 0xd5, 0x6a, 0x3b, 0xa8, - 0xb5, 0x7b, 0x27, 0x93, 0xa6, 0x29, 0xc9, 0xc4, 0xb2, 0x36, 0xc1, 0x44, 0x65, 0x0b, 0x53, 0xe8, - 0x1a, 0x1d, 0x44, 0x2d, 0xb7, 0x7a, 0x73, 0x52, 0xcb, 0xad, 0xa9, 0xe5, 0x68, 0xc9, 0x2d, 0x67, - 0x45, 0x9c, 0x1e, 0xf3, 0x16, 0x25, 0xf2, 0xf8, 0x16, 0x3a, 0xaa, 0xf7, 0x48, 0x4a, 0x8f, 0xa8, - 0x34, 0x28, 0x27, 0xe3, 0xfa, 0x44, 0xc5, 0x0d, 0x79, 0x40, 0xcd, 0xe5, 0x2c, 0xd2, 0x65, 0x30, - 0xac, 0xf4, 0x2f, 0xb5, 0x3e, 0x9a, 0x1b, 0x9b, 0x13, 0xfb, 0x79, 0x9d, 0xb8, 0x59, 0xa6, 0xef, - 0x70, 0x06, 0xdb, 0x84, 0xeb, 0x20, 0x57, 0x1f, 0x0a, 0x1d, 0xdc, 0x74, 0xc8, 0xac, 0xd2, 0xcf, - 0x94, 0x8d, 0x31, 0x23, 0xd0, 0x36, 0xb6, 0x3b, 0x27, 0x4d, 0x17, 0x42, 0xf4, 0x7b, 0x9c, 0xd7, - 0x3b, 0xe4, 0xa2, 0xc5, 0x0b, 0xbd, 0x46, 0xdd, 0x87, 0xdd, 0x74, 0xc8, 0x14, 0x06, 0x36, 0xc9, - 0xb7, 0x62, 0x55, 0x71, 0x4f, 0x42, 0x6a, 0xac, 0x90, 0xc7, 0xef, 0x19, 0xcd, 0x5f, 0xab, 0x8d, - 0x4b, 0xae, 0x34, 0xf3, 0xaa, 0xb4, 0x79, 0x27, 0x5b, 0x26, 0x4f, 0x35, 0x49, 0x29, 0x67, 0x7a, - 0x89, 0x4c, 0xea, 0x4c, 0x7d, 0x89, 0xc3, 0x23, 0x5c, 0xcf, 0x6c, 0x30, 0xe8, 0xb4, 0xaf, 0xa1, - 0x47, 0xa1, 0xd3, 0xbe, 0xa6, 0x9e, 0x84, 0x52, 0x9e, 0x48, 0xfb, 0x78, 0x03, 0xe2, 0x44, 0x60, - 0x88, 0x3c, 0xb6, 0xd2, 0x88, 0xb8, 0xb4, 0xa0, 0x54, 0xaf, 0x64, 0x51, 0x8d, 0x85, 0xbc, 0x72, - 0x23, 0xb2, 0xa1, 0x58, 0x45, 0xc9, 0xb1, 0xa8, 0xe7, 0xc9, 0xd7, 0xd0, 0xe6, 0x55, 0x32, 0xd9, - 0xd2, 0x15, 0x85, 0x2e, 0xc6, 0x27, 0xdb, 0x15, 0xa8, 0x9d, 0x2a, 0x50, 0x7e, 0x76, 0xcd, 0x13, - 0x99, 0x7c, 0x4f, 0x61, 0x20, 0x52, 0x4b, 0x55, 0x4b, 0x6a, 0xa7, 0xa9, 0x94, 0xba, 0xda, 0x69, - 0xaa, 0x65, 0xa7, 0x1d, 0x2e, 0x45, 0x76, 0x79, 0x26, 0x71, 0x6e, 0x3b, 0xd7, 0xa6, 0xab, 0xfc, - 0x5f, 0x38, 0x9f, 0xfe, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7a, 0x9c, 0x44, 0x52, 0xb0, 0x33, - 0x00, 0x00, + 0x56, 0x9d, 0xf5, 0xd1, 0x55, 0xfd, 0xea, 0xb3, 0xa3, 0x3f, 0x5c, 0xae, 0xb1, 0x67, 0xbc, 0x81, + 0x3d, 0xf2, 0xd8, 0x33, 0xb6, 0xe9, 0x61, 0x99, 0x1d, 0xef, 0x7a, 0x34, 0xdd, 0xed, 0x5a, 0xdb, + 0x33, 0x35, 0xdd, 0x56, 0xb6, 0x3d, 0x36, 0x2b, 0xd8, 0x54, 0x56, 0x66, 0xb8, 0x3b, 0x71, 0x76, + 0x66, 0x4d, 0x66, 0x96, 0xdb, 0x0d, 0x17, 0xb4, 0xe2, 0x04, 0x07, 0x0e, 0x88, 0x33, 0x9c, 0x10, + 0x12, 0x88, 0x2b, 0xe2, 0x80, 0xc4, 0x99, 0x2b, 0x07, 0x10, 0x70, 0x41, 0xe2, 0x17, 0x20, 0xae, + 0x48, 0x28, 0xbe, 0x32, 0x22, 0x32, 0xb3, 0xbc, 0xf6, 0x08, 0xb8, 0xb4, 0x2a, 0xde, 0x7b, 0xf9, + 0x5e, 0xc4, 0xfb, 0x8a, 0x17, 0x2f, 0xa2, 0xa1, 0xfb, 0x7a, 0xe1, 0x27, 0x73, 0xef, 0xd6, 0x3c, + 0x89, 0xb3, 0x18, 0xad, 0xf2, 0xd1, 0x78, 0xdd, 0x8d, 0xa2, 0x38, 0x73, 0xb3, 0x20, 0x8e, 0x52, + 0x8e, 0xc2, 0x5b, 0xb0, 0xb1, 0xeb, 0xfb, 0xfb, 0x8b, 0x24, 0x21, 0x91, 0x77, 0x6e, 0x93, 0x74, + 0x1e, 0x47, 0x29, 0xc1, 0x3f, 0x87, 0xfe, 0xae, 0xef, 0x3f, 0x76, 0x83, 0xc4, 0x26, 0xdf, 0x2d, + 0x48, 0x9a, 0xa1, 0xab, 0xd0, 0x9b, 0xb9, 0x29, 0x71, 0x3c, 0x41, 0x3a, 0xb2, 0xae, 0x58, 0xd7, + 0xd7, 0x6c, 0x13, 0x88, 0x3e, 0x84, 0xfe, 0x77, 0x8b, 0x38, 0xd3, 0xc8, 0x6a, 0x8c, 0xac, 0x00, + 0xc5, 0xeb, 0x30, 0xc8, 0xf9, 0x0b, 0x91, 0x7f, 0x67, 0x41, 0x73, 0x37, 0x24, 0x49, 0x86, 0x6e, + 0x42, 0x23, 0x3b, 0x9f, 0x13, 0x26, 0xa1, 0xbf, 0x73, 0xe1, 0x96, 0x58, 0x0b, 0x43, 0xf2, 0xbf, + 0x4f, 0xce, 0xe7, 0xc4, 0x66, 0x44, 0x68, 0x04, 0xad, 0x53, 0x92, 0xa6, 0xee, 0x31, 0x11, 0xa2, + 0xe4, 0x10, 0xfd, 0x84, 0xce, 0x38, 0x74, 0x23, 0x8f, 0x38, 0x2e, 0xfd, 0x68, 0x54, 0xbf, 0x62, + 0x5d, 0xef, 0xec, 0x6c, 0x4a, 0x7e, 0x7b, 0x1c, 0xc9, 0x18, 0x3e, 0x5c, 0xb1, 0x4d, 0x62, 0x7c, + 0x15, 0xd6, 0x72, 0x51, 0xe8, 0x02, 0x6c, 0x4c, 0x0f, 0x9f, 0x39, 0x4f, 0xec, 0xdd, 0xfb, 0x8f, + 0x0e, 0x1e, 0x38, 0x7b, 0xbb, 0xd3, 0xdd, 0x83, 0xfd, 0xc9, 0x70, 0x65, 0x6f, 0x0d, 0x5a, 0x73, + 0xf7, 0x3c, 0x8c, 0x5d, 0x1f, 0xff, 0x4d, 0x0d, 0x5a, 0x82, 0x25, 0x55, 0x56, 0x16, 0x67, 0x6e, + 0xe8, 0x08, 0x9e, 0x6c, 0x29, 0x0d, 0xdb, 0x04, 0xa2, 0xeb, 0x30, 0xf0, 0x4e, 0xdc, 0x28, 0x22, + 0x8a, 0xae, 0xc6, 0xe8, 0x8a, 0x60, 0xf4, 0x23, 0xb8, 0x30, 0x27, 0x91, 0x1f, 0x44, 0xc7, 0x4e, + 0xf1, 0x8b, 0x3a, 0xfb, 0x62, 0x19, 0x1a, 0xdd, 0x85, 0x51, 0x10, 0xb9, 0x5e, 0x16, 0xbc, 0x22, + 0xa5, 0x4f, 0x1b, 0xec, 0xd3, 0xa5, 0x78, 0x6a, 0xcc, 0x33, 0x37, 0x0c, 0x49, 0x96, 0x7f, 0xd1, + 0x64, 0x5f, 0x14, 0xa0, 0xe8, 0x0b, 0x18, 0x2f, 0x22, 0x2f, 0x8e, 0x5e, 0x04, 0xc9, 0x29, 0xf1, + 0x9d, 0xc2, 0x37, 0xab, 0xec, 0x9b, 0x37, 0x50, 0xe0, 0x7f, 0xb6, 0xa0, 0xab, 0x1b, 0xe3, 0x2d, + 0xd5, 0xf7, 0x09, 0x34, 0xd2, 0xc0, 0xe7, 0x3a, 0xeb, 0xef, 0x5c, 0xac, 0x32, 0xeb, 0xad, 0xa3, + 0xc0, 0x27, 0x36, 0x23, 0x43, 0x9b, 0xd0, 0x9c, 0xc5, 0x8b, 0xc8, 0x67, 0x1a, 0xeb, 0xd9, 0x7c, + 0x80, 0x30, 0x74, 0x29, 0xb6, 0xa0, 0x13, 0x03, 0x86, 0xc6, 0xd0, 0xce, 0xdd, 0xb9, 0xc9, 0x7c, + 0x2c, 0x1f, 0xe3, 0xcb, 0xd0, 0xa0, 0x32, 0x10, 0xc0, 0xaa, 0x3d, 0xf9, 0xe6, 0xf0, 0xc9, 0x64, + 0xb8, 0x82, 0xd6, 0xa0, 0x39, 0x3d, 0xdc, 0xdf, 0x9d, 0x0e, 0x2d, 0xfc, 0xeb, 0x00, 0x7b, 0x6e, + 0x24, 0x63, 0xe8, 0x3a, 0x0c, 0xa2, 0xd8, 0x27, 0x4e, 0xe0, 0x93, 0x28, 0x0b, 0x5e, 0x04, 0x24, + 0x11, 0x51, 0x54, 0x04, 0xe3, 0x1e, 0x74, 0xd8, 0x77, 0x22, 0x36, 0x3e, 0x83, 0xe6, 0xfe, 0x89, + 0x1b, 0x44, 0x74, 0x11, 0x1e, 0xfd, 0x21, 0xbe, 0xe3, 0x03, 0x1a, 0x03, 0x11, 0xc9, 0xce, 0xe2, + 0xe4, 0xa5, 0x8c, 0x01, 0x31, 0xc4, 0x73, 0x68, 0xef, 0x73, 0xab, 0xa6, 0x68, 0x1b, 0x56, 0xb9, + 0xa1, 0xd9, 0xc7, 0x3d, 0x5b, 0x8c, 0xe8, 0xf2, 0xa4, 0x0b, 0xb0, 0xcf, 0x7b, 0x76, 0x3e, 0xa6, + 0x9c, 0x85, 0x67, 0x09, 0xb5, 0xc9, 0x21, 0xe5, 0xe6, 0x85, 0x71, 0x4a, 0x7c, 0xa6, 0xb2, 0x9e, + 0x2d, 0x46, 0xd8, 0x81, 0x2d, 0x2a, 0xf1, 0x98, 0x3c, 0x76, 0xd3, 0xf4, 0x2c, 0x4e, 0x7c, 0xb9, + 0x78, 0x0c, 0xdd, 0x88, 0x9c, 0x39, 0x73, 0x01, 0x16, 0x2b, 0x30, 0x60, 0x94, 0x26, 0x0e, 0x7d, + 0x45, 0xc3, 0x57, 0x63, 0xc0, 0xf0, 0x08, 0xb6, 0x8b, 0x02, 0x54, 0x06, 0xd9, 0xd8, 0xa7, 0xb3, + 0x10, 0x4b, 0x7e, 0x67, 0xb5, 0x1b, 0x96, 0xae, 0x99, 0x96, 0xa6, 0xaa, 0x7f, 0x11, 0x27, 0x22, + 0xe2, 0xda, 0x36, 0x1f, 0xa0, 0x2b, 0xd0, 0xf1, 0x49, 0x9a, 0x05, 0x11, 0xcb, 0xaa, 0x4c, 0x17, + 0x6b, 0xb6, 0x0e, 0x62, 0x6a, 0x3f, 0x8d, 0x17, 0x51, 0x26, 0xa2, 0x47, 0x8c, 0xd0, 0x10, 0xea, + 0x2f, 0x88, 0x0c, 0x0f, 0xfa, 0x13, 0x7f, 0x09, 0x9b, 0xe6, 0xf4, 0xf9, 0xba, 0xe8, 0xfc, 0xb3, + 0xc4, 0x8d, 0x52, 0x6a, 0x93, 0x38, 0x72, 0x02, 0x3f, 0x1d, 0x59, 0x57, 0xea, 0x74, 0xfe, 0x05, + 0x30, 0xfe, 0x18, 0xfa, 0xfb, 0x71, 0x14, 0x11, 0x2f, 0x93, 0x6b, 0x1f, 0x43, 0x9b, 0x2d, 0x72, + 0x91, 0x04, 0x62, 0xd1, 0xf9, 0x98, 0x26, 0xe1, 0x9c, 0x5a, 0xa8, 0xf0, 0x36, 0xac, 0xef, 0x27, + 0xc4, 0xcd, 0xc8, 0x41, 0xec, 0x13, 0x8d, 0x47, 0xc1, 0x6a, 0xf9, 0x18, 0xff, 0x89, 0x05, 0x48, + 0xff, 0x42, 0x4c, 0xf9, 0x57, 0xa0, 0x97, 0x12, 0xe2, 0x3b, 0xa7, 0x11, 0x39, 0x8d, 0xa3, 0xc0, + 0x13, 0x13, 0xee, 0x52, 0xe0, 0x37, 0x02, 0x86, 0x3e, 0x82, 0x61, 0x10, 0x05, 0x59, 0xe0, 0x86, + 0xc1, 0xef, 0x10, 0xdf, 0x09, 0x23, 0x3f, 0x1d, 0xd5, 0xf8, 0xc2, 0x34, 0xf8, 0x34, 0xf2, 0x53, + 0x74, 0x1b, 0x36, 0x74, 0x52, 0x8f, 0x4e, 0xfb, 0x75, 0x26, 0x4c, 0x81, 0x34, 0xd4, 0x3e, 0xc7, + 0xe0, 0x7f, 0xb2, 0xa0, 0x2d, 0x77, 0x35, 0xc3, 0xac, 0x56, 0xc1, 0xac, 0xf7, 0xa0, 0x93, 0x9e, + 0xb9, 0x73, 0xc7, 0x0b, 0x03, 0x12, 0x65, 0x22, 0x99, 0xbc, 0x27, 0x93, 0x89, 0x64, 0x71, 0xeb, + 0xe8, 0xcc, 0x9d, 0xef, 0x33, 0x12, 0x5b, 0xa7, 0xe7, 0xa9, 0xea, 0x25, 0x89, 0x1c, 0xd7, 0xf7, + 0x13, 0x92, 0xa6, 0x6c, 0x4a, 0x6b, 0xb6, 0x09, 0xa4, 0x99, 0xd4, 0x27, 0x5e, 0x70, 0xea, 0x86, + 0xce, 0x3c, 0x74, 0x3d, 0x92, 0x8a, 0xa0, 0x29, 0x40, 0x31, 0x06, 0x50, 0x82, 0x50, 0x0b, 0xea, + 0xd3, 0x83, 0xfb, 0xc3, 0x15, 0xd4, 0x81, 0xd6, 0xfe, 0xe1, 0xc1, 0xc1, 0xe4, 0xf9, 0x93, 0x61, + 0x8d, 0xda, 0xf8, 0x3e, 0x99, 0xc7, 0x69, 0xa0, 0xdb, 0x78, 0xd9, 0xf2, 0xf0, 0x4d, 0x18, 0xe4, + 0xd4, 0xc2, 0x36, 0x23, 0x68, 0xc9, 0xc9, 0x72, 0x6a, 0x39, 0xa4, 0x0e, 0x78, 0x3f, 0x48, 0xbd, + 0xf8, 0x15, 0x49, 0xa8, 0x35, 0xd3, 0x77, 0xcf, 0x5b, 0x3f, 0x84, 0xad, 0x02, 0x07, 0x21, 0xf4, + 0x12, 0xac, 0x45, 0x8b, 0x53, 0x87, 0xd2, 0xa7, 0x22, 0xff, 0x28, 0x00, 0xfe, 0x03, 0x0b, 0xd0, + 0xe4, 0x35, 0xf1, 0x16, 0x19, 0xa1, 0xeb, 0xd7, 0x16, 0x16, 0x27, 0x3e, 0x49, 0x9c, 0x20, 0x77, + 0x3c, 0x39, 0x66, 0x99, 0xc9, 0x0d, 0x18, 0x4a, 0xe4, 0x3c, 0x31, 0xa4, 0x49, 0x64, 0x4e, 0x48, + 0xe2, 0xcc, 0x17, 0x33, 0xe7, 0x25, 0x39, 0x17, 0x16, 0x31, 0x60, 0x94, 0xf3, 0x77, 0x0b, 0x37, + 0xca, 0x82, 0xec, 0x5c, 0xa4, 0xfc, 0x7c, 0x4c, 0x63, 0xe0, 0x01, 0xc9, 0xc4, 0x36, 0xf2, 0x36, + 0x3a, 0xfe, 0x0b, 0x0b, 0x90, 0xfe, 0x85, 0x58, 0xf2, 0x7d, 0x68, 0x8b, 0x1d, 0x84, 0xc7, 0x6b, + 0x67, 0xe7, 0xba, 0x74, 0xab, 0x32, 0xb5, 0xdc, 0xb6, 0xd2, 0x49, 0x94, 0x25, 0xe7, 0x76, 0xfe, + 0xe5, 0x78, 0x0a, 0x3d, 0x03, 0x45, 0xf3, 0x06, 0x5d, 0x15, 0x9f, 0x04, 0xfd, 0x89, 0xae, 0x41, + 0xf3, 0x95, 0x1b, 0x2e, 0x78, 0xf6, 0xee, 0xec, 0x0c, 0x0a, 0x3b, 0xa1, 0xcd, 0xb1, 0x77, 0x6b, + 0x3f, 0xb2, 0xf0, 0x10, 0xfa, 0x0f, 0x48, 0xf6, 0x28, 0x7a, 0x11, 0x8b, 0x85, 0xe1, 0x7f, 0xa9, + 0xc3, 0x20, 0x07, 0x29, 0x0f, 0x79, 0x45, 0x92, 0x94, 0x26, 0x34, 0xe1, 0x21, 0x62, 0xc8, 0x92, + 0x38, 0x35, 0xb9, 0xd4, 0xad, 0x48, 0xd0, 0x3a, 0x0c, 0x21, 0x68, 0x2c, 0x92, 0x80, 0x46, 0x02, + 0x0d, 0x65, 0xf6, 0x5b, 0x9a, 0x9f, 0xda, 0x40, 0xfa, 0xbe, 0x02, 0xe4, 0x58, 0x37, 0x48, 0x52, + 0x96, 0x25, 0x25, 0x96, 0x02, 0xd0, 0x4d, 0x58, 0x65, 0x56, 0x4f, 0x59, 0xae, 0xec, 0xec, 0x6c, + 0xc8, 0xf5, 0x1d, 0x32, 0xe8, 0x3e, 0xcd, 0xa6, 0xb6, 0x20, 0x41, 0x3b, 0x50, 0x0f, 0x23, 0x7f, + 0xd4, 0x62, 0xfa, 0xbe, 0xa2, 0xe9, 0x5b, 0x5f, 0xe0, 0xad, 0x69, 0xe4, 0x73, 0x3d, 0x53, 0x62, + 0x9a, 0xd9, 0xdd, 0x30, 0x70, 0xd3, 0xd1, 0x1a, 0xdf, 0x54, 0xd9, 0x40, 0xdf, 0x54, 0xc1, 0xd8, + 0x54, 0xd1, 0x1d, 0xd8, 0x90, 0xe5, 0x16, 0x4b, 0x05, 0x27, 0x6e, 0x7a, 0x42, 0xd2, 0x51, 0x87, + 0xad, 0xb7, 0x0a, 0x85, 0x3e, 0x81, 0x96, 0x4c, 0x59, 0x5d, 0x73, 0x0d, 0x22, 0x5f, 0xb1, 0xd9, + 0x49, 0x9a, 0xf1, 0x03, 0x68, 0xcb, 0x19, 0xbe, 0x83, 0xb9, 0xa7, 0x91, 0xcf, 0xd8, 0x68, 0xe6, + 0xde, 0x64, 0x8e, 0x29, 0x13, 0xae, 0x34, 0xf9, 0x8f, 0x61, 0xc3, 0x80, 0x0a, 0xab, 0x5f, 0xad, + 0xce, 0xd9, 0x26, 0x10, 0x7f, 0xc1, 0x58, 0xd2, 0xe0, 0xd6, 0xbc, 0xe8, 0x1d, 0x32, 0x84, 0xcd, + 0x84, 0xab, 0xef, 0xf3, 0x0d, 0x63, 0x90, 0x90, 0xf9, 0x82, 0x1f, 0x4e, 0x8e, 0xbc, 0x38, 0xe1, + 0x55, 0xca, 0xba, 0x0d, 0x0a, 0x4c, 0xb7, 0xd2, 0x19, 0xdd, 0x1a, 0x79, 0xc8, 0xb7, 0x6d, 0x31, + 0xc2, 0x17, 0x60, 0x6b, 0x1a, 0xa4, 0x99, 0x48, 0xd6, 0x41, 0x9e, 0xb8, 0xf0, 0x57, 0xb0, 0x5d, + 0x44, 0x08, 0x79, 0x77, 0x00, 0xbc, 0x1c, 0x2a, 0xc2, 0x73, 0x58, 0xcc, 0xfa, 0xb6, 0x46, 0x83, + 0xff, 0xc1, 0x82, 0x75, 0xca, 0x8c, 0x7b, 0x9d, 0x5c, 0xb8, 0x96, 0x86, 0x2c, 0x33, 0x0d, 0xfd, + 0x10, 0x9a, 0xf1, 0x59, 0x44, 0x12, 0xb1, 0xa5, 0x7c, 0x90, 0x9b, 0xa9, 0xc8, 0xe3, 0xd6, 0x21, + 0x25, 0xb3, 0x39, 0x35, 0x75, 0xc6, 0x30, 0x38, 0x0d, 0x32, 0x59, 0xa6, 0xb2, 0x01, 0xd5, 0x6f, + 0x10, 0x79, 0xe1, 0xc2, 0xa7, 0xc7, 0x93, 0xc0, 0x4d, 0xc5, 0x0e, 0xd2, 0xb6, 0x8b, 0x60, 0x7c, + 0x15, 0x9a, 0x8c, 0x1f, 0x6a, 0x43, 0x63, 0xef, 0xf0, 0xc9, 0xc3, 0xe1, 0x0a, 0xdd, 0x47, 0x0e, + 0x9f, 0x1d, 0x0c, 0x2d, 0x0a, 0x7a, 0x3c, 0x99, 0xd8, 0xc3, 0x1a, 0xfe, 0x53, 0x0b, 0x90, 0x3e, + 0x11, 0xa1, 0x95, 0x2f, 0xf2, 0x50, 0xe3, 0x1a, 0xf9, 0xb0, 0x6a, 0xd2, 0x22, 0x86, 0xf8, 0x90, + 0x87, 0x91, 0xf8, 0x6a, 0xfc, 0x08, 0x3a, 0x1a, 0xb8, 0xc2, 0x77, 0xaf, 0x9a, 0xbe, 0xdb, 0x37, + 0x43, 0x59, 0x77, 0x5d, 0x04, 0x43, 0x2a, 0x94, 0x1e, 0x11, 0x73, 0x73, 0x7e, 0xc4, 0x2d, 0x20, + 0x60, 0x62, 0xce, 0x9b, 0xd0, 0xe4, 0x89, 0x83, 0xbb, 0x2b, 0x1f, 0xe4, 0x9f, 0x13, 0xa5, 0x67, + 0xfc, 0x99, 0xf8, 0x9c, 0xe8, 0x4b, 0xc6, 0xd0, 0xe4, 0x59, 0x89, 0xaf, 0xb8, 0x2b, 0x67, 0x44, + 0xa9, 0x6c, 0x8e, 0xc2, 0xff, 0x66, 0x41, 0x4b, 0x44, 0x17, 0xf5, 0xc1, 0x34, 0x73, 0xb3, 0x85, + 0xdc, 0x3c, 0xc5, 0x08, 0x7d, 0x0c, 0x6d, 0x71, 0x7e, 0x4a, 0xc5, 0xe2, 0x94, 0x3b, 0x09, 0xb8, + 0x9d, 0x53, 0xa0, 0x6b, 0xb0, 0xca, 0x4a, 0x77, 0x9e, 0x25, 0x3b, 0x3b, 0x3d, 0x8d, 0x36, 0x88, + 0x6c, 0x81, 0xa4, 0xd5, 0xe5, 0x2c, 0x8c, 0xbd, 0x97, 0x27, 0x24, 0x38, 0x3e, 0xc9, 0x44, 0xe2, + 0xd4, 0x41, 0x79, 0xb2, 0x6d, 0x6a, 0xc9, 0x56, 0x4b, 0xdf, 0xab, 0x66, 0xfa, 0xce, 0x33, 0x5d, + 0x4b, 0xcb, 0x74, 0xf8, 0x2b, 0xe8, 0xb3, 0x78, 0x54, 0x75, 0x70, 0x31, 0xcd, 0x5b, 0x15, 0x69, + 0x3e, 0xe7, 0x55, 0xd3, 0x79, 0xfd, 0xb9, 0x05, 0xe8, 0x70, 0x4e, 0xa2, 0xff, 0x93, 0x12, 0x5c, + 0x95, 0xd2, 0x75, 0xa3, 0x94, 0xbe, 0x02, 0x9d, 0xf9, 0x22, 0x3d, 0x71, 0x04, 0x92, 0x6f, 0xe8, + 0x3a, 0x48, 0x16, 0xdb, 0x4d, 0x55, 0x6c, 0xdf, 0x83, 0x0d, 0x63, 0x9e, 0xc2, 0x1d, 0x3e, 0x84, + 0xbe, 0x59, 0x54, 0x8b, 0x79, 0x16, 0xa0, 0xf8, 0xef, 0x6b, 0xd0, 0x64, 0x4e, 0xcb, 0xfc, 0x2f, + 0x09, 0xc4, 0x21, 0xd5, 0xb2, 0xf9, 0xc0, 0x28, 0x30, 0x6a, 0x66, 0x81, 0xa1, 0xe7, 0x8c, 0xba, + 0x99, 0x33, 0xfa, 0x50, 0x0b, 0x7c, 0x71, 0x88, 0xa8, 0x05, 0x3e, 0xfa, 0xb2, 0xac, 0xb6, 0x26, + 0xf3, 0xad, 0x6d, 0xe9, 0x2f, 0xa6, 0xe1, 0x2a, 0xd5, 0x19, 0xc6, 0x9e, 0x1b, 0x52, 0x61, 0xdc, + 0x19, 0xf2, 0x31, 0x7a, 0x1f, 0xc0, 0x63, 0xa5, 0xbb, 0xef, 0xb8, 0x19, 0x73, 0x89, 0x86, 0xad, + 0x41, 0xd0, 0x35, 0x71, 0xc0, 0x6e, 0xb3, 0x04, 0xb6, 0x6e, 0xc4, 0xaa, 0x76, 0xb0, 0xc6, 0xd0, + 0x0d, 0x52, 0x27, 0x3e, 0x8b, 0x1c, 0x96, 0x05, 0xd8, 0x2e, 0xda, 0xb6, 0x0d, 0x18, 0x75, 0xd3, + 0x93, 0x38, 0xf4, 0xd9, 0x4e, 0xda, 0xb0, 0xd9, 0x6f, 0xfc, 0x67, 0x16, 0x74, 0x19, 0x2f, 0x9b, + 0x9c, 0xc6, 0xaf, 0xdc, 0xd0, 0xd0, 0x99, 0xb5, 0x5c, 0x67, 0x85, 0x72, 0x4f, 0x2f, 0x12, 0xeb, + 0x85, 0x22, 0x51, 0x5f, 0x7d, 0xa3, 0xb0, 0xfa, 0xe2, 0xb4, 0x9b, 0xe5, 0x69, 0xe3, 0x13, 0x58, + 0xe5, 0x99, 0x09, 0x7d, 0x02, 0x30, 0x5b, 0x9c, 0x3b, 0x46, 0x76, 0xec, 0x19, 0x1a, 0xb1, 0x35, + 0x02, 0x74, 0x1b, 0x3a, 0x29, 0x09, 0x43, 0x49, 0x5f, 0xab, 0xa2, 0xd7, 0x29, 0xf0, 0xa7, 0x32, + 0x73, 0xb2, 0x72, 0x86, 0xea, 0x8b, 0xa6, 0x1e, 0x51, 0x29, 0xb3, 0xdf, 0xd4, 0x87, 0xe3, 0xb3, + 0x48, 0x1c, 0xd1, 0xe9, 0x4f, 0xfc, 0x0b, 0x4b, 0x7c, 0xf5, 0x74, 0xee, 0xbb, 0x19, 0xa1, 0x95, + 0x01, 0x5f, 0x8b, 0xc5, 0x9c, 0xc4, 0x94, 0xf7, 0x70, 0xc5, 0xe6, 0x58, 0xf4, 0x13, 0xe8, 0x71, + 0x0d, 0x25, 0x5c, 0xf1, 0x22, 0x5f, 0x6d, 0x9a, 0xd3, 0xe3, 0xb8, 0x87, 0x2b, 0xb6, 0x49, 0xbc, + 0xd7, 0x87, 0x2e, 0x07, 0x2c, 0x98, 0x50, 0xfc, 0xaf, 0x35, 0x68, 0xd0, 0x64, 0xb9, 0xfc, 0x5c, + 0xf1, 0x56, 0x55, 0xe3, 0x97, 0xd0, 0x0d, 0x23, 0x5f, 0x0e, 0x65, 0x5e, 0xbc, 0xa4, 0xa7, 0x63, + 0x5a, 0xe1, 0x3c, 0x5e, 0xcc, 0xbe, 0x26, 0xe7, 0x62, 0xdb, 0x31, 0xbe, 0xa0, 0xf2, 0x83, 0x88, + 0xb7, 0x78, 0xf8, 0xde, 0x28, 0x87, 0x6a, 0x8b, 0x68, 0x6a, 0x5b, 0x04, 0xcd, 0x1a, 0xaf, 0x17, + 0xbe, 0x63, 0xa6, 0x4a, 0x1d, 0x84, 0x3e, 0x86, 0xf5, 0x94, 0x78, 0x71, 0xe4, 0xa7, 0xfc, 0xc4, + 0xe9, 0x65, 0xc4, 0x67, 0x71, 0xd2, 0xb3, 0xcb, 0x88, 0xea, 0x32, 0x72, 0x7c, 0x0f, 0x06, 0x85, + 0x69, 0x57, 0x6c, 0x8b, 0x9b, 0xfa, 0xb6, 0xb8, 0xa6, 0x6f, 0x83, 0xbf, 0x57, 0x83, 0xf5, 0xc7, + 0xf4, 0x70, 0x28, 0x8c, 0xc2, 0xd3, 0xe9, 0xff, 0x66, 0xce, 0xd1, 0xe3, 0xa7, 0x51, 0x88, 0x1f, + 0x99, 0x01, 0x9a, 0x6f, 0xce, 0x00, 0x37, 0x60, 0x98, 0x10, 0x76, 0x84, 0x75, 0x72, 0x56, 0x5c, + 0x9d, 0x25, 0x38, 0x2d, 0x9e, 0x83, 0xd3, 0x53, 0xe2, 0x07, 0x6e, 0x46, 0xa1, 0x8e, 0x47, 0x8f, + 0x28, 0x21, 0xd3, 0x6a, 0xdb, 0xae, 0x42, 0x51, 0x15, 0x20, 0x5d, 0x05, 0x22, 0x53, 0x7f, 0x0e, + 0xc3, 0x20, 0xca, 0x48, 0x12, 0xb9, 0xa1, 0x73, 0xea, 0x66, 0xde, 0x09, 0x59, 0x12, 0x97, 0x25, + 0x32, 0xf4, 0x63, 0xe8, 0xb3, 0xea, 0x3c, 0x5d, 0x78, 0x1e, 0x49, 0x69, 0x31, 0xc5, 0x03, 0x34, + 0xaf, 0xca, 0xe9, 0x21, 0xf4, 0x88, 0x23, 0xed, 0x02, 0x29, 0xfa, 0x8c, 0x56, 0xaa, 0xa7, 0x6e, + 0x10, 0xd1, 0x22, 0x9f, 0x87, 0x5b, 0xbd, 0x22, 0xdc, 0xec, 0x22, 0x15, 0xfa, 0x1c, 0x7a, 0x8c, + 0xd5, 0x0b, 0x37, 0x08, 0x17, 0x09, 0xab, 0xe0, 0x4a, 0x42, 0x7f, 0xca, 0x71, 0xb6, 0x49, 0x89, + 0xff, 0xd3, 0x82, 0x81, 0x52, 0xc1, 0xe4, 0x15, 0x89, 0x68, 0x76, 0x6e, 0xb2, 0xf5, 0x2c, 0x0d, + 0x76, 0x86, 0x45, 0x9f, 0x43, 0x57, 0x5f, 0x80, 0x88, 0xf5, 0xaa, 0x95, 0x3e, 0x5c, 0xb1, 0x0d, + 0x52, 0xf4, 0xf9, 0xdb, 0xad, 0xf4, 0xe1, 0x4a, 0xd5, 0x5a, 0xbb, 0xfa, 0x0a, 0x98, 0x63, 0x55, + 0x2f, 0x35, 0x97, 0x2a, 0x48, 0xf7, 0x5a, 0xd0, 0x24, 0x74, 0x81, 0x38, 0x86, 0x8e, 0x76, 0x3a, + 0x5a, 0x5a, 0x78, 0x69, 0x69, 0xa7, 0x66, 0xa6, 0x1d, 0xad, 0x0e, 0x6a, 0x94, 0xea, 0x20, 0xde, + 0x46, 0x6d, 0x6a, 0x6d, 0x54, 0xfc, 0x29, 0x6c, 0xb1, 0xac, 0x47, 0xd4, 0x75, 0xc8, 0x2f, 0x3f, + 0xfc, 0x8f, 0x60, 0xbb, 0xf8, 0x91, 0xe8, 0xa5, 0x4d, 0x01, 0x71, 0x8c, 0x11, 0xba, 0x6f, 0xea, + 0x69, 0xbc, 0x21, 0x80, 0xf1, 0x5f, 0x5a, 0xb0, 0x61, 0xb0, 0x13, 0x61, 0xf0, 0x3e, 0x0c, 0x25, + 0x8d, 0x13, 0x47, 0x0e, 0xdb, 0x65, 0x2d, 0xb5, 0xcb, 0xa2, 0x5b, 0x80, 0x94, 0x71, 0x0a, 0xdc, + 0x2b, 0x30, 0x3c, 0x96, 0xa9, 0x18, 0x5f, 0x51, 0xf3, 0x6a, 0xab, 0x04, 0xd7, 0x93, 0x4a, 0xc3, + 0x48, 0x2a, 0x4a, 0x2b, 0xbb, 0x61, 0x68, 0x1c, 0x76, 0xf0, 0x02, 0x2e, 0x94, 0x30, 0x62, 0x29, + 0x1f, 0xc3, 0xba, 0x14, 0x21, 0x55, 0x22, 0xab, 0xfa, 0x32, 0x82, 0x52, 0x8b, 0xf5, 0x6a, 0xd4, + 0xbc, 0x7d, 0x58, 0x46, 0xe0, 0x4f, 0x60, 0x9d, 0x8b, 0xd5, 0xef, 0xb4, 0x96, 0x1e, 0xde, 0xe8, + 0xc1, 0x59, 0x27, 0x17, 0x16, 0xfd, 0xfd, 0x1a, 0x05, 0xa7, 0x59, 0x9c, 0x18, 0xfd, 0xd1, 0xb7, + 0x6a, 0x76, 0xea, 0x4d, 0xd4, 0x9a, 0xd9, 0x44, 0x45, 0x5f, 0x43, 0x87, 0xee, 0x64, 0x33, 0xd7, + 0x7b, 0xb9, 0x98, 0xcb, 0xad, 0xef, 0x86, 0x0c, 0x96, 0xb2, 0x44, 0xba, 0x11, 0xee, 0x71, 0x62, + 0xbe, 0x11, 0x42, 0x98, 0x03, 0xd0, 0x0f, 0xd8, 0xe5, 0x9f, 0xe3, 0xbb, 0x99, 0x3b, 0x73, 0x53, + 0xde, 0x60, 0xee, 0xb2, 0x7d, 0xed, 0xbe, 0x00, 0x89, 0x3d, 0x49, 0xe7, 0xf0, 0xcb, 0xf6, 0xa4, + 0xae, 0xbe, 0x27, 0x11, 0xea, 0x89, 0xda, 0x9c, 0x54, 0xcf, 0x37, 0xe1, 0x60, 0xd1, 0xcb, 0x15, + 0x6a, 0x90, 0x40, 0xd6, 0xc8, 0xfd, 0x88, 0xba, 0x97, 0x20, 0x92, 0x2d, 0x11, 0x7e, 0x98, 0x1f, + 0x48, 0xb8, 0x6c, 0xe1, 0xde, 0x07, 0x74, 0x44, 0xb2, 0x69, 0x7c, 0x3c, 0x25, 0xaf, 0xd4, 0x49, + 0xe2, 0x16, 0xac, 0x85, 0xf1, 0xb1, 0x13, 0x52, 0x98, 0xb8, 0x21, 0xcc, 0x0f, 0x5a, 0x39, 0xad, + 0x22, 0xc1, 0x5b, 0xb0, 0x61, 0x70, 0x11, 0xa6, 0x5c, 0x87, 0xc1, 0xd1, 0xc9, 0x22, 0xf3, 0xe3, + 0x33, 0x79, 0x3b, 0x43, 0x8f, 0x8c, 0x0a, 0x24, 0xc8, 0x7e, 0x0d, 0xb6, 0x8f, 0x16, 0xb3, 0xd4, + 0x4b, 0x82, 0x19, 0x31, 0x0f, 0xfe, 0x63, 0x68, 0x93, 0xd7, 0x41, 0x9a, 0x05, 0xd1, 0x31, 0x9b, + 0x46, 0xdb, 0xce, 0xc7, 0xd4, 0xfb, 0xf3, 0xaf, 0xd8, 0x3d, 0x54, 0xee, 0xfd, 0x1f, 0xc0, 0xe5, + 0x1c, 0x43, 0x93, 0x60, 0xba, 0xeb, 0x79, 0x64, 0x9e, 0x11, 0x79, 0x4b, 0x82, 0xef, 0xc1, 0x96, + 0x49, 0xa0, 0xdd, 0xbf, 0xca, 0xa3, 0x7e, 0xe6, 0xbe, 0x14, 0x35, 0x5e, 0xdb, 0x36, 0x81, 0xf8, + 0xbf, 0x6b, 0xd0, 0xa5, 0x9f, 0x49, 0xb6, 0xe8, 0x62, 0x29, 0xdd, 0xb4, 0xd8, 0xf8, 0x91, 0x59, + 0x1c, 0xd7, 0x0a, 0xc5, 0xf1, 0x1b, 0xcb, 0x85, 0x65, 0x9d, 0x53, 0x55, 0x96, 0x34, 0xf5, 0xb2, + 0xa4, 0xd8, 0x8f, 0x5d, 0xad, 0xe8, 0xc7, 0x6e, 0xc3, 0x6a, 0xc2, 0x9a, 0x65, 0xe2, 0x64, 0x2a, + 0x46, 0x34, 0x1b, 0xf1, 0x13, 0x9c, 0x93, 0x10, 0x8f, 0x04, 0xaf, 0xa8, 0xb6, 0xdb, 0x3c, 0x1b, + 0x15, 0xe1, 0xf4, 0xe8, 0x26, 0x60, 0xa9, 0xb8, 0xb2, 0x5a, 0xe3, 0xd7, 0x95, 0x26, 0x94, 0x66, + 0x44, 0x99, 0xbd, 0x35, 0xae, 0xbc, 0xc7, 0x57, 0x81, 0xa1, 0x73, 0xc8, 0xa1, 0x92, 0x73, 0x87, + 0x57, 0x37, 0x45, 0x38, 0xcd, 0xd2, 0x1d, 0x6d, 0x73, 0xfb, 0x9e, 0x1d, 0x6c, 0x5d, 0xc7, 0xf5, + 0x82, 0x8e, 0x8b, 0xda, 0x6c, 0x54, 0x68, 0xf3, 0x43, 0xe8, 0x8b, 0xdd, 0xd4, 0x49, 0x88, 0x9b, + 0xc6, 0x72, 0x9f, 0x2b, 0x40, 0xf1, 0x5f, 0xd7, 0xf9, 0x6c, 0x45, 0x01, 0xf0, 0xff, 0xeb, 0x2c, + 0xca, 0xe4, 0x4d, 0xc3, 0xe4, 0xd7, 0x61, 0x60, 0x98, 0x96, 0xf8, 0xc2, 0xe2, 0x45, 0x30, 0x2d, + 0xe0, 0x95, 0x69, 0x33, 0x61, 0x6d, 0x1d, 0x54, 0x52, 0x16, 0x54, 0x28, 0xeb, 0x0a, 0x34, 0x92, + 0x38, 0x24, 0xcc, 0xa4, 0x7d, 0xd5, 0xff, 0xb1, 0xe3, 0x90, 0xd8, 0x0c, 0x43, 0x77, 0x9a, 0x82, + 0x5b, 0x10, 0x9f, 0xf5, 0x71, 0xd7, 0xec, 0x32, 0x82, 0x06, 0xaa, 0xee, 0x16, 0xd9, 0xa8, 0xc7, + 0x6f, 0x84, 0x0c, 0x20, 0x3d, 0x7b, 0x27, 0xce, 0x3c, 0x21, 0xc1, 0xa9, 0x7b, 0x4c, 0x46, 0x7d, + 0x46, 0xa2, 0x41, 0x54, 0x28, 0x0d, 0xb4, 0x50, 0xc2, 0xff, 0x55, 0x83, 0xe6, 0x93, 0xc4, 0xf5, + 0x09, 0x3d, 0x60, 0x9e, 0xd2, 0x88, 0x77, 0x96, 0x1f, 0xf8, 0x6c, 0x9d, 0x82, 0x7e, 0x90, 0x69, + 0x1f, 0xd4, 0x2a, 0x3f, 0xd0, 0x28, 0x34, 0xfb, 0xd4, 0x0d, 0xfb, 0xbc, 0xc9, 0xa6, 0x9a, 0x27, + 0x34, 0x4d, 0x4f, 0xc8, 0xd7, 0xb3, 0xaa, 0xa7, 0x06, 0xa9, 0xfb, 0xd6, 0x52, 0xdd, 0x5f, 0x81, + 0x0e, 0xe1, 0x17, 0x43, 0xac, 0x49, 0xc1, 0x3d, 0x41, 0x07, 0xe5, 0x67, 0x94, 0xb5, 0x37, 0x9f, + 0x51, 0xee, 0x42, 0xd7, 0xa3, 0x8e, 0x41, 0x92, 0xb9, 0x9b, 0x64, 0xdc, 0x15, 0x96, 0xf7, 0x51, + 0x0c, 0x5a, 0x7c, 0x13, 0x36, 0x98, 0xd6, 0x1f, 0x06, 0x74, 0x87, 0x3a, 0xd7, 0x4e, 0x61, 0xbc, + 0x55, 0x6b, 0x69, 0xad, 0x5a, 0x7c, 0x0f, 0x36, 0x4d, 0x62, 0xb1, 0x3d, 0x5e, 0x83, 0xd5, 0x8c, + 0xc2, 0x4b, 0xa7, 0x14, 0x46, 0x6d, 0x0b, 0x24, 0xfe, 0x23, 0x0b, 0x7a, 0x14, 0x12, 0x44, 0xc7, + 0x53, 0xca, 0x2f, 0xa5, 0x0a, 0x3f, 0x75, 0x5f, 0x3b, 0x29, 0x09, 0x43, 0xd9, 0x16, 0x91, 0x63, + 0xf6, 0xfa, 0xc5, 0x7d, 0xed, 0xcc, 0x16, 0xb2, 0xa4, 0x93, 0x43, 0xea, 0x86, 0x09, 0x49, 0x49, + 0x42, 0x8b, 0x26, 0xf6, 0x29, 0x4f, 0x24, 0x26, 0x90, 0x06, 0x48, 0x0e, 0xa0, 0x4c, 0xc4, 0xf3, + 0x07, 0x1d, 0x86, 0x77, 0xf8, 0x82, 0xf2, 0x09, 0xbd, 0x4d, 0x55, 0xfc, 0x57, 0x16, 0x6c, 0x15, + 0x3e, 0x12, 0x6a, 0xd8, 0x85, 0x55, 0xa6, 0x27, 0xa9, 0x86, 0x8f, 0x74, 0x35, 0x94, 0xc8, 0x6f, + 0xf1, 0xa1, 0xe8, 0x32, 0xf3, 0x0f, 0xc7, 0x8f, 0xa1, 0xa3, 0x81, 0x2b, 0x4a, 0x97, 0x9b, 0x66, + 0x97, 0x79, 0xab, 0x5a, 0x84, 0x56, 0xd1, 0x7c, 0x0b, 0xdd, 0xa7, 0xd1, 0xec, 0x7b, 0x3c, 0xd4, + 0x40, 0x97, 0x60, 0x2d, 0x21, 0xa2, 0x07, 0x20, 0x0a, 0x19, 0x05, 0xc0, 0x03, 0xe8, 0x09, 0xbe, + 0xea, 0x7e, 0xfd, 0x69, 0x14, 0xc6, 0xde, 0xcb, 0xb7, 0xbd, 0x5f, 0xff, 0x19, 0x20, 0xfd, 0x03, + 0x55, 0x6a, 0x2d, 0x18, 0xb4, 0x50, 0x6a, 0x49, 0x20, 0x2b, 0xb5, 0x3e, 0x80, 0x8e, 0x4e, 0xc2, + 0xaf, 0xe3, 0x40, 0x11, 0xe0, 0x3f, 0xb4, 0x60, 0xf0, 0x2c, 0xc8, 0x4e, 0xfc, 0xc4, 0x3d, 0x7b, + 0x0b, 0xa3, 0x16, 0xdf, 0x3a, 0xd4, 0xde, 0xf4, 0xd6, 0xa1, 0x5e, 0x7c, 0xeb, 0xe0, 0x86, 0xa1, + 0x68, 0xcb, 0xd0, 0x9f, 0x7a, 0x43, 0xb6, 0xc7, 0x1b, 0xb2, 0x77, 0x61, 0xa8, 0x26, 0xf3, 0x6e, + 0xdd, 0xd8, 0x1b, 0xd7, 0x61, 0x2d, 0x8f, 0x77, 0xd4, 0x82, 0xfa, 0xde, 0xd3, 0xdf, 0x18, 0xae, + 0xa0, 0x36, 0x34, 0x8e, 0x26, 0xd3, 0x29, 0xbf, 0xf8, 0x60, 0x77, 0x21, 0xb5, 0x1b, 0x37, 0xa0, + 0x41, 0xb3, 0x0b, 0x5a, 0x83, 0xe6, 0x93, 0xdd, 0xaf, 0x27, 0x36, 0x7f, 0xae, 0xf3, 0x0d, 0xfb, + 0x69, 0xa1, 0x2e, 0xb4, 0x1f, 0x1d, 0x3c, 0x99, 0xd8, 0x07, 0xbb, 0xd3, 0x61, 0xed, 0xc6, 0x33, + 0x68, 0xcb, 0xba, 0x91, 0x12, 0xed, 0x4e, 0x27, 0xf6, 0x13, 0x4e, 0x3f, 0xb1, 0xed, 0x43, 0x9b, + 0xf3, 0x7d, 0xb6, 0x6b, 0x1f, 0x0c, 0x6b, 0xf4, 0xd7, 0xa3, 0x83, 0x9f, 0x1e, 0x0e, 0xeb, 0xa8, + 0x03, 0xad, 0x6f, 0x27, 0xf6, 0xde, 0xe1, 0xd1, 0x64, 0xd8, 0xa0, 0xb4, 0xf7, 0x27, 0x7b, 0x4f, + 0x1f, 0x0c, 0x9b, 0x4c, 0xa2, 0xbd, 0xbb, 0x3f, 0x19, 0xae, 0xee, 0xfc, 0xbb, 0x05, 0xad, 0xe7, + 0x0b, 0xff, 0x51, 0x14, 0x64, 0x68, 0x02, 0xa0, 0xde, 0x4f, 0xa0, 0xfc, 0x15, 0x53, 0xe9, 0x15, + 0xc6, 0x78, 0x5c, 0x85, 0x12, 0x6e, 0xb5, 0x82, 0x1e, 0x42, 0x47, 0xab, 0xc9, 0xd1, 0x78, 0xf9, + 0xe1, 0x61, 0xfc, 0x5e, 0x25, 0x2e, 0xe7, 0x34, 0x01, 0x50, 0x1e, 0xa7, 0x26, 0x54, 0x72, 0x5b, + 0x35, 0xa1, 0xb2, 0x83, 0xe2, 0x95, 0x9d, 0xbf, 0x1d, 0x43, 0xfd, 0xf9, 0xc2, 0x47, 0xcf, 0xa1, + 0xa3, 0x3d, 0x30, 0x44, 0xa5, 0x3b, 0x36, 0x35, 0x9d, 0xaa, 0x77, 0x88, 0xe3, 0x5f, 0xfc, 0xe3, + 0x7f, 0xfc, 0x71, 0x6d, 0x13, 0x0f, 0x6e, 0xbf, 0xfa, 0xd5, 0xdb, 0xae, 0xef, 0x4b, 0x5f, 0xbc, + 0x6b, 0xdd, 0x40, 0x36, 0xb4, 0xc4, 0x1b, 0x42, 0xb4, 0xad, 0xf1, 0xd0, 0x0e, 0x78, 0xe3, 0x0b, + 0x25, 0xb8, 0xe0, 0xbb, 0xcd, 0xf8, 0x0e, 0x71, 0x47, 0xf0, 0xa5, 0xdb, 0x14, 0xe5, 0xb9, 0x07, + 0xf5, 0x3d, 0x37, 0x42, 0x48, 0x5d, 0xa1, 0xcb, 0x9c, 0x30, 0xde, 0x30, 0x60, 0x82, 0x0f, 0x62, + 0x7c, 0xba, 0xb8, 0x45, 0xf9, 0xcc, 0xdc, 0x88, 0xf2, 0x38, 0x86, 0xbe, 0xf9, 0x40, 0x09, 0x5d, + 0xd6, 0x6f, 0x82, 0x4a, 0x2f, 0xa3, 0xc6, 0xef, 0x2f, 0x43, 0x17, 0x26, 0xdb, 0xa7, 0x42, 0x3c, + 0x46, 0x43, 0xf3, 0x03, 0xf2, 0xa0, 0xab, 0xbf, 0x17, 0x42, 0xea, 0xd5, 0x4a, 0xf9, 0x11, 0xd4, + 0xf8, 0x52, 0x35, 0x52, 0x88, 0x18, 0x31, 0x11, 0x08, 0x0f, 0x99, 0x08, 0x4a, 0x21, 0xae, 0xaa, + 0xa8, 0x96, 0xc5, 0x23, 0x21, 0xa5, 0x65, 0xf3, 0x8d, 0x91, 0xd2, 0x72, 0xf1, 0x35, 0x91, 0xa1, + 0x65, 0x91, 0x13, 0xa9, 0x86, 0x7e, 0x0e, 0xbd, 0x67, 0xec, 0x09, 0xa0, 0x78, 0x9a, 0xa2, 0x38, + 0x9b, 0x2f, 0x5b, 0x14, 0xe7, 0xc2, 0x1b, 0x16, 0x7c, 0x89, 0x71, 0xde, 0xc6, 0xeb, 0x94, 0x33, + 0x7f, 0x4e, 0xe8, 0x73, 0x12, 0xca, 0xff, 0xb7, 0xa1, 0x67, 0xbc, 0x42, 0x41, 0xf9, 0xe2, 0xab, + 0x9e, 0xb7, 0x8c, 0x2f, 0x2f, 0xc1, 0x56, 0xc9, 0xf2, 0x05, 0x09, 0x7b, 0xb7, 0x42, 0x65, 0x3d, + 0x07, 0x50, 0xaf, 0x39, 0x54, 0xb8, 0x94, 0x5e, 0x90, 0xa8, 0x70, 0x29, 0x3f, 0xfe, 0xc0, 0x1b, + 0x4c, 0x44, 0x0f, 0x75, 0xb8, 0x1b, 0x71, 0x5e, 0x53, 0x68, 0x89, 0x77, 0x0b, 0x4a, 0x3f, 0xe6, + 0xe3, 0x0d, 0xa5, 0x9f, 0xc2, 0x03, 0x07, 0x3c, 0x64, 0x0c, 0x01, 0xb5, 0x29, 0xc3, 0x80, 0xb2, + 0xf8, 0x4d, 0xe8, 0x68, 0x97, 0xfe, 0x48, 0x9f, 0x4d, 0xe1, 0x7d, 0x80, 0x8a, 0xc8, 0x8a, 0x57, + 0x02, 0x78, 0x93, 0x71, 0xee, 0xa3, 0x2e, 0xe5, 0x2c, 0x3b, 0x1e, 0x82, 0xbb, 0xbc, 0xd5, 0x37, + 0xb8, 0x17, 0x9e, 0x0a, 0x18, 0xdc, 0x8b, 0xcf, 0x00, 0x4c, 0xee, 0x54, 0xc7, 0x6c, 0xee, 0xcf, + 0x00, 0xd4, 0x05, 0xb4, 0xd2, 0x71, 0xe9, 0x26, 0x5d, 0xe9, 0xb8, 0x7c, 0x5f, 0x2d, 0x43, 0x15, + 0x01, 0x65, 0x2d, 0xae, 0x69, 0x8e, 0xa1, 0x6f, 0xbe, 0x0f, 0x50, 0xa1, 0x5a, 0xf9, 0xa0, 0x40, + 0x85, 0x6a, 0xf5, 0xb3, 0x02, 0xe9, 0xf1, 0x88, 0x87, 0xaa, 0x62, 0x7b, 0x04, 0x6b, 0xf9, 0xcd, + 0x35, 0x1a, 0xe9, 0x4c, 0xf4, 0x0b, 0xee, 0xf1, 0xc5, 0x0a, 0x8c, 0x6c, 0x58, 0x30, 0xce, 0x1d, + 0xb4, 0x46, 0x39, 0xf3, 0x0b, 0x0c, 0xc9, 0x94, 0xbd, 0xa1, 0x31, 0x99, 0x6a, 0xd7, 0xde, 0x05, + 0xa6, 0xfa, 0xe5, 0x77, 0x81, 0x29, 0xe3, 0xe3, 0x40, 0x47, 0xbb, 0x17, 0x55, 0x96, 0x2c, 0x5f, + 0xea, 0x2a, 0x4b, 0x56, 0x5c, 0xa4, 0xe2, 0x0b, 0x8c, 0xf5, 0x3a, 0xcf, 0xdc, 0xf1, 0x9c, 0x44, + 0x32, 0xa1, 0xfc, 0x16, 0x80, 0x6a, 0x65, 0x2b, 0x63, 0x96, 0x2e, 0x39, 0x94, 0x73, 0x17, 0x3a, + 0xdf, 0xf8, 0x22, 0x63, 0xbd, 0xc1, 0xf3, 0x21, 0xbb, 0x5e, 0x60, 0xe6, 0xbc, 0x6b, 0xdd, 0xb8, + 0x63, 0xa1, 0x17, 0xd0, 0x57, 0xf4, 0x47, 0xe7, 0x91, 0xf7, 0x26, 0x11, 0xe3, 0x2a, 0x94, 0x58, + 0xc0, 0x65, 0x26, 0xe5, 0x02, 0x46, 0xa6, 0x94, 0xf4, 0x3c, 0xf2, 0x68, 0xdc, 0xff, 0x0c, 0x3a, + 0xda, 0x8b, 0x35, 0xa5, 0xa7, 0xf2, 0x33, 0xb6, 0x71, 0x55, 0xb3, 0xdd, 0xdc, 0xd9, 0xc4, 0x79, + 0x26, 0x3d, 0x73, 0xe7, 0x94, 0x77, 0x04, 0x7d, 0xb3, 0xa7, 0xac, 0xdc, 0xb2, 0xb2, 0x41, 0xad, + 0xdc, 0x72, 0x49, 0x2b, 0xda, 0x58, 0x0b, 0x6f, 0xa5, 0xea, 0x3b, 0xe9, 0x8c, 0x16, 0x0f, 0x79, + 0x6b, 0x59, 0x2f, 0x1e, 0x8a, 0xed, 0x6b, 0xbd, 0x78, 0x28, 0xf5, 0xa2, 0xcd, 0x35, 0x71, 0x31, + 0xd2, 0x32, 0x28, 0x81, 0x41, 0xa1, 0xef, 0x8b, 0x0a, 0xb3, 0x2e, 0xb6, 0x8a, 0xc7, 0x1f, 0x2c, + 0xc5, 0x0b, 0x79, 0xef, 0x33, 0x79, 0x23, 0xbc, 0xa1, 0xe4, 0xb9, 0x61, 0xc8, 0xcd, 0xc4, 0xf7, + 0x19, 0x50, 0x5d, 0x5c, 0xe5, 0x07, 0xa5, 0x46, 0xf0, 0x78, 0x5c, 0x85, 0x12, 0x42, 0x0c, 0x6f, + 0xe3, 0x42, 0x64, 0xb5, 0x30, 0x83, 0x8e, 0xd6, 0x5b, 0x54, 0x7a, 0x2b, 0xb7, 0x2d, 0x95, 0xde, + 0xaa, 0x9a, 0x91, 0x86, 0xde, 0x52, 0x92, 0x85, 0xf1, 0x31, 0x6b, 0x5e, 0x52, 0x19, 0xdf, 0x42, + 0x5b, 0x76, 0x25, 0x51, 0x1e, 0x11, 0x85, 0xd6, 0xe5, 0x78, 0x54, 0x46, 0x14, 0xc2, 0x90, 0x25, + 0xd4, 0x54, 0x60, 0x29, 0x5f, 0x07, 0x06, 0x85, 0x1e, 0xa5, 0xb2, 0x47, 0x75, 0xf3, 0x72, 0xdc, + 0x33, 0xfe, 0x13, 0x03, 0xbf, 0xc7, 0x58, 0x6f, 0x21, 0xa6, 0xfd, 0x54, 0x7e, 0xc2, 0xfe, 0x7b, + 0x22, 0xbd, 0x63, 0x21, 0xa2, 0x09, 0x28, 0x1a, 0xbc, 0xba, 0xa7, 0x3a, 0x36, 0x5f, 0xf6, 0xf1, + 0x4b, 0xed, 0x25, 0x62, 0xb8, 0x91, 0xef, 0x58, 0x68, 0x5e, 0x68, 0x98, 0x8a, 0xce, 0x9b, 0x96, + 0xc9, 0x2b, 0xfb, 0xa9, 0xe3, 0xaa, 0xbb, 0x28, 0xfc, 0x03, 0x26, 0xeb, 0x3d, 0x74, 0xd1, 0x90, + 0x45, 0xc3, 0x52, 0x5e, 0xc5, 0xdd, 0xb1, 0xd0, 0x0c, 0xfa, 0x26, 0xcb, 0x77, 0x12, 0x55, 0x88, + 0x7f, 0x84, 0x4a, 0xa2, 0xa8, 0x8c, 0xdf, 0xd5, 0x3a, 0xc8, 0x46, 0x9f, 0x18, 0x5d, 0xab, 0x96, + 0x55, 0xe8, 0x23, 0x8f, 0x37, 0x75, 0x99, 0x12, 0x89, 0x31, 0x13, 0x7a, 0x09, 0x8d, 0xcb, 0x42, + 0x5d, 0x41, 0xc3, 0x52, 0x68, 0x57, 0xef, 0x60, 0xa8, 0xba, 0xb2, 0xa2, 0x09, 0xa2, 0xea, 0xca, + 0xaa, 0xa6, 0x87, 0x34, 0x1e, 0xaf, 0x2b, 0x59, 0x87, 0xe3, 0x84, 0x53, 0xf0, 0x42, 0xb9, 0xd0, + 0xe9, 0xb8, 0xb4, 0xa4, 0x17, 0x50, 0x28, 0xd3, 0x2a, 0x3b, 0x05, 0x32, 0x4e, 0xd1, 0xba, 0x14, + 0x15, 0x44, 0xc7, 0xbc, 0x61, 0x80, 0xbe, 0x82, 0x26, 0x3b, 0x86, 0xa3, 0x4d, 0x75, 0x64, 0x51, + 0xa7, 0xfd, 0xf1, 0x56, 0x01, 0x6a, 0xd6, 0x22, 0x98, 0x6d, 0x8e, 0x8b, 0x48, 0x54, 0xf7, 0x33, + 0xe8, 0xf3, 0xda, 0x55, 0x1e, 0x56, 0x55, 0x54, 0x16, 0xce, 0xd2, 0x2a, 0x2a, 0x8b, 0xe7, 0x5a, + 0x33, 0x1f, 0xf3, 0xf2, 0xf5, 0x4c, 0xd0, 0xdc, 0xb5, 0x6e, 0xcc, 0x56, 0xd9, 0xff, 0x66, 0x7d, + 0xfa, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xec, 0xb6, 0x0d, 0x31, 0xc6, 0x35, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -5323,6 +5579,8 @@ type XudClient interface { // Begin gracefully shutting down xud. // shell: xucli shutdown Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) + // Subscribes to alerts such as low balance. + SubscribeAlerts(ctx context.Context, in *SubscribeAlertsRequest, opts ...grpc.CallOption) (Xud_SubscribeAlertsClient, error) // Subscribes to orders being added to and removed from the order book. This call allows the client // to maintain an up-to-date view of the order book. For example, an exchange that wants to show // its users a real time view of the orders available to them would subscribe to this streaming @@ -5621,8 +5879,40 @@ func (c *xudClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...g return out, nil } +func (c *xudClient) SubscribeAlerts(ctx context.Context, in *SubscribeAlertsRequest, opts ...grpc.CallOption) (Xud_SubscribeAlertsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[1], "/xudrpc.Xud/SubscribeAlerts", opts...) + if err != nil { + return nil, err + } + x := &xudSubscribeAlertsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Xud_SubscribeAlertsClient interface { + Recv() (*Alert, error) + grpc.ClientStream +} + +type xudSubscribeAlertsClient struct { + grpc.ClientStream +} + +func (x *xudSubscribeAlertsClient) Recv() (*Alert, error) { + m := new(Alert) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + func (c *xudClient) SubscribeOrders(ctx context.Context, in *SubscribeOrdersRequest, opts ...grpc.CallOption) (Xud_SubscribeOrdersClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[1], "/xudrpc.Xud/SubscribeOrders", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[2], "/xudrpc.Xud/SubscribeOrders", opts...) if err != nil { return nil, err } @@ -5654,7 +5944,7 @@ func (x *xudSubscribeOrdersClient) Recv() (*OrderUpdate, error) { } func (c *xudClient) SubscribeSwapFailures(ctx context.Context, in *SubscribeSwapsRequest, opts ...grpc.CallOption) (Xud_SubscribeSwapFailuresClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[2], "/xudrpc.Xud/SubscribeSwapFailures", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[3], "/xudrpc.Xud/SubscribeSwapFailures", opts...) if err != nil { return nil, err } @@ -5686,7 +5976,7 @@ func (x *xudSubscribeSwapFailuresClient) Recv() (*SwapFailure, error) { } func (c *xudClient) SubscribeSwaps(ctx context.Context, in *SubscribeSwapsRequest, opts ...grpc.CallOption) (Xud_SubscribeSwapsClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[3], "/xudrpc.Xud/SubscribeSwaps", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[4], "/xudrpc.Xud/SubscribeSwaps", opts...) if err != nil { return nil, err } @@ -5718,7 +6008,7 @@ func (x *xudSubscribeSwapsClient) Recv() (*SwapSuccess, error) { } func (c *xudClient) SubscribeSwapsAccepted(ctx context.Context, in *SubscribeSwapsAcceptedRequest, opts ...grpc.CallOption) (Xud_SubscribeSwapsAcceptedClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[4], "/xudrpc.Xud/SubscribeSwapsAccepted", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[5], "/xudrpc.Xud/SubscribeSwapsAccepted", opts...) if err != nil { return nil, err } @@ -5883,6 +6173,8 @@ type XudServer interface { // Begin gracefully shutting down xud. // shell: xucli shutdown Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error) + // Subscribes to alerts such as low balance. + SubscribeAlerts(*SubscribeAlertsRequest, Xud_SubscribeAlertsServer) error // Subscribes to orders being added to and removed from the order book. This call allows the client // to maintain an up-to-date view of the order book. For example, an exchange that wants to show // its users a real time view of the orders available to them would subscribe to this streaming @@ -6391,6 +6683,27 @@ func _Xud_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interf return interceptor(ctx, in, info, handler) } +func _Xud_SubscribeAlerts_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SubscribeAlertsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(XudServer).SubscribeAlerts(m, &xudSubscribeAlertsServer{stream}) +} + +type Xud_SubscribeAlertsServer interface { + Send(*Alert) error + grpc.ServerStream +} + +type xudSubscribeAlertsServer struct { + grpc.ServerStream +} + +func (x *xudSubscribeAlertsServer) Send(m *Alert) error { + return x.ServerStream.SendMsg(m) +} + func _Xud_SubscribeOrders_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(SubscribeOrdersRequest) if err := stream.RecvMsg(m); err != nil { @@ -6674,6 +6987,11 @@ var _Xud_serviceDesc = grpc.ServiceDesc{ Handler: _Xud_PlaceOrder_Handler, ServerStreams: true, }, + { + StreamName: "SubscribeAlerts", + Handler: _Xud_SubscribeAlerts_Handler, + ServerStreams: true, + }, { StreamName: "SubscribeOrders", Handler: _Xud_SubscribeOrders_Handler, From 3a890e04235175da735d7ab38aed1d79b5c02e5d Mon Sep 17 00:00:00 2001 From: rsercano Date: Mon, 7 Dec 2020 23:47:19 +0300 Subject: [PATCH 02/16] rebased --- docs/api.md | 2 - test/simulation/xudrpc/xudrpc.pb.go | 1015 ++++++++++++++++++--------- 2 files changed, 667 insertions(+), 350 deletions(-) diff --git a/docs/api.md b/docs/api.md index 45baa07d4..12da08a64 100644 --- a/docs/api.md +++ b/docs/api.md @@ -106,11 +106,9 @@ - [OrderSide](#xudrpc.OrderSide) - [Role](#xudrpc.Role) - - [Xud](#xudrpc.Xud) - [XudInit](#xudrpc.XudInit) - - [Scalar Value Types](#scalar-value-types) diff --git a/test/simulation/xudrpc/xudrpc.pb.go b/test/simulation/xudrpc/xudrpc.pb.go index 5a7a1d24e..3e2ac8c65 100644 --- a/test/simulation/xudrpc/xudrpc.pb.go +++ b/test/simulation/xudrpc/xudrpc.pb.go @@ -119,6 +119,55 @@ func (LogLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor_6960a02cc0a63cf6, []int{2} } +// The type of the alert. +type Alert_AlertType int32 + +const ( + Alert_LOW_TRADING_BALANCE Alert_AlertType = 0 +) + +var Alert_AlertType_name = map[int32]string{ + 0: "LOW_TRADING_BALANCE", +} + +var Alert_AlertType_value = map[string]int32{ + "LOW_TRADING_BALANCE": 0, +} + +func (x Alert_AlertType) String() string { + return proto.EnumName(Alert_AlertType_name, int32(x)) +} + +func (Alert_AlertType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{3, 0} +} + +// The side of the low balance. +type BalanceAlert_Side int32 + +const ( + BalanceAlert_REMOTE BalanceAlert_Side = 0 + BalanceAlert_LOCAL BalanceAlert_Side = 1 +) + +var BalanceAlert_Side_name = map[int32]string{ + 0: "REMOTE", + 1: "LOCAL", +} + +var BalanceAlert_Side_value = map[string]int32{ + "REMOTE": 0, + "LOCAL": 1, +} + +func (x BalanceAlert_Side) String() string { + return proto.EnumName(BalanceAlert_Side_name, int32(x)) +} + +func (BalanceAlert_Side) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{5, 0} +} + type Currency_SwapClient int32 const ( @@ -141,7 +190,7 @@ func (x Currency_SwapClient) String() string { } func (Currency_SwapClient) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{16, 0} + return fileDescriptor_6960a02cc0a63cf6, []int{18, 0} } type ListOrdersRequest_Owner int32 @@ -169,7 +218,7 @@ func (x ListOrdersRequest_Owner) String() string { } func (ListOrdersRequest_Owner) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{32, 0} + return fileDescriptor_6960a02cc0a63cf6, []int{34, 0} } type AddCurrencyResponse struct { @@ -283,6 +332,90 @@ func (m *AddPairResponse) XXX_DiscardUnknown() { var xxx_messageInfo_AddPairResponse proto.InternalMessageInfo +type Alert struct { + Type Alert_AlertType `protobuf:"varint,1,opt,name=type,proto3,enum=xudrpc.Alert_AlertType" json:"type,omitempty"` + // The human readable alert message. + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + // The structured payload. + // + // Types that are valid to be assigned to Payload: + // *Alert_BalanceAlert + Payload isAlert_Payload `protobuf_oneof:"payload"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Alert) Reset() { *m = Alert{} } +func (m *Alert) String() string { return proto.CompactTextString(m) } +func (*Alert) ProtoMessage() {} +func (*Alert) Descriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{3} +} + +func (m *Alert) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Alert.Unmarshal(m, b) +} +func (m *Alert) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Alert.Marshal(b, m, deterministic) +} +func (m *Alert) XXX_Merge(src proto.Message) { + xxx_messageInfo_Alert.Merge(m, src) +} +func (m *Alert) XXX_Size() int { + return xxx_messageInfo_Alert.Size(m) +} +func (m *Alert) XXX_DiscardUnknown() { + xxx_messageInfo_Alert.DiscardUnknown(m) +} + +var xxx_messageInfo_Alert proto.InternalMessageInfo + +func (m *Alert) GetType() Alert_AlertType { + if m != nil { + return m.Type + } + return Alert_LOW_TRADING_BALANCE +} + +func (m *Alert) GetMessage() string { + if m != nil { + return m.Message + } + return "" +} + +type isAlert_Payload interface { + isAlert_Payload() +} + +type Alert_BalanceAlert struct { + BalanceAlert *BalanceAlert `protobuf:"bytes,3,opt,name=balance_alert,proto3,oneof"` +} + +func (*Alert_BalanceAlert) isAlert_Payload() {} + +func (m *Alert) GetPayload() isAlert_Payload { + if m != nil { + return m.Payload + } + return nil +} + +func (m *Alert) GetBalanceAlert() *BalanceAlert { + if x, ok := m.GetPayload().(*Alert_BalanceAlert); ok { + return x.BalanceAlert + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*Alert) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*Alert_BalanceAlert)(nil), + } +} + type Balance struct { // Total balance denominated in satoshis. TotalBalance uint64 `protobuf:"varint,1,opt,name=total_balance,proto3" json:"total_balance,omitempty"` @@ -305,7 +438,7 @@ func (m *Balance) Reset() { *m = Balance{} } func (m *Balance) String() string { return proto.CompactTextString(m) } func (*Balance) ProtoMessage() {} func (*Balance) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{3} + return fileDescriptor_6960a02cc0a63cf6, []int{4} } func (m *Balance) XXX_Unmarshal(b []byte) error { @@ -368,6 +501,81 @@ func (m *Balance) GetUnconfirmedWalletBalance() uint64 { return 0 } +type BalanceAlert struct { + // The total balance. + TotalBalance uint64 `protobuf:"varint,1,opt,name=total_balance,proto3" json:"total_balance,omitempty"` + Side BalanceAlert_Side `protobuf:"varint,2,opt,name=side,proto3,enum=xudrpc.BalanceAlert_Side" json:"side,omitempty"` + // The bound of the low balance in percentage. + Bound uint32 `protobuf:"varint,3,opt,name=bound,proto3" json:"bound,omitempty"` + // The current side balance. + SideBalance uint64 `protobuf:"varint,4,opt,name=side_balance,proto3" json:"side_balance,omitempty"` + // The currency of the alert. + Currency string `protobuf:"bytes,5,opt,name=currency,proto3" json:"currency,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BalanceAlert) Reset() { *m = BalanceAlert{} } +func (m *BalanceAlert) String() string { return proto.CompactTextString(m) } +func (*BalanceAlert) ProtoMessage() {} +func (*BalanceAlert) Descriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{5} +} + +func (m *BalanceAlert) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BalanceAlert.Unmarshal(m, b) +} +func (m *BalanceAlert) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BalanceAlert.Marshal(b, m, deterministic) +} +func (m *BalanceAlert) XXX_Merge(src proto.Message) { + xxx_messageInfo_BalanceAlert.Merge(m, src) +} +func (m *BalanceAlert) XXX_Size() int { + return xxx_messageInfo_BalanceAlert.Size(m) +} +func (m *BalanceAlert) XXX_DiscardUnknown() { + xxx_messageInfo_BalanceAlert.DiscardUnknown(m) +} + +var xxx_messageInfo_BalanceAlert proto.InternalMessageInfo + +func (m *BalanceAlert) GetTotalBalance() uint64 { + if m != nil { + return m.TotalBalance + } + return 0 +} + +func (m *BalanceAlert) GetSide() BalanceAlert_Side { + if m != nil { + return m.Side + } + return BalanceAlert_REMOTE +} + +func (m *BalanceAlert) GetBound() uint32 { + if m != nil { + return m.Bound + } + return 0 +} + +func (m *BalanceAlert) GetSideBalance() uint64 { + if m != nil { + return m.SideBalance + } + return 0 +} + +func (m *BalanceAlert) GetCurrency() string { + if m != nil { + return m.Currency + } + return "" +} + type BanRequest struct { // The node pub key or alias of the node to ban. NodeIdentifier string `protobuf:"bytes,1,opt,name=node_identifier,proto3" json:"node_identifier,omitempty"` @@ -380,7 +588,7 @@ func (m *BanRequest) Reset() { *m = BanRequest{} } func (m *BanRequest) String() string { return proto.CompactTextString(m) } func (*BanRequest) ProtoMessage() {} func (*BanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{4} + return fileDescriptor_6960a02cc0a63cf6, []int{6} } func (m *BanRequest) XXX_Unmarshal(b []byte) error { @@ -418,7 +626,7 @@ func (m *BanResponse) Reset() { *m = BanResponse{} } func (m *BanResponse) String() string { return proto.CompactTextString(m) } func (*BanResponse) ProtoMessage() {} func (*BanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{5} + return fileDescriptor_6960a02cc0a63cf6, []int{7} } func (m *BanResponse) XXX_Unmarshal(b []byte) error { @@ -453,7 +661,7 @@ func (m *Chain) Reset() { *m = Chain{} } func (m *Chain) String() string { return proto.CompactTextString(m) } func (*Chain) ProtoMessage() {} func (*Chain) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{6} + return fileDescriptor_6960a02cc0a63cf6, []int{8} } func (m *Chain) XXX_Unmarshal(b []byte) error { @@ -506,7 +714,7 @@ func (m *Channels) Reset() { *m = Channels{} } func (m *Channels) String() string { return proto.CompactTextString(m) } func (*Channels) ProtoMessage() {} func (*Channels) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{7} + return fileDescriptor_6960a02cc0a63cf6, []int{9} } func (m *Channels) XXX_Unmarshal(b []byte) error { @@ -567,7 +775,7 @@ func (m *ChangePasswordRequest) Reset() { *m = ChangePasswordRequest{} } func (m *ChangePasswordRequest) String() string { return proto.CompactTextString(m) } func (*ChangePasswordRequest) ProtoMessage() {} func (*ChangePasswordRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{8} + return fileDescriptor_6960a02cc0a63cf6, []int{10} } func (m *ChangePasswordRequest) XXX_Unmarshal(b []byte) error { @@ -612,7 +820,7 @@ func (m *ChangePasswordResponse) Reset() { *m = ChangePasswordResponse{} func (m *ChangePasswordResponse) String() string { return proto.CompactTextString(m) } func (*ChangePasswordResponse) ProtoMessage() {} func (*ChangePasswordResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{9} + return fileDescriptor_6960a02cc0a63cf6, []int{11} } func (m *ChangePasswordResponse) XXX_Unmarshal(b []byte) error { @@ -658,7 +866,7 @@ func (m *CloseChannelRequest) Reset() { *m = CloseChannelRequest{} } func (m *CloseChannelRequest) String() string { return proto.CompactTextString(m) } func (*CloseChannelRequest) ProtoMessage() {} func (*CloseChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{10} + return fileDescriptor_6960a02cc0a63cf6, []int{12} } func (m *CloseChannelRequest) XXX_Unmarshal(b []byte) error { @@ -733,7 +941,7 @@ func (m *CloseChannelResponse) Reset() { *m = CloseChannelResponse{} } func (m *CloseChannelResponse) String() string { return proto.CompactTextString(m) } func (*CloseChannelResponse) ProtoMessage() {} func (*CloseChannelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{11} + return fileDescriptor_6960a02cc0a63cf6, []int{13} } func (m *CloseChannelResponse) XXX_Unmarshal(b []byte) error { @@ -773,7 +981,7 @@ func (m *ConnectRequest) Reset() { *m = ConnectRequest{} } func (m *ConnectRequest) String() string { return proto.CompactTextString(m) } func (*ConnectRequest) ProtoMessage() {} func (*ConnectRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{12} + return fileDescriptor_6960a02cc0a63cf6, []int{14} } func (m *ConnectRequest) XXX_Unmarshal(b []byte) error { @@ -811,7 +1019,7 @@ func (m *ConnectResponse) Reset() { *m = ConnectResponse{} } func (m *ConnectResponse) String() string { return proto.CompactTextString(m) } func (*ConnectResponse) ProtoMessage() {} func (*ConnectResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{13} + return fileDescriptor_6960a02cc0a63cf6, []int{15} } func (m *ConnectResponse) XXX_Unmarshal(b []byte) error { @@ -845,7 +1053,7 @@ func (m *CreateNodeRequest) Reset() { *m = CreateNodeRequest{} } func (m *CreateNodeRequest) String() string { return proto.CompactTextString(m) } func (*CreateNodeRequest) ProtoMessage() {} func (*CreateNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{14} + return fileDescriptor_6960a02cc0a63cf6, []int{16} } func (m *CreateNodeRequest) XXX_Unmarshal(b []byte) error { @@ -889,7 +1097,7 @@ func (m *CreateNodeResponse) Reset() { *m = CreateNodeResponse{} } func (m *CreateNodeResponse) String() string { return proto.CompactTextString(m) } func (*CreateNodeResponse) ProtoMessage() {} func (*CreateNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{15} + return fileDescriptor_6960a02cc0a63cf6, []int{17} } func (m *CreateNodeResponse) XXX_Unmarshal(b []byte) error { @@ -953,7 +1161,7 @@ func (m *Currency) Reset() { *m = Currency{} } func (m *Currency) String() string { return proto.CompactTextString(m) } func (*Currency) ProtoMessage() {} func (*Currency) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{16} + return fileDescriptor_6960a02cc0a63cf6, []int{18} } func (m *Currency) XXX_Unmarshal(b []byte) error { @@ -1014,7 +1222,7 @@ func (m *DepositRequest) Reset() { *m = DepositRequest{} } func (m *DepositRequest) String() string { return proto.CompactTextString(m) } func (*DepositRequest) ProtoMessage() {} func (*DepositRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{17} + return fileDescriptor_6960a02cc0a63cf6, []int{19} } func (m *DepositRequest) XXX_Unmarshal(b []byte) error { @@ -1054,7 +1262,7 @@ func (m *DepositResponse) Reset() { *m = DepositResponse{} } func (m *DepositResponse) String() string { return proto.CompactTextString(m) } func (*DepositResponse) ProtoMessage() {} func (*DepositResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{18} + return fileDescriptor_6960a02cc0a63cf6, []int{20} } func (m *DepositResponse) XXX_Unmarshal(b []byte) error { @@ -1094,7 +1302,7 @@ func (m *DiscoverNodesRequest) Reset() { *m = DiscoverNodesRequest{} } func (m *DiscoverNodesRequest) String() string { return proto.CompactTextString(m) } func (*DiscoverNodesRequest) ProtoMessage() {} func (*DiscoverNodesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{19} + return fileDescriptor_6960a02cc0a63cf6, []int{21} } func (m *DiscoverNodesRequest) XXX_Unmarshal(b []byte) error { @@ -1133,7 +1341,7 @@ func (m *DiscoverNodesResponse) Reset() { *m = DiscoverNodesResponse{} } func (m *DiscoverNodesResponse) String() string { return proto.CompactTextString(m) } func (*DiscoverNodesResponse) ProtoMessage() {} func (*DiscoverNodesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{20} + return fileDescriptor_6960a02cc0a63cf6, []int{22} } func (m *DiscoverNodesResponse) XXX_Unmarshal(b []byte) error { @@ -1179,7 +1387,7 @@ func (m *ExecuteSwapRequest) Reset() { *m = ExecuteSwapRequest{} } func (m *ExecuteSwapRequest) String() string { return proto.CompactTextString(m) } func (*ExecuteSwapRequest) ProtoMessage() {} func (*ExecuteSwapRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{21} + return fileDescriptor_6960a02cc0a63cf6, []int{23} } func (m *ExecuteSwapRequest) XXX_Unmarshal(b []byte) error { @@ -1241,7 +1449,7 @@ func (m *GetBalanceRequest) Reset() { *m = GetBalanceRequest{} } func (m *GetBalanceRequest) String() string { return proto.CompactTextString(m) } func (*GetBalanceRequest) ProtoMessage() {} func (*GetBalanceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{22} + return fileDescriptor_6960a02cc0a63cf6, []int{24} } func (m *GetBalanceRequest) XXX_Unmarshal(b []byte) error { @@ -1281,7 +1489,7 @@ func (m *GetBalanceResponse) Reset() { *m = GetBalanceResponse{} } func (m *GetBalanceResponse) String() string { return proto.CompactTextString(m) } func (*GetBalanceResponse) ProtoMessage() {} func (*GetBalanceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{23} + return fileDescriptor_6960a02cc0a63cf6, []int{25} } func (m *GetBalanceResponse) XXX_Unmarshal(b []byte) error { @@ -1319,7 +1527,7 @@ func (m *GetInfoRequest) Reset() { *m = GetInfoRequest{} } func (m *GetInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetInfoRequest) ProtoMessage() {} func (*GetInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{24} + return fileDescriptor_6960a02cc0a63cf6, []int{26} } func (m *GetInfoRequest) XXX_Unmarshal(b []byte) error { @@ -1369,7 +1577,7 @@ func (m *GetInfoResponse) Reset() { *m = GetInfoResponse{} } func (m *GetInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetInfoResponse) ProtoMessage() {} func (*GetInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{25} + return fileDescriptor_6960a02cc0a63cf6, []int{27} } func (m *GetInfoResponse) XXX_Unmarshal(b []byte) error { @@ -1477,7 +1685,7 @@ func (m *GetMnemonicRequest) Reset() { *m = GetMnemonicRequest{} } func (m *GetMnemonicRequest) String() string { return proto.CompactTextString(m) } func (*GetMnemonicRequest) ProtoMessage() {} func (*GetMnemonicRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{26} + return fileDescriptor_6960a02cc0a63cf6, []int{28} } func (m *GetMnemonicRequest) XXX_Unmarshal(b []byte) error { @@ -1509,7 +1717,7 @@ func (m *GetMnemonicResponse) Reset() { *m = GetMnemonicResponse{} } func (m *GetMnemonicResponse) String() string { return proto.CompactTextString(m) } func (*GetMnemonicResponse) ProtoMessage() {} func (*GetMnemonicResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{27} + return fileDescriptor_6960a02cc0a63cf6, []int{29} } func (m *GetMnemonicResponse) XXX_Unmarshal(b []byte) error { @@ -1549,7 +1757,7 @@ func (m *GetNodeInfoRequest) Reset() { *m = GetNodeInfoRequest{} } func (m *GetNodeInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetNodeInfoRequest) ProtoMessage() {} func (*GetNodeInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{28} + return fileDescriptor_6960a02cc0a63cf6, []int{30} } func (m *GetNodeInfoRequest) XXX_Unmarshal(b []byte) error { @@ -1592,7 +1800,7 @@ func (m *GetNodeInfoResponse) Reset() { *m = GetNodeInfoResponse{} } func (m *GetNodeInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetNodeInfoResponse) ProtoMessage() {} func (*GetNodeInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{29} + return fileDescriptor_6960a02cc0a63cf6, []int{31} } func (m *GetNodeInfoResponse) XXX_Unmarshal(b []byte) error { @@ -1637,7 +1845,7 @@ func (m *ListCurrenciesRequest) Reset() { *m = ListCurrenciesRequest{} } func (m *ListCurrenciesRequest) String() string { return proto.CompactTextString(m) } func (*ListCurrenciesRequest) ProtoMessage() {} func (*ListCurrenciesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{30} + return fileDescriptor_6960a02cc0a63cf6, []int{32} } func (m *ListCurrenciesRequest) XXX_Unmarshal(b []byte) error { @@ -1670,7 +1878,7 @@ func (m *ListCurrenciesResponse) Reset() { *m = ListCurrenciesResponse{} func (m *ListCurrenciesResponse) String() string { return proto.CompactTextString(m) } func (*ListCurrenciesResponse) ProtoMessage() {} func (*ListCurrenciesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{31} + return fileDescriptor_6960a02cc0a63cf6, []int{33} } func (m *ListCurrenciesResponse) XXX_Unmarshal(b []byte) error { @@ -1716,7 +1924,7 @@ func (m *ListOrdersRequest) Reset() { *m = ListOrdersRequest{} } func (m *ListOrdersRequest) String() string { return proto.CompactTextString(m) } func (*ListOrdersRequest) ProtoMessage() {} func (*ListOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{32} + return fileDescriptor_6960a02cc0a63cf6, []int{34} } func (m *ListOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -1777,7 +1985,7 @@ func (m *ListOrdersResponse) Reset() { *m = ListOrdersResponse{} } func (m *ListOrdersResponse) String() string { return proto.CompactTextString(m) } func (*ListOrdersResponse) ProtoMessage() {} func (*ListOrdersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{33} + return fileDescriptor_6960a02cc0a63cf6, []int{35} } func (m *ListOrdersResponse) XXX_Unmarshal(b []byte) error { @@ -1815,7 +2023,7 @@ func (m *ListPairsRequest) Reset() { *m = ListPairsRequest{} } func (m *ListPairsRequest) String() string { return proto.CompactTextString(m) } func (*ListPairsRequest) ProtoMessage() {} func (*ListPairsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{34} + return fileDescriptor_6960a02cc0a63cf6, []int{36} } func (m *ListPairsRequest) XXX_Unmarshal(b []byte) error { @@ -1848,7 +2056,7 @@ func (m *ListPairsResponse) Reset() { *m = ListPairsResponse{} } func (m *ListPairsResponse) String() string { return proto.CompactTextString(m) } func (*ListPairsResponse) ProtoMessage() {} func (*ListPairsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{35} + return fileDescriptor_6960a02cc0a63cf6, []int{37} } func (m *ListPairsResponse) XXX_Unmarshal(b []byte) error { @@ -1886,7 +2094,7 @@ func (m *ListPeersRequest) Reset() { *m = ListPeersRequest{} } func (m *ListPeersRequest) String() string { return proto.CompactTextString(m) } func (*ListPeersRequest) ProtoMessage() {} func (*ListPeersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{36} + return fileDescriptor_6960a02cc0a63cf6, []int{38} } func (m *ListPeersRequest) XXX_Unmarshal(b []byte) error { @@ -1919,7 +2127,7 @@ func (m *ListPeersResponse) Reset() { *m = ListPeersResponse{} } func (m *ListPeersResponse) String() string { return proto.CompactTextString(m) } func (*ListPeersResponse) ProtoMessage() {} func (*ListPeersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{37} + return fileDescriptor_6960a02cc0a63cf6, []int{39} } func (m *ListPeersResponse) XXX_Unmarshal(b []byte) error { @@ -1964,7 +2172,7 @@ func (m *LndInfo) Reset() { *m = LndInfo{} } func (m *LndInfo) String() string { return proto.CompactTextString(m) } func (*LndInfo) ProtoMessage() {} func (*LndInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{38} + return fileDescriptor_6960a02cc0a63cf6, []int{40} } func (m *LndInfo) XXX_Unmarshal(b []byte) error { @@ -2048,7 +2256,7 @@ func (m *NodeIdentifier) Reset() { *m = NodeIdentifier{} } func (m *NodeIdentifier) String() string { return proto.CompactTextString(m) } func (*NodeIdentifier) ProtoMessage() {} func (*NodeIdentifier) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{39} + return fileDescriptor_6960a02cc0a63cf6, []int{41} } func (m *NodeIdentifier) XXX_Unmarshal(b []byte) error { @@ -2103,7 +2311,7 @@ func (m *OpenChannelRequest) Reset() { *m = OpenChannelRequest{} } func (m *OpenChannelRequest) String() string { return proto.CompactTextString(m) } func (*OpenChannelRequest) ProtoMessage() {} func (*OpenChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{40} + return fileDescriptor_6960a02cc0a63cf6, []int{42} } func (m *OpenChannelRequest) XXX_Unmarshal(b []byte) error { @@ -2171,7 +2379,7 @@ func (m *OpenChannelResponse) Reset() { *m = OpenChannelResponse{} } func (m *OpenChannelResponse) String() string { return proto.CompactTextString(m) } func (*OpenChannelResponse) ProtoMessage() {} func (*OpenChannelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{41} + return fileDescriptor_6960a02cc0a63cf6, []int{43} } func (m *OpenChannelResponse) XXX_Unmarshal(b []byte) error { @@ -2229,7 +2437,7 @@ func (m *Order) Reset() { *m = Order{} } func (m *Order) String() string { return proto.CompactTextString(m) } func (*Order) ProtoMessage() {} func (*Order) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{42} + return fileDescriptor_6960a02cc0a63cf6, []int{44} } func (m *Order) XXX_Unmarshal(b []byte) error { @@ -2340,7 +2548,7 @@ func (m *OrderRemoval) Reset() { *m = OrderRemoval{} } func (m *OrderRemoval) String() string { return proto.CompactTextString(m) } func (*OrderRemoval) ProtoMessage() {} func (*OrderRemoval) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{43} + return fileDescriptor_6960a02cc0a63cf6, []int{45} } func (m *OrderRemoval) XXX_Unmarshal(b []byte) error { @@ -2410,7 +2618,7 @@ func (m *Orders) Reset() { *m = Orders{} } func (m *Orders) String() string { return proto.CompactTextString(m) } func (*Orders) ProtoMessage() {} func (*Orders) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{44} + return fileDescriptor_6960a02cc0a63cf6, []int{46} } func (m *Orders) XXX_Unmarshal(b []byte) error { @@ -2459,7 +2667,7 @@ func (m *OrdersCount) Reset() { *m = OrdersCount{} } func (m *OrdersCount) String() string { return proto.CompactTextString(m) } func (*OrdersCount) ProtoMessage() {} func (*OrdersCount) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{45} + return fileDescriptor_6960a02cc0a63cf6, []int{47} } func (m *OrdersCount) XXX_Unmarshal(b []byte) error { @@ -2508,7 +2716,7 @@ func (m *OrderUpdate) Reset() { *m = OrderUpdate{} } func (m *OrderUpdate) String() string { return proto.CompactTextString(m) } func (*OrderUpdate) ProtoMessage() {} func (*OrderUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{46} + return fileDescriptor_6960a02cc0a63cf6, []int{48} } func (m *OrderUpdate) XXX_Unmarshal(b []byte) error { @@ -2600,7 +2808,7 @@ func (m *Peer) Reset() { *m = Peer{} } func (m *Peer) String() string { return proto.CompactTextString(m) } func (*Peer) ProtoMessage() {} func (*Peer) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{47} + return fileDescriptor_6960a02cc0a63cf6, []int{49} } func (m *Peer) XXX_Unmarshal(b []byte) error { @@ -2702,7 +2910,7 @@ func (m *PlaceOrderRequest) Reset() { *m = PlaceOrderRequest{} } func (m *PlaceOrderRequest) String() string { return proto.CompactTextString(m) } func (*PlaceOrderRequest) ProtoMessage() {} func (*PlaceOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{48} + return fileDescriptor_6960a02cc0a63cf6, []int{50} } func (m *PlaceOrderRequest) XXX_Unmarshal(b []byte) error { @@ -2790,7 +2998,7 @@ func (m *PlaceOrderResponse) Reset() { *m = PlaceOrderResponse{} } func (m *PlaceOrderResponse) String() string { return proto.CompactTextString(m) } func (*PlaceOrderResponse) ProtoMessage() {} func (*PlaceOrderResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{49} + return fileDescriptor_6960a02cc0a63cf6, []int{51} } func (m *PlaceOrderResponse) XXX_Unmarshal(b []byte) error { @@ -2855,7 +3063,7 @@ func (m *PlaceOrderEvent) Reset() { *m = PlaceOrderEvent{} } func (m *PlaceOrderEvent) String() string { return proto.CompactTextString(m) } func (*PlaceOrderEvent) ProtoMessage() {} func (*PlaceOrderEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{50} + return fileDescriptor_6960a02cc0a63cf6, []int{52} } func (m *PlaceOrderEvent) XXX_Unmarshal(b []byte) error { @@ -2963,7 +3171,7 @@ func (m *ConnextInfo) Reset() { *m = ConnextInfo{} } func (m *ConnextInfo) String() string { return proto.CompactTextString(m) } func (*ConnextInfo) ProtoMessage() {} func (*ConnextInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{51} + return fileDescriptor_6960a02cc0a63cf6, []int{53} } func (m *ConnextInfo) XXX_Unmarshal(b []byte) error { @@ -3024,7 +3232,7 @@ func (m *RemoveCurrencyRequest) Reset() { *m = RemoveCurrencyRequest{} } func (m *RemoveCurrencyRequest) String() string { return proto.CompactTextString(m) } func (*RemoveCurrencyRequest) ProtoMessage() {} func (*RemoveCurrencyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{52} + return fileDescriptor_6960a02cc0a63cf6, []int{54} } func (m *RemoveCurrencyRequest) XXX_Unmarshal(b []byte) error { @@ -3062,7 +3270,7 @@ func (m *RemoveCurrencyResponse) Reset() { *m = RemoveCurrencyResponse{} func (m *RemoveCurrencyResponse) String() string { return proto.CompactTextString(m) } func (*RemoveCurrencyResponse) ProtoMessage() {} func (*RemoveCurrencyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{53} + return fileDescriptor_6960a02cc0a63cf6, []int{55} } func (m *RemoveCurrencyResponse) XXX_Unmarshal(b []byte) error { @@ -3098,7 +3306,7 @@ func (m *RemoveOrderRequest) Reset() { *m = RemoveOrderRequest{} } func (m *RemoveOrderRequest) String() string { return proto.CompactTextString(m) } func (*RemoveOrderRequest) ProtoMessage() {} func (*RemoveOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{54} + return fileDescriptor_6960a02cc0a63cf6, []int{56} } func (m *RemoveOrderRequest) XXX_Unmarshal(b []byte) error { @@ -3152,7 +3360,7 @@ func (m *RemoveOrderResponse) Reset() { *m = RemoveOrderResponse{} } func (m *RemoveOrderResponse) String() string { return proto.CompactTextString(m) } func (*RemoveOrderResponse) ProtoMessage() {} func (*RemoveOrderResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{55} + return fileDescriptor_6960a02cc0a63cf6, []int{57} } func (m *RemoveOrderResponse) XXX_Unmarshal(b []byte) error { @@ -3211,7 +3419,7 @@ func (m *RemoveAllOrdersRequest) Reset() { *m = RemoveAllOrdersRequest{} func (m *RemoveAllOrdersRequest) String() string { return proto.CompactTextString(m) } func (*RemoveAllOrdersRequest) ProtoMessage() {} func (*RemoveAllOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{56} + return fileDescriptor_6960a02cc0a63cf6, []int{58} } func (m *RemoveAllOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -3246,7 +3454,7 @@ func (m *RemoveAllOrdersResponse) Reset() { *m = RemoveAllOrdersResponse func (m *RemoveAllOrdersResponse) String() string { return proto.CompactTextString(m) } func (*RemoveAllOrdersResponse) ProtoMessage() {} func (*RemoveAllOrdersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{57} + return fileDescriptor_6960a02cc0a63cf6, []int{59} } func (m *RemoveAllOrdersResponse) XXX_Unmarshal(b []byte) error { @@ -3293,7 +3501,7 @@ func (m *RemovePairRequest) Reset() { *m = RemovePairRequest{} } func (m *RemovePairRequest) String() string { return proto.CompactTextString(m) } func (*RemovePairRequest) ProtoMessage() {} func (*RemovePairRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{58} + return fileDescriptor_6960a02cc0a63cf6, []int{60} } func (m *RemovePairRequest) XXX_Unmarshal(b []byte) error { @@ -3331,7 +3539,7 @@ func (m *RemovePairResponse) Reset() { *m = RemovePairResponse{} } func (m *RemovePairResponse) String() string { return proto.CompactTextString(m) } func (*RemovePairResponse) ProtoMessage() {} func (*RemovePairResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{59} + return fileDescriptor_6960a02cc0a63cf6, []int{61} } func (m *RemovePairResponse) XXX_Unmarshal(b []byte) error { @@ -3371,7 +3579,7 @@ func (m *RestoreNodeRequest) Reset() { *m = RestoreNodeRequest{} } func (m *RestoreNodeRequest) String() string { return proto.CompactTextString(m) } func (*RestoreNodeRequest) ProtoMessage() {} func (*RestoreNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{60} + return fileDescriptor_6960a02cc0a63cf6, []int{62} } func (m *RestoreNodeRequest) XXX_Unmarshal(b []byte) error { @@ -3434,7 +3642,7 @@ func (m *RestoreNodeResponse) Reset() { *m = RestoreNodeResponse{} } func (m *RestoreNodeResponse) String() string { return proto.CompactTextString(m) } func (*RestoreNodeResponse) ProtoMessage() {} func (*RestoreNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{61} + return fileDescriptor_6960a02cc0a63cf6, []int{63} } func (m *RestoreNodeResponse) XXX_Unmarshal(b []byte) error { @@ -3480,7 +3688,7 @@ func (m *SetLogLevelRequest) Reset() { *m = SetLogLevelRequest{} } func (m *SetLogLevelRequest) String() string { return proto.CompactTextString(m) } func (*SetLogLevelRequest) ProtoMessage() {} func (*SetLogLevelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{62} + return fileDescriptor_6960a02cc0a63cf6, []int{64} } func (m *SetLogLevelRequest) XXX_Unmarshal(b []byte) error { @@ -3518,7 +3726,7 @@ func (m *SetLogLevelResponse) Reset() { *m = SetLogLevelResponse{} } func (m *SetLogLevelResponse) String() string { return proto.CompactTextString(m) } func (*SetLogLevelResponse) ProtoMessage() {} func (*SetLogLevelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{63} + return fileDescriptor_6960a02cc0a63cf6, []int{65} } func (m *SetLogLevelResponse) XXX_Unmarshal(b []byte) error { @@ -3549,7 +3757,7 @@ func (m *ShutdownRequest) Reset() { *m = ShutdownRequest{} } func (m *ShutdownRequest) String() string { return proto.CompactTextString(m) } func (*ShutdownRequest) ProtoMessage() {} func (*ShutdownRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{64} + return fileDescriptor_6960a02cc0a63cf6, []int{66} } func (m *ShutdownRequest) XXX_Unmarshal(b []byte) error { @@ -3580,7 +3788,7 @@ func (m *ShutdownResponse) Reset() { *m = ShutdownResponse{} } func (m *ShutdownResponse) String() string { return proto.CompactTextString(m) } func (*ShutdownResponse) ProtoMessage() {} func (*ShutdownResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{65} + return fileDescriptor_6960a02cc0a63cf6, []int{67} } func (m *ShutdownResponse) XXX_Unmarshal(b []byte) error { @@ -3613,7 +3821,7 @@ func (m *SubscribeOrdersRequest) Reset() { *m = SubscribeOrdersRequest{} func (m *SubscribeOrdersRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeOrdersRequest) ProtoMessage() {} func (*SubscribeOrdersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{66} + return fileDescriptor_6960a02cc0a63cf6, []int{68} } func (m *SubscribeOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -3641,6 +3849,37 @@ func (m *SubscribeOrdersRequest) GetExisting() bool { return false } +type SubscribeAlertsRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SubscribeAlertsRequest) Reset() { *m = SubscribeAlertsRequest{} } +func (m *SubscribeAlertsRequest) String() string { return proto.CompactTextString(m) } +func (*SubscribeAlertsRequest) ProtoMessage() {} +func (*SubscribeAlertsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{69} +} + +func (m *SubscribeAlertsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SubscribeAlertsRequest.Unmarshal(m, b) +} +func (m *SubscribeAlertsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SubscribeAlertsRequest.Marshal(b, m, deterministic) +} +func (m *SubscribeAlertsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SubscribeAlertsRequest.Merge(m, src) +} +func (m *SubscribeAlertsRequest) XXX_Size() int { + return xxx_messageInfo_SubscribeAlertsRequest.Size(m) +} +func (m *SubscribeAlertsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SubscribeAlertsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SubscribeAlertsRequest proto.InternalMessageInfo + type SubscribeSwapsAcceptedRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -3651,7 +3890,7 @@ func (m *SubscribeSwapsAcceptedRequest) Reset() { *m = SubscribeSwapsAcc func (m *SubscribeSwapsAcceptedRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeSwapsAcceptedRequest) ProtoMessage() {} func (*SubscribeSwapsAcceptedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{67} + return fileDescriptor_6960a02cc0a63cf6, []int{70} } func (m *SubscribeSwapsAcceptedRequest) XXX_Unmarshal(b []byte) error { @@ -3685,7 +3924,7 @@ func (m *SubscribeSwapsRequest) Reset() { *m = SubscribeSwapsRequest{} } func (m *SubscribeSwapsRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeSwapsRequest) ProtoMessage() {} func (*SubscribeSwapsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{68} + return fileDescriptor_6960a02cc0a63cf6, []int{71} } func (m *SubscribeSwapsRequest) XXX_Unmarshal(b []byte) error { @@ -3745,7 +3984,7 @@ func (m *SwapAccepted) Reset() { *m = SwapAccepted{} } func (m *SwapAccepted) String() string { return proto.CompactTextString(m) } func (*SwapAccepted) ProtoMessage() {} func (*SwapAccepted) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{69} + return fileDescriptor_6960a02cc0a63cf6, []int{72} } func (m *SwapAccepted) XXX_Unmarshal(b []byte) error { @@ -3863,7 +4102,7 @@ func (m *SwapFailure) Reset() { *m = SwapFailure{} } func (m *SwapFailure) String() string { return proto.CompactTextString(m) } func (*SwapFailure) ProtoMessage() {} func (*SwapFailure) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{70} + return fileDescriptor_6960a02cc0a63cf6, []int{73} } func (m *SwapFailure) XXX_Unmarshal(b []byte) error { @@ -3955,7 +4194,7 @@ func (m *SwapSuccess) Reset() { *m = SwapSuccess{} } func (m *SwapSuccess) String() string { return proto.CompactTextString(m) } func (*SwapSuccess) ProtoMessage() {} func (*SwapSuccess) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{71} + return fileDescriptor_6960a02cc0a63cf6, []int{74} } func (m *SwapSuccess) XXX_Unmarshal(b []byte) error { @@ -4099,7 +4338,7 @@ func (m *Trade) Reset() { *m = Trade{} } func (m *Trade) String() string { return proto.CompactTextString(m) } func (*Trade) ProtoMessage() {} func (*Trade) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{72} + return fileDescriptor_6960a02cc0a63cf6, []int{75} } func (m *Trade) XXX_Unmarshal(b []byte) error { @@ -4202,7 +4441,7 @@ func (m *TradeHistoryRequest) Reset() { *m = TradeHistoryRequest{} } func (m *TradeHistoryRequest) String() string { return proto.CompactTextString(m) } func (*TradeHistoryRequest) ProtoMessage() {} func (*TradeHistoryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{73} + return fileDescriptor_6960a02cc0a63cf6, []int{76} } func (m *TradeHistoryRequest) XXX_Unmarshal(b []byte) error { @@ -4241,7 +4480,7 @@ func (m *TradeHistoryResponse) Reset() { *m = TradeHistoryResponse{} } func (m *TradeHistoryResponse) String() string { return proto.CompactTextString(m) } func (*TradeHistoryResponse) ProtoMessage() {} func (*TradeHistoryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{74} + return fileDescriptor_6960a02cc0a63cf6, []int{77} } func (m *TradeHistoryResponse) XXX_Unmarshal(b []byte) error { @@ -4287,7 +4526,7 @@ func (m *TradingLimits) Reset() { *m = TradingLimits{} } func (m *TradingLimits) String() string { return proto.CompactTextString(m) } func (*TradingLimits) ProtoMessage() {} func (*TradingLimits) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{75} + return fileDescriptor_6960a02cc0a63cf6, []int{78} } func (m *TradingLimits) XXX_Unmarshal(b []byte) error { @@ -4349,7 +4588,7 @@ func (m *TradingLimitsRequest) Reset() { *m = TradingLimitsRequest{} } func (m *TradingLimitsRequest) String() string { return proto.CompactTextString(m) } func (*TradingLimitsRequest) ProtoMessage() {} func (*TradingLimitsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{76} + return fileDescriptor_6960a02cc0a63cf6, []int{79} } func (m *TradingLimitsRequest) XXX_Unmarshal(b []byte) error { @@ -4389,7 +4628,7 @@ func (m *TradingLimitsResponse) Reset() { *m = TradingLimitsResponse{} } func (m *TradingLimitsResponse) String() string { return proto.CompactTextString(m) } func (*TradingLimitsResponse) ProtoMessage() {} func (*TradingLimitsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{77} + return fileDescriptor_6960a02cc0a63cf6, []int{80} } func (m *TradingLimitsResponse) XXX_Unmarshal(b []byte) error { @@ -4431,7 +4670,7 @@ func (m *UnbanRequest) Reset() { *m = UnbanRequest{} } func (m *UnbanRequest) String() string { return proto.CompactTextString(m) } func (*UnbanRequest) ProtoMessage() {} func (*UnbanRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{78} + return fileDescriptor_6960a02cc0a63cf6, []int{81} } func (m *UnbanRequest) XXX_Unmarshal(b []byte) error { @@ -4476,7 +4715,7 @@ func (m *UnbanResponse) Reset() { *m = UnbanResponse{} } func (m *UnbanResponse) String() string { return proto.CompactTextString(m) } func (*UnbanResponse) ProtoMessage() {} func (*UnbanResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{79} + return fileDescriptor_6960a02cc0a63cf6, []int{82} } func (m *UnbanResponse) XXX_Unmarshal(b []byte) error { @@ -4510,7 +4749,7 @@ func (m *UnlockNodeRequest) Reset() { *m = UnlockNodeRequest{} } func (m *UnlockNodeRequest) String() string { return proto.CompactTextString(m) } func (*UnlockNodeRequest) ProtoMessage() {} func (*UnlockNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{80} + return fileDescriptor_6960a02cc0a63cf6, []int{83} } func (m *UnlockNodeRequest) XXX_Unmarshal(b []byte) error { @@ -4552,7 +4791,7 @@ func (m *UnlockNodeResponse) Reset() { *m = UnlockNodeResponse{} } func (m *UnlockNodeResponse) String() string { return proto.CompactTextString(m) } func (*UnlockNodeResponse) ProtoMessage() {} func (*UnlockNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{81} + return fileDescriptor_6960a02cc0a63cf6, []int{84} } func (m *UnlockNodeResponse) XXX_Unmarshal(b []byte) error { @@ -4608,7 +4847,7 @@ func (m *WithdrawRequest) Reset() { *m = WithdrawRequest{} } func (m *WithdrawRequest) String() string { return proto.CompactTextString(m) } func (*WithdrawRequest) ProtoMessage() {} func (*WithdrawRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6960a02cc0a63cf6, []int{82} + return fileDescriptor_6960a02cc0a63cf6, []int{85} } func (m *WithdrawRequest) XXX_Unmarshal(b []byte) error { @@ -4676,7 +4915,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_6960a02cc0a63cf6, []int{83} + return fileDescriptor_6960a02cc0a63cf6, []int{86} } func (m *WithdrawResponse) XXX_Unmarshal(b []byte) error { @@ -4708,12 +4947,16 @@ func init() { proto.RegisterEnum("xudrpc.OrderSide", OrderSide_name, OrderSide_value) proto.RegisterEnum("xudrpc.Role", Role_name, Role_value) proto.RegisterEnum("xudrpc.LogLevel", LogLevel_name, LogLevel_value) + proto.RegisterEnum("xudrpc.Alert_AlertType", Alert_AlertType_name, Alert_AlertType_value) + proto.RegisterEnum("xudrpc.BalanceAlert_Side", BalanceAlert_Side_name, BalanceAlert_Side_value) proto.RegisterEnum("xudrpc.Currency_SwapClient", Currency_SwapClient_name, Currency_SwapClient_value) proto.RegisterEnum("xudrpc.ListOrdersRequest_Owner", ListOrdersRequest_Owner_name, ListOrdersRequest_Owner_value) proto.RegisterType((*AddCurrencyResponse)(nil), "xudrpc.AddCurrencyResponse") proto.RegisterType((*AddPairRequest)(nil), "xudrpc.AddPairRequest") proto.RegisterType((*AddPairResponse)(nil), "xudrpc.AddPairResponse") + proto.RegisterType((*Alert)(nil), "xudrpc.Alert") proto.RegisterType((*Balance)(nil), "xudrpc.Balance") + proto.RegisterType((*BalanceAlert)(nil), "xudrpc.BalanceAlert") proto.RegisterType((*BanRequest)(nil), "xudrpc.BanRequest") proto.RegisterType((*BanResponse)(nil), "xudrpc.BanResponse") proto.RegisterType((*Chain)(nil), "xudrpc.Chain") @@ -4782,6 +5025,7 @@ func init() { proto.RegisterType((*ShutdownRequest)(nil), "xudrpc.ShutdownRequest") proto.RegisterType((*ShutdownResponse)(nil), "xudrpc.ShutdownResponse") proto.RegisterType((*SubscribeOrdersRequest)(nil), "xudrpc.SubscribeOrdersRequest") + proto.RegisterType((*SubscribeAlertsRequest)(nil), "xudrpc.SubscribeAlertsRequest") proto.RegisterType((*SubscribeSwapsAcceptedRequest)(nil), "xudrpc.SubscribeSwapsAcceptedRequest") proto.RegisterType((*SubscribeSwapsRequest)(nil), "xudrpc.SubscribeSwapsRequest") proto.RegisterType((*SwapAccepted)(nil), "xudrpc.SwapAccepted") @@ -4805,268 +5049,281 @@ func init() { func init() { proto.RegisterFile("xudrpc.proto", fileDescriptor_6960a02cc0a63cf6) } var fileDescriptor_6960a02cc0a63cf6 = []byte{ - // 4168 bytes of a gzipped FileDescriptorProto + // 4374 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x4d, 0x8f, 0x1c, 0x49, - 0x56, 0x9d, 0xd5, 0x5d, 0xdd, 0xd5, 0xaf, 0x3e, 0x3b, 0xfa, 0xc3, 0x35, 0x35, 0x9e, 0x19, 0x6f, - 0x30, 0x1e, 0x79, 0x3c, 0x33, 0xb6, 0xf1, 0xb0, 0xcc, 0x8e, 0x17, 0x8f, 0xa6, 0xbb, 0xdd, 0x3b, - 0xf6, 0x4c, 0xaf, 0x6d, 0x65, 0xdb, 0x63, 0xb3, 0x82, 0x4d, 0x65, 0x65, 0x86, 0xbb, 0x13, 0x67, - 0x67, 0xd6, 0x64, 0x66, 0xb9, 0x6d, 0xb8, 0xa0, 0x15, 0x27, 0x38, 0x70, 0x40, 0x9c, 0xe1, 0x84, - 0x90, 0x58, 0x71, 0xe5, 0x84, 0xc4, 0x99, 0x2b, 0x07, 0x24, 0xe0, 0x82, 0xc4, 0x2f, 0x40, 0x5c, - 0x91, 0xd0, 0x8b, 0x8f, 0x8c, 0x88, 0xcc, 0xac, 0x5e, 0x7b, 0x04, 0xdc, 0x2a, 0x5e, 0xbc, 0x7c, - 0x2f, 0xe2, 0x7d, 0xc7, 0x8b, 0x28, 0xe8, 0xbd, 0x9c, 0x87, 0xd9, 0x2c, 0xb8, 0x36, 0xcb, 0xd2, - 0x22, 0x25, 0xab, 0x62, 0x34, 0xd9, 0xf0, 0x93, 0x24, 0x2d, 0xfc, 0x22, 0x4a, 0x93, 0x5c, 0x4c, - 0xd1, 0x6d, 0xd8, 0xdc, 0x0d, 0xc3, 0xfd, 0x79, 0x96, 0xb1, 0x24, 0x78, 0xe5, 0xb2, 0x7c, 0x96, - 0x26, 0x39, 0xa3, 0x3f, 0x87, 0xc1, 0x6e, 0x18, 0x3e, 0xf4, 0xa3, 0xcc, 0x65, 0xdf, 0xcd, 0x59, - 0x5e, 0x90, 0xf7, 0xa1, 0x3f, 0xf5, 0x73, 0xe6, 0x05, 0x12, 0x75, 0xec, 0x5c, 0x72, 0xae, 0xac, - 0xbb, 0x36, 0x90, 0x7c, 0x00, 0x83, 0xef, 0xe6, 0x69, 0x61, 0xa0, 0xb5, 0x38, 0x5a, 0x05, 0x4a, - 0x37, 0x60, 0x58, 0xd2, 0x97, 0x2c, 0xff, 0xae, 0x05, 0x6b, 0x7b, 0x7e, 0xec, 0x27, 0x01, 0x43, - 0x66, 0x45, 0x5a, 0xf8, 0xb1, 0x37, 0x15, 0x00, 0xce, 0x6c, 0xc5, 0xb5, 0x81, 0xe4, 0x0a, 0x0c, - 0x83, 0x13, 0x3f, 0x49, 0x98, 0xc6, 0x6b, 0x71, 0xbc, 0x2a, 0x98, 0xfc, 0x08, 0x2e, 0xcc, 0x58, - 0x12, 0x46, 0xc9, 0xb1, 0x57, 0xfd, 0x62, 0x99, 0x7f, 0xb1, 0x68, 0x9a, 0xdc, 0x82, 0x71, 0x94, - 0xf8, 0x41, 0x11, 0xbd, 0x60, 0xb5, 0x4f, 0x57, 0xf8, 0xa7, 0x0b, 0xe7, 0x51, 0x18, 0x67, 0x7e, - 0x1c, 0xb3, 0xa2, 0xfc, 0xa2, 0xcd, 0xbf, 0xa8, 0x40, 0xc9, 0x17, 0x30, 0x99, 0x27, 0x41, 0x9a, - 0x3c, 0x8b, 0xb2, 0x53, 0x16, 0x7a, 0x95, 0x6f, 0x56, 0xf9, 0x37, 0xe7, 0x60, 0xd0, 0xdf, 0x04, - 0xd8, 0xf3, 0x13, 0xa5, 0xa8, 0x2b, 0x30, 0x4c, 0xd2, 0x90, 0x79, 0x51, 0xc8, 0x92, 0x22, 0x7a, - 0x16, 0xb1, 0x4c, 0xaa, 0xaa, 0x0a, 0xa6, 0x7d, 0xe8, 0xf2, 0xef, 0xa4, 0x02, 0x3e, 0x83, 0xf6, - 0xfe, 0x89, 0x1f, 0x25, 0x64, 0x0b, 0xda, 0x01, 0xfe, 0x90, 0xdf, 0x89, 0x01, 0x19, 0xc3, 0x5a, - 0xc2, 0x8a, 0xb3, 0x34, 0x7b, 0x2e, 0x75, 0xaa, 0x86, 0x74, 0x06, 0x9d, 0x7d, 0xb1, 0xf5, 0x9c, - 0xec, 0xc0, 0xaa, 0x90, 0x06, 0xff, 0xb8, 0xef, 0xca, 0x11, 0x99, 0x40, 0x47, 0xc9, 0x89, 0x7f, - 0xde, 0x77, 0xcb, 0x31, 0x52, 0x96, 0xe2, 0xe7, 0xda, 0xe8, 0xbb, 0x6a, 0x88, 0xd4, 0x82, 0x38, - 0xcd, 0x59, 0xc8, 0x65, 0xdd, 0x77, 0xe5, 0x88, 0x7a, 0xb0, 0x8d, 0x1c, 0x8f, 0xd9, 0x43, 0x3f, - 0xcf, 0xcf, 0xd2, 0x2c, 0x54, 0x9b, 0xa7, 0xd0, 0x4b, 0xd8, 0x99, 0x37, 0x93, 0x60, 0xb9, 0x03, - 0x0b, 0x86, 0x38, 0x69, 0x1c, 0x6a, 0x1c, 0xb1, 0x1b, 0x0b, 0x46, 0xc7, 0xb0, 0x53, 0x65, 0x20, - 0xa5, 0xf4, 0xf7, 0x0e, 0x6c, 0xee, 0xe3, 0x2a, 0xe4, 0x96, 0xdf, 0x58, 0xec, 0x28, 0x8a, 0x8a, - 0x77, 0x94, 0x63, 0x14, 0xfd, 0xb3, 0x34, 0x93, 0x66, 0xd9, 0x71, 0xc5, 0x80, 0x5c, 0x82, 0x6e, - 0xc8, 0xf2, 0x22, 0x4a, 0xb8, 0xeb, 0x72, 0x59, 0xac, 0xbb, 0x26, 0x88, 0x8b, 0xfd, 0x34, 0x9d, - 0x27, 0x85, 0x34, 0x31, 0x39, 0x22, 0x23, 0x58, 0x7e, 0xc6, 0x94, 0x0d, 0xe1, 0x4f, 0xfa, 0x25, - 0x6c, 0xd9, 0xcb, 0x17, 0xfb, 0xc2, 0xf5, 0x17, 0x99, 0x9f, 0xe4, 0xa8, 0x93, 0x34, 0xf1, 0xa2, - 0x30, 0x1f, 0x3b, 0x97, 0x96, 0x71, 0xfd, 0x15, 0x30, 0xfd, 0x18, 0x06, 0xfb, 0x69, 0x92, 0xb0, - 0xa0, 0x50, 0x7b, 0x9f, 0x40, 0x87, 0x6f, 0x72, 0x9e, 0x45, 0x72, 0xd3, 0xe5, 0x18, 0x3d, 0xbd, - 0xc4, 0x96, 0x22, 0xbc, 0x0e, 0x1b, 0xfb, 0x19, 0xf3, 0x0b, 0x76, 0x3f, 0x0d, 0x99, 0x41, 0xa3, - 0xa2, 0xb5, 0x72, 0x4c, 0xff, 0xdc, 0x01, 0x62, 0x7e, 0x21, 0x97, 0xfc, 0x6b, 0xd0, 0xcf, 0x19, - 0x0b, 0xbd, 0xd3, 0x84, 0x9d, 0xa6, 0x49, 0x14, 0xc8, 0x05, 0xf7, 0x10, 0xf8, 0x53, 0x09, 0x23, - 0x1f, 0xc2, 0x28, 0x4a, 0xa2, 0x22, 0xf2, 0xe3, 0xe8, 0xf7, 0x59, 0xe8, 0xc5, 0x49, 0x98, 0x8f, - 0x5b, 0x62, 0x63, 0x06, 0xfc, 0x30, 0x09, 0x73, 0x72, 0x1d, 0x36, 0x4d, 0xd4, 0x00, 0x97, 0xfd, - 0xb2, 0x90, 0xaa, 0x20, 0xc6, 0xd4, 0xbe, 0x98, 0xa1, 0xff, 0xec, 0x40, 0x47, 0x85, 0x4e, 0x4b, - 0xad, 0x4e, 0x45, 0xad, 0xb7, 0xa1, 0x9b, 0x9f, 0xf9, 0x33, 0x2f, 0x88, 0x23, 0x96, 0x14, 0x5c, - 0xeb, 0x83, 0x9b, 0x6f, 0x5f, 0x93, 0x41, 0x5a, 0x91, 0xb8, 0x76, 0x74, 0xe6, 0xcf, 0xf6, 0x39, - 0x8a, 0x6b, 0xe2, 0x8b, 0x70, 0xf8, 0x9c, 0x25, 0x9e, 0x1f, 0x86, 0x19, 0xcb, 0x73, 0xbe, 0xa4, - 0x75, 0xd7, 0x06, 0x62, 0xb8, 0x09, 0x59, 0x10, 0x9d, 0xfa, 0xb1, 0x37, 0x8b, 0xfd, 0x80, 0xe5, - 0xd2, 0x69, 0x2a, 0x50, 0x4a, 0x01, 0x34, 0x23, 0xb2, 0x06, 0xcb, 0x87, 0xf7, 0xef, 0x8c, 0x96, - 0x48, 0x17, 0xd6, 0xf6, 0x1f, 0xdc, 0xbf, 0x7f, 0xf0, 0xf4, 0xd1, 0xa8, 0x85, 0x3a, 0xbe, 0xc3, - 0x66, 0x69, 0x1e, 0x99, 0x3a, 0x5e, 0xb4, 0x3d, 0xfa, 0x11, 0x0c, 0x4b, 0x6c, 0xa9, 0x9b, 0x31, - 0xac, 0xa9, 0xc5, 0x0a, 0x6c, 0x35, 0x44, 0x03, 0xbc, 0x13, 0xe5, 0x41, 0xfa, 0x82, 0x65, 0xa8, - 0xcd, 0xfc, 0xcd, 0xe3, 0xd6, 0x0f, 0x61, 0xbb, 0x42, 0x41, 0x32, 0xbd, 0x08, 0xeb, 0xc9, 0xfc, - 0xd4, 0x43, 0xfc, 0x5c, 0xc6, 0x1f, 0x0d, 0xa0, 0x7f, 0xec, 0x00, 0x39, 0x78, 0xc9, 0x82, 0x79, - 0xc1, 0x70, 0xff, 0xc6, 0xc6, 0xd2, 0x2c, 0x64, 0x99, 0x17, 0x95, 0x86, 0xa7, 0xc6, 0x3c, 0x32, - 0xf9, 0x11, 0x9f, 0x92, 0x31, 0x4f, 0x0e, 0x31, 0x88, 0xcc, 0x18, 0xcb, 0xbc, 0xd9, 0x7c, 0xea, - 0x3d, 0x67, 0xaf, 0xa4, 0x46, 0x2c, 0x18, 0x52, 0xfe, 0x6e, 0xee, 0x27, 0x45, 0x54, 0xbc, 0x92, - 0xb9, 0xa2, 0x1c, 0xa3, 0x0f, 0x7c, 0xc5, 0x0a, 0x99, 0xef, 0x5e, 0x47, 0xc6, 0x7f, 0xed, 0x00, - 0x31, 0xbf, 0x90, 0x5b, 0xbe, 0x03, 0x1d, 0x99, 0x06, 0x84, 0xbf, 0x76, 0x6f, 0x5e, 0x51, 0x66, - 0x55, 0xc7, 0xbe, 0x26, 0xc7, 0xf9, 0x41, 0x52, 0x64, 0xaf, 0xdc, 0xf2, 0xcb, 0xc9, 0x21, 0xf4, - 0xad, 0x29, 0x8c, 0x1b, 0xb8, 0x2b, 0xb1, 0x08, 0xfc, 0x49, 0x2e, 0x43, 0xfb, 0x85, 0x1f, 0xcf, - 0x45, 0xf4, 0xee, 0xde, 0x1c, 0x2a, 0x2e, 0x8a, 0x85, 0x98, 0xbd, 0xd5, 0xfa, 0x91, 0x43, 0x47, - 0x30, 0xf8, 0x8a, 0x15, 0xf7, 0x92, 0x67, 0xa9, 0xdc, 0x18, 0xfd, 0x97, 0x65, 0x18, 0x96, 0x20, - 0x6d, 0x21, 0x2f, 0x58, 0x96, 0x63, 0x40, 0x93, 0x16, 0x22, 0x87, 0x3c, 0x88, 0xa3, 0xca, 0x95, - 0x6c, 0x65, 0x80, 0x36, 0x61, 0x84, 0xc0, 0xca, 0x3c, 0x8b, 0xd0, 0x13, 0xd0, 0x95, 0xf9, 0x6f, - 0xa5, 0x7e, 0xd4, 0x81, 0xb2, 0x7d, 0x0d, 0x28, 0x67, 0xfd, 0x28, 0xcb, 0x79, 0x94, 0x54, 0xb3, - 0x08, 0x20, 0x1f, 0xc1, 0x2a, 0xd7, 0x7a, 0xce, 0x63, 0x65, 0xf7, 0xe6, 0xa6, 0xda, 0xdf, 0x03, - 0x0e, 0xdd, 0xc7, 0x68, 0xea, 0x4a, 0x14, 0x72, 0x13, 0x96, 0xe3, 0x24, 0x1c, 0xaf, 0x71, 0x79, - 0x5f, 0x32, 0xe4, 0x6d, 0x6e, 0xf0, 0xda, 0x61, 0x12, 0x0a, 0x39, 0x23, 0x32, 0x46, 0x76, 0x3f, - 0x8e, 0xfc, 0x7c, 0xbc, 0x2e, 0x92, 0x2a, 0x1f, 0x98, 0x49, 0x15, 0xac, 0xa4, 0x4a, 0x6e, 0xc0, - 0xa6, 0xaa, 0x49, 0x78, 0x28, 0x38, 0xf1, 0xf3, 0x13, 0x96, 0x8f, 0xbb, 0x7c, 0xbf, 0x4d, 0x53, - 0xe4, 0x13, 0x58, 0x53, 0x21, 0xab, 0x67, 0xef, 0x41, 0xc6, 0x2b, 0xbe, 0x3a, 0x85, 0x33, 0xf9, - 0x0a, 0x3a, 0x6a, 0x85, 0x6f, 0xa0, 0xee, 0xc3, 0x24, 0xe4, 0x64, 0x0c, 0x75, 0x6f, 0x71, 0xc3, - 0x54, 0x01, 0x57, 0xa9, 0xfc, 0xc7, 0xb0, 0x69, 0x41, 0xa5, 0xd6, 0xdf, 0x6f, 0x8e, 0xd9, 0x36, - 0x90, 0x7e, 0xc1, 0x49, 0xa2, 0x73, 0x1b, 0x56, 0xf4, 0x06, 0x11, 0xc2, 0xe5, 0xcc, 0xf5, 0xf7, - 0x65, 0xc2, 0x18, 0x66, 0x6c, 0x36, 0x17, 0x15, 0xf0, 0x51, 0x90, 0x66, 0xa2, 0x4a, 0xd9, 0x70, - 0x41, 0x83, 0x31, 0x95, 0x4e, 0x31, 0x35, 0x0a, 0x97, 0xef, 0xb8, 0x72, 0x44, 0x2f, 0xc0, 0xf6, - 0x61, 0x94, 0x17, 0x32, 0x58, 0x47, 0x65, 0xe0, 0xa2, 0x5f, 0xc3, 0x4e, 0x75, 0x42, 0xf2, 0xbb, - 0x01, 0x10, 0x94, 0x50, 0xe9, 0x9e, 0xa3, 0x6a, 0xd4, 0x77, 0x0d, 0x1c, 0xfa, 0x8f, 0x0e, 0x6c, - 0x20, 0x31, 0x61, 0x75, 0x6a, 0xe3, 0x46, 0x18, 0x72, 0xec, 0x30, 0xf4, 0x43, 0x68, 0xa7, 0x67, - 0x09, 0xcb, 0x64, 0x4a, 0x79, 0xaf, 0x54, 0x53, 0x95, 0xc6, 0xb5, 0x07, 0x88, 0xe6, 0x0a, 0x6c, - 0x34, 0xc6, 0x38, 0x3a, 0x8d, 0x0a, 0x59, 0x6f, 0x89, 0x01, 0xca, 0x37, 0x4a, 0x82, 0x78, 0x1e, - 0x32, 0x8f, 0x5b, 0xa7, 0xcc, 0x20, 0x1d, 0xb7, 0x0a, 0xa6, 0xef, 0x43, 0x9b, 0xd3, 0x23, 0x1d, - 0x58, 0xd9, 0x7b, 0xf0, 0xe8, 0xee, 0x68, 0x09, 0xf3, 0xc8, 0x83, 0x27, 0xf7, 0x47, 0x0e, 0x82, - 0x1e, 0x1e, 0x1c, 0xb8, 0xa3, 0x16, 0xfd, 0x0b, 0x07, 0x88, 0xb9, 0x10, 0x29, 0x95, 0x2f, 0x4a, - 0x57, 0x13, 0x12, 0xf9, 0xa0, 0x69, 0xd1, 0xd2, 0x87, 0xc4, 0x50, 0xb8, 0x91, 0xfc, 0x6a, 0x72, - 0x0f, 0xba, 0x06, 0xb8, 0xc1, 0x76, 0xdf, 0xb7, 0x6d, 0x77, 0x60, 0xbb, 0xb2, 0x69, 0xba, 0x04, - 0x46, 0xc8, 0x14, 0xcf, 0x21, 0xa5, 0x3a, 0x3f, 0x14, 0x1a, 0x90, 0x30, 0xb9, 0xe6, 0x2d, 0x68, - 0x8b, 0xc0, 0x21, 0xcc, 0x55, 0x0c, 0xca, 0xcf, 0x99, 0x96, 0x33, 0xfd, 0x4c, 0x7e, 0xce, 0xcc, - 0x2d, 0x53, 0x68, 0x8b, 0xa8, 0x24, 0x76, 0xdc, 0x53, 0x2b, 0x42, 0x2c, 0x57, 0x4c, 0xd1, 0x7f, - 0x73, 0x60, 0x4d, 0x7a, 0x17, 0xda, 0x60, 0x5e, 0xf8, 0xc5, 0x5c, 0x25, 0x4f, 0x39, 0x22, 0x1f, - 0x43, 0x47, 0x1e, 0x32, 0x72, 0xb9, 0x39, 0x6d, 0x4e, 0x12, 0xee, 0x96, 0x18, 0xe4, 0x32, 0xac, - 0xf2, 0xd2, 0x5d, 0x44, 0xc9, 0xee, 0xcd, 0xbe, 0x81, 0x1b, 0x25, 0xae, 0x9c, 0xc4, 0xea, 0x72, - 0x1a, 0xa7, 0xc1, 0xf3, 0x13, 0x16, 0x1d, 0x9f, 0x14, 0x32, 0x70, 0x9a, 0xa0, 0x32, 0xd8, 0xb6, - 0x8d, 0x60, 0x6b, 0x84, 0xef, 0x55, 0x3b, 0x7c, 0x97, 0x91, 0x6e, 0xcd, 0x88, 0x74, 0xf4, 0x6b, - 0x18, 0x70, 0x7f, 0xd4, 0x75, 0x70, 0x35, 0xcc, 0x3b, 0x0d, 0x61, 0xbe, 0xa4, 0xd5, 0x32, 0x69, - 0xfd, 0x95, 0x03, 0xe4, 0xc1, 0x8c, 0x25, 0xff, 0x27, 0x25, 0xb8, 0x2e, 0xa5, 0x97, 0xad, 0x52, - 0xfa, 0x12, 0x74, 0x67, 0xf3, 0xfc, 0xc4, 0x93, 0x93, 0x22, 0xa1, 0x9b, 0x20, 0x55, 0x6c, 0xb7, - 0x75, 0xb1, 0x7d, 0x1b, 0x36, 0xad, 0x75, 0x4a, 0x73, 0xf8, 0x00, 0x06, 0x76, 0x51, 0x2d, 0xd7, - 0x59, 0x81, 0xd2, 0x7f, 0x68, 0x41, 0x9b, 0x1b, 0x2d, 0xb7, 0xbf, 0x2c, 0x92, 0x07, 0x61, 0xc7, - 0x15, 0x03, 0xab, 0xc0, 0x68, 0xd9, 0x05, 0x86, 0x19, 0x33, 0x96, 0xed, 0x98, 0x31, 0x80, 0x56, - 0x14, 0xca, 0x43, 0x44, 0x2b, 0x0a, 0xc9, 0x97, 0x75, 0xb1, 0xb5, 0xb9, 0x6d, 0xed, 0x28, 0x7b, - 0xb1, 0x15, 0xd7, 0x28, 0xce, 0x38, 0x0d, 0xfc, 0x18, 0x99, 0x09, 0x63, 0x28, 0xc7, 0xe4, 0x5d, - 0x80, 0x80, 0x97, 0xee, 0xa1, 0xe7, 0x17, 0xdc, 0x24, 0x56, 0x5c, 0x03, 0x42, 0x2e, 0xc3, 0x4a, - 0x1e, 0x85, 0x6c, 0xdc, 0xe1, 0x01, 0x6c, 0xc3, 0xf2, 0xd5, 0xa3, 0x28, 0x64, 0x2e, 0x9f, 0x46, - 0x63, 0x89, 0x72, 0x2f, 0x3d, 0x4b, 0x3c, 0x1e, 0x05, 0x78, 0x16, 0xed, 0xb8, 0x16, 0x0c, 0xcd, - 0xf4, 0x24, 0x8d, 0x43, 0x9e, 0x49, 0x57, 0x5c, 0xfe, 0x9b, 0xfe, 0xa5, 0x03, 0x3d, 0x4e, 0xcb, - 0x65, 0xa7, 0xe9, 0x0b, 0x3f, 0xb6, 0x64, 0xe6, 0x2c, 0x96, 0x59, 0xa5, 0xdc, 0x33, 0x8b, 0xc4, - 0xe5, 0x4a, 0x91, 0x68, 0xee, 0x7e, 0xa5, 0xb2, 0xfb, 0xea, 0xb2, 0xdb, 0xf5, 0x65, 0xd3, 0x13, - 0x58, 0x15, 0x91, 0x89, 0x7c, 0x02, 0x30, 0x9d, 0xbf, 0xf2, 0xac, 0xe8, 0xd8, 0xb7, 0x24, 0xe2, - 0x1a, 0x08, 0xe4, 0x3a, 0x74, 0x73, 0x16, 0xc7, 0x0a, 0xbf, 0xd5, 0x84, 0x6f, 0x62, 0xd0, 0x4f, - 0x55, 0xe4, 0xe4, 0xe5, 0x0c, 0xca, 0x0b, 0x43, 0x8f, 0xac, 0x94, 0xf9, 0x6f, 0xb4, 0xe1, 0xf4, - 0x2c, 0x91, 0x47, 0x74, 0xfc, 0x49, 0x7f, 0xe1, 0xc8, 0xaf, 0x1e, 0xcf, 0x42, 0xbf, 0x60, 0x58, - 0x19, 0x88, 0xbd, 0x38, 0xdc, 0x48, 0x6c, 0x7e, 0x77, 0x97, 0x5c, 0x31, 0x4b, 0x7e, 0x0b, 0xfa, - 0x42, 0x42, 0x99, 0x10, 0xbc, 0x8c, 0x57, 0x5b, 0xf6, 0xf2, 0xc4, 0xdc, 0xdd, 0x25, 0xd7, 0x46, - 0xde, 0x1b, 0x40, 0x4f, 0x00, 0xe6, 0x9c, 0x29, 0xfd, 0xd7, 0x16, 0xac, 0x60, 0xb0, 0x5c, 0x7c, - 0xae, 0x78, 0xad, 0xaa, 0xf1, 0x4b, 0xe8, 0xc5, 0x49, 0xa8, 0x86, 0x2a, 0x2e, 0x5e, 0x34, 0xc3, - 0x31, 0x56, 0x38, 0x0f, 0xe7, 0xd3, 0x6f, 0xd8, 0x2b, 0x99, 0x76, 0xac, 0x2f, 0x90, 0x7f, 0x94, - 0x4c, 0xd3, 0x79, 0x12, 0xca, 0xdc, 0xa8, 0x86, 0x3a, 0x45, 0xb4, 0x8d, 0x14, 0x81, 0x51, 0xe3, - 0xe5, 0x3c, 0xf4, 0xec, 0x50, 0x69, 0x82, 0xc8, 0xc7, 0xb0, 0x91, 0xb3, 0x20, 0x4d, 0xc2, 0x5c, - 0x9c, 0x38, 0x83, 0x82, 0x85, 0xdc, 0x4f, 0xfa, 0x6e, 0x7d, 0xa2, 0xb9, 0x8c, 0x9c, 0xdc, 0x86, - 0x61, 0x65, 0xd9, 0x0d, 0x69, 0x71, 0xcb, 0x4c, 0x8b, 0xeb, 0x66, 0x1a, 0xfc, 0xc3, 0x16, 0x6c, - 0x3c, 0xc4, 0xc3, 0xa1, 0x54, 0x8a, 0x08, 0xa7, 0xff, 0x9b, 0x31, 0xc7, 0xf4, 0x9f, 0x95, 0x8a, - 0xff, 0xa8, 0x08, 0xd0, 0x3e, 0x3f, 0x02, 0x5c, 0x85, 0x51, 0xc6, 0xf8, 0x11, 0xd6, 0x2b, 0x49, - 0x09, 0x71, 0xd6, 0xe0, 0x58, 0x3c, 0x47, 0xa7, 0xa7, 0x2c, 0x8c, 0xfc, 0x02, 0xa1, 0x5e, 0x80, - 0x47, 0x94, 0x98, 0x4b, 0xb5, 0xe3, 0x36, 0x4d, 0xa1, 0x08, 0x88, 0x29, 0x02, 0x19, 0xa9, 0x3f, - 0x87, 0x51, 0x94, 0x14, 0x2c, 0x4b, 0xfc, 0xd8, 0x3b, 0xf5, 0x8b, 0xe0, 0x84, 0x2d, 0xf0, 0xcb, - 0x1a, 0x1a, 0xf9, 0x31, 0x0c, 0x78, 0x75, 0x9e, 0xcf, 0x83, 0x80, 0xe5, 0x58, 0x4c, 0x09, 0x07, - 0x2d, 0xab, 0x72, 0x3c, 0x84, 0x1e, 0x89, 0x49, 0xb7, 0x82, 0x4a, 0x3e, 0xc3, 0x4a, 0xf5, 0xd4, - 0x8f, 0x12, 0x2c, 0xf2, 0x85, 0xbb, 0x2d, 0x37, 0xb8, 0x9b, 0x5b, 0xc5, 0x22, 0x9f, 0x43, 0x9f, - 0x93, 0x7a, 0xe6, 0x47, 0xf1, 0x3c, 0xe3, 0x15, 0x5c, 0x8d, 0xe9, 0x4f, 0xc4, 0x9c, 0x6b, 0x63, - 0xd2, 0xff, 0x74, 0x60, 0xa8, 0x45, 0x70, 0xf0, 0x82, 0x25, 0x18, 0x9d, 0xdb, 0x7c, 0x3f, 0x0b, - 0x9d, 0x9d, 0xcf, 0x92, 0xcf, 0xa1, 0x67, 0x6e, 0x40, 0xfa, 0x7a, 0xd3, 0x4e, 0xef, 0x2e, 0xb9, - 0x16, 0x2a, 0xf9, 0xfc, 0xf5, 0x76, 0x7a, 0x77, 0xa9, 0x69, 0xaf, 0x3d, 0x73, 0x07, 0xdc, 0xb0, - 0x9a, 0xb7, 0x5a, 0x72, 0x95, 0xa8, 0x7b, 0x6b, 0xd0, 0x66, 0xb8, 0x41, 0x9a, 0x42, 0xd7, 0x38, - 0x1d, 0x2d, 0x2c, 0xbc, 0x8c, 0xb0, 0xd3, 0xb2, 0xc3, 0x8e, 0x51, 0x07, 0xad, 0xd4, 0xea, 0x20, - 0xd1, 0x46, 0x6d, 0x1b, 0x6d, 0x54, 0xfa, 0x29, 0x6c, 0xf3, 0xa8, 0xc7, 0x74, 0xcf, 0xfd, 0x57, - 0x1f, 0xfe, 0xc7, 0xb0, 0x53, 0xfd, 0x48, 0xf6, 0xd2, 0x0e, 0x81, 0x88, 0x19, 0xcb, 0x75, 0xcf, - 0xeb, 0x69, 0x9c, 0xe3, 0xc0, 0xf4, 0x6f, 0x1c, 0xd8, 0xb4, 0xc8, 0x49, 0x37, 0x78, 0x17, 0x46, - 0x0a, 0xc7, 0x4b, 0x13, 0x8f, 0x67, 0x59, 0x47, 0x67, 0x59, 0x72, 0x0d, 0x88, 0x56, 0x4e, 0x85, - 0x7a, 0xc3, 0x8c, 0xf0, 0x65, 0x64, 0x13, 0x6a, 0x6c, 0x51, 0x6d, 0xd5, 0xe0, 0x66, 0x50, 0x59, - 0xb1, 0x82, 0x8a, 0x96, 0xca, 0x6e, 0x1c, 0x5b, 0x87, 0x1d, 0x3a, 0x87, 0x0b, 0xb5, 0x19, 0xb9, - 0x95, 0x8f, 0x61, 0x43, 0xb1, 0x50, 0x22, 0x51, 0x55, 0x7d, 0x7d, 0x02, 0xb1, 0xe5, 0x7e, 0x0d, - 0x6c, 0xd1, 0x3e, 0xac, 0x4f, 0xd0, 0x4f, 0x60, 0x43, 0xb0, 0x35, 0x2f, 0x4e, 0x16, 0x1e, 0xde, - 0xf0, 0xe0, 0x6c, 0xa2, 0x4b, 0x8d, 0xfe, 0x51, 0x0b, 0xc1, 0x79, 0x91, 0x66, 0x56, 0x7f, 0xf4, - 0xb5, 0x9a, 0x9d, 0x66, 0x13, 0xb5, 0x65, 0x37, 0x51, 0xc9, 0x37, 0xd0, 0xc5, 0x4c, 0x36, 0xf5, - 0x83, 0xe7, 0xf3, 0x99, 0x4a, 0x7d, 0x57, 0x95, 0xb3, 0xd4, 0x39, 0x62, 0x22, 0xdc, 0x13, 0xc8, - 0x22, 0x11, 0x42, 0x5c, 0x02, 0xc8, 0x0f, 0xf8, 0x0d, 0x93, 0x17, 0xfa, 0x85, 0x3f, 0xf5, 0x73, - 0xd1, 0x60, 0xee, 0xf1, 0xbc, 0x76, 0x47, 0x82, 0x64, 0x4e, 0x32, 0x29, 0xfc, 0xaa, 0x9c, 0xd4, - 0x33, 0x73, 0x12, 0x43, 0x4b, 0x34, 0xd6, 0xa4, 0x7b, 0xbe, 0x99, 0x00, 0xcb, 0x5e, 0xae, 0x14, - 0x83, 0x02, 0xf2, 0x46, 0xee, 0x87, 0x68, 0x5e, 0x12, 0x49, 0xb5, 0x44, 0xc4, 0x61, 0x7e, 0xa8, - 0xe0, 0xaa, 0x85, 0x7b, 0x07, 0xc8, 0x11, 0x2b, 0x0e, 0xd3, 0xe3, 0x43, 0xf6, 0x42, 0x9f, 0x24, - 0xae, 0xc1, 0x7a, 0x9c, 0x1e, 0x7b, 0x31, 0xc2, 0xf8, 0x72, 0x07, 0xfa, 0xa0, 0x55, 0xe2, 0x6a, - 0x14, 0xba, 0x0d, 0x9b, 0x16, 0x15, 0xa9, 0xca, 0x0d, 0x18, 0x1e, 0x9d, 0xcc, 0x8b, 0x30, 0x3d, - 0x53, 0xb7, 0x33, 0x78, 0x64, 0xd4, 0x20, 0x89, 0xf6, 0x1b, 0xb0, 0x73, 0x34, 0x9f, 0xe6, 0x41, - 0x16, 0x4d, 0x99, 0x7d, 0xf0, 0x9f, 0x40, 0x87, 0xbd, 0x8c, 0xf2, 0x22, 0x4a, 0x8e, 0xf9, 0x32, - 0x3a, 0x6e, 0x39, 0xa6, 0xef, 0xc1, 0x3b, 0xe5, 0x57, 0x18, 0xea, 0xf2, 0xdd, 0x20, 0x60, 0xb3, - 0x82, 0xa9, 0xbb, 0x10, 0x7a, 0x1b, 0xb6, 0x6d, 0x04, 0xe3, 0x2a, 0x4f, 0x1d, 0xe8, 0x0b, 0xff, - 0xb9, 0xac, 0xe4, 0x3a, 0xae, 0x0d, 0xa4, 0xff, 0xdd, 0x82, 0x1e, 0x7e, 0xa6, 0xc8, 0x92, 0xb7, - 0x6a, 0x41, 0x65, 0x8d, 0x8f, 0xef, 0xd9, 0x25, 0x70, 0xab, 0x52, 0x02, 0x9f, 0x5b, 0x14, 0x2c, - 0xea, 0x8f, 0xea, 0xe2, 0xa3, 0x6d, 0x16, 0x1f, 0xd5, 0xae, 0xeb, 0x6a, 0x43, 0xd7, 0x75, 0x07, - 0x56, 0x33, 0xde, 0x12, 0x93, 0xe7, 0x4f, 0x39, 0xc2, 0x98, 0x23, 0xce, 0x69, 0x5e, 0xc6, 0x02, - 0x16, 0xbd, 0x40, 0x99, 0x76, 0x44, 0xcc, 0xa9, 0xc2, 0xf1, 0x80, 0x26, 0x61, 0xb9, 0xbc, 0x98, - 0x5a, 0x17, 0x37, 0x77, 0x36, 0x14, 0xe3, 0x9e, 0x8a, 0xd1, 0x06, 0x55, 0xd1, 0xc9, 0x6b, 0x98, - 0xc1, 0x35, 0x94, 0x50, 0x45, 0xb9, 0x2b, 0x6a, 0x98, 0x2a, 0x1c, 0x63, 0x71, 0xd7, 0x48, 0x61, - 0xdf, 0xb3, 0x4f, 0x6d, 0xca, 0x78, 0xb9, 0x22, 0xe3, 0xaa, 0x34, 0x57, 0x1a, 0xa4, 0xf9, 0x01, - 0x0c, 0x64, 0xce, 0xf4, 0x32, 0xe6, 0xe7, 0xa9, 0xca, 0x66, 0x15, 0x28, 0xfd, 0xdb, 0x65, 0xb1, - 0x5a, 0x99, 0xe6, 0xff, 0x7f, 0x8d, 0x45, 0xab, 0xbc, 0x6d, 0xa9, 0xfc, 0x0a, 0x0c, 0x2d, 0xd5, - 0xb2, 0x50, 0x6a, 0xbc, 0x0a, 0xc6, 0x32, 0x5d, 0xab, 0xb6, 0x90, 0xda, 0x36, 0x41, 0x35, 0x61, - 0x41, 0x83, 0xb0, 0x2e, 0xc1, 0x4a, 0x96, 0xc6, 0x8c, 0xab, 0x74, 0xa0, 0xbb, 0x3c, 0x6e, 0x1a, - 0x33, 0x97, 0xcf, 0x60, 0x3e, 0xa9, 0x98, 0x05, 0x0b, 0x79, 0xb7, 0x76, 0xdd, 0xad, 0x4f, 0xa0, - 0xa3, 0x9a, 0x66, 0x51, 0x8c, 0xfb, 0xe2, 0xde, 0xc7, 0x02, 0xe2, 0x09, 0x3b, 0xf3, 0x66, 0x19, - 0x8b, 0x4e, 0xfd, 0x63, 0x36, 0x1e, 0x70, 0x14, 0x03, 0xa2, 0x5d, 0x69, 0x68, 0xb8, 0x12, 0xfd, - 0xaf, 0x16, 0xb4, 0x1f, 0x65, 0x7e, 0xc8, 0xf0, 0x18, 0x79, 0x8a, 0x1e, 0xef, 0x2d, 0x3e, 0xd6, - 0xb9, 0x26, 0x06, 0x7e, 0x50, 0x18, 0x1f, 0xb4, 0x1a, 0x3f, 0x30, 0x30, 0x0c, 0xfd, 0x2c, 0x5b, - 0xfa, 0x39, 0x4f, 0xa7, 0x86, 0x25, 0xb4, 0x6d, 0x4b, 0x28, 0xf7, 0xb3, 0x6a, 0x86, 0x06, 0x25, - 0xfb, 0xb5, 0x85, 0xb2, 0xbf, 0x04, 0x5d, 0x26, 0xae, 0x7f, 0x78, 0x2b, 0x42, 0x58, 0x82, 0x09, - 0x2a, 0x4f, 0x22, 0xeb, 0xe7, 0x9f, 0x44, 0x6e, 0x41, 0x2f, 0x40, 0xc3, 0x60, 0xd9, 0xcc, 0xcf, - 0x0a, 0x61, 0x0a, 0x8b, 0xbb, 0x25, 0x16, 0x2e, 0xfd, 0x08, 0x36, 0xb9, 0xd4, 0xef, 0x46, 0x98, - 0x87, 0x5e, 0x19, 0x67, 0x2d, 0xd1, 0x90, 0x75, 0x8c, 0x86, 0x2c, 0xbd, 0x0d, 0x5b, 0x36, 0xb2, - 0x4c, 0x82, 0x97, 0x61, 0xb5, 0x40, 0x78, 0xed, 0x2c, 0xc2, 0xb1, 0x5d, 0x39, 0x49, 0xff, 0xd4, - 0x81, 0x3e, 0x42, 0xa2, 0xe4, 0xf8, 0x10, 0xe9, 0xe5, 0x28, 0xf0, 0x53, 0xff, 0xa5, 0x97, 0xb3, - 0x38, 0x56, 0xcd, 0x0f, 0x35, 0x46, 0x81, 0xe3, 0xef, 0xe9, 0x5c, 0x15, 0x6e, 0x6a, 0x88, 0x66, - 0x98, 0xb1, 0x9c, 0x65, 0x58, 0x1a, 0xf1, 0x4f, 0x45, 0x20, 0xb1, 0x81, 0xe8, 0x20, 0x25, 0x00, - 0x89, 0x08, 0x85, 0x5a, 0x30, 0x7a, 0x53, 0x6c, 0xa8, 0x5c, 0xd0, 0xeb, 0xd4, 0xbe, 0xbf, 0x74, - 0x60, 0xbb, 0xf2, 0x91, 0x14, 0xc3, 0x2e, 0xac, 0x72, 0x39, 0x29, 0x31, 0x7c, 0x68, 0x8a, 0xa1, - 0x86, 0x7e, 0x4d, 0x0c, 0x65, 0x2f, 0x59, 0x7c, 0x38, 0x79, 0x08, 0x5d, 0x03, 0xdc, 0x50, 0xa0, - 0x7c, 0x64, 0xf7, 0x92, 0xb7, 0x9b, 0x59, 0x18, 0x75, 0xcb, 0xb7, 0xd0, 0x7b, 0x9c, 0x4c, 0xbf, - 0xc7, 0x73, 0x0c, 0x72, 0x11, 0xd6, 0x33, 0x26, 0x4f, 0xfa, 0xb2, 0x5c, 0xd1, 0x00, 0x3a, 0x84, - 0xbe, 0xa4, 0xab, 0x6f, 0xd1, 0x1f, 0x27, 0x71, 0x1a, 0x3c, 0x7f, 0xdd, 0x5b, 0xf4, 0x9f, 0x01, - 0x31, 0x3f, 0xd0, 0x05, 0xd5, 0x9c, 0x43, 0x2b, 0x05, 0x95, 0x02, 0xf2, 0x82, 0xea, 0x3d, 0xe8, - 0x9a, 0x28, 0xe2, 0xd2, 0x0d, 0x34, 0x02, 0xfd, 0x13, 0x07, 0x86, 0x4f, 0xa2, 0xe2, 0x24, 0xcc, - 0xfc, 0xb3, 0xd7, 0x50, 0x6a, 0xf5, 0x45, 0x43, 0xeb, 0xbc, 0x17, 0x0d, 0xcb, 0xd5, 0x17, 0x0d, - 0x7e, 0x1c, 0xcb, 0xe6, 0x0b, 0xfe, 0x34, 0xdb, 0xae, 0x7d, 0xd1, 0x76, 0xbd, 0x05, 0x23, 0xbd, - 0x98, 0x37, 0xeb, 0xb9, 0x5e, 0xbd, 0x02, 0xeb, 0xa5, 0xbf, 0x93, 0x35, 0x58, 0xde, 0x7b, 0xfc, - 0xdb, 0xa3, 0x25, 0xd2, 0x81, 0x95, 0xa3, 0x83, 0xc3, 0x43, 0x71, 0xbd, 0xc1, 0x6f, 0x3c, 0x5a, - 0x57, 0xaf, 0xc2, 0x0a, 0x46, 0x17, 0xb2, 0x0e, 0xed, 0x47, 0xbb, 0xdf, 0x1c, 0xb8, 0xa3, 0x25, - 0xfc, 0xf9, 0x53, 0xfe, 0xd3, 0x21, 0x3d, 0xe8, 0xdc, 0xbb, 0xff, 0xe8, 0xc0, 0xbd, 0xbf, 0x7b, - 0x38, 0x6a, 0x5d, 0x7d, 0x02, 0x1d, 0x55, 0x1d, 0x22, 0xd2, 0xee, 0xe1, 0x81, 0xfb, 0x48, 0xe0, - 0x1f, 0xb8, 0xee, 0x03, 0x57, 0xd0, 0x7d, 0xb2, 0xeb, 0xde, 0x1f, 0xb5, 0xf0, 0xd7, 0xbd, 0xfb, - 0x3f, 0x79, 0x30, 0x5a, 0x26, 0x5d, 0x58, 0xfb, 0xf6, 0xc0, 0xdd, 0x7b, 0x70, 0x74, 0x30, 0x5a, - 0x41, 0xdc, 0x3b, 0x07, 0x7b, 0x8f, 0xbf, 0x1a, 0xb5, 0x39, 0x47, 0x77, 0x77, 0xff, 0x60, 0xb4, - 0x7a, 0xf3, 0xdf, 0x1d, 0x58, 0x7b, 0x3a, 0x0f, 0xef, 0x25, 0x51, 0x41, 0x0e, 0x00, 0xf4, 0x2b, - 0x09, 0xf2, 0x56, 0xd9, 0xed, 0xaf, 0xbe, 0xb5, 0x98, 0x4c, 0x9a, 0xa6, 0xa4, 0x59, 0x2d, 0x91, - 0xbb, 0xd0, 0x35, 0x2a, 0x6f, 0x32, 0x59, 0x7c, 0x44, 0x98, 0xbc, 0xdd, 0x38, 0x57, 0x52, 0x3a, - 0x00, 0xd0, 0x16, 0xa7, 0x17, 0x54, 0x33, 0x5b, 0xbd, 0xa0, 0xba, 0x81, 0xd2, 0xa5, 0x9b, 0xbf, - 0x9c, 0xc0, 0xf2, 0xd3, 0x79, 0x48, 0x9e, 0x42, 0xd7, 0x78, 0xab, 0x46, 0x6a, 0x37, 0x69, 0x7a, - 0x39, 0x4d, 0x4f, 0xda, 0x26, 0xbf, 0xf8, 0xa7, 0xff, 0xf8, 0xb3, 0xd6, 0x16, 0x1d, 0x5e, 0x7f, - 0xf1, 0xeb, 0xd7, 0xfd, 0x30, 0x54, 0xb6, 0x78, 0xcb, 0xb9, 0x4a, 0x5c, 0x58, 0x93, 0xcf, 0xd1, - 0xc8, 0x8e, 0x41, 0xc3, 0x38, 0xc6, 0x4d, 0x2e, 0xd4, 0xe0, 0x92, 0xee, 0x0e, 0xa7, 0x3b, 0xa2, - 0x5d, 0x49, 0x17, 0xd3, 0x14, 0xd2, 0xdc, 0x83, 0xe5, 0x3d, 0x3f, 0x21, 0x44, 0x5f, 0x94, 0xab, - 0x98, 0x30, 0xd9, 0xb4, 0x60, 0x92, 0x0e, 0xe1, 0x74, 0x7a, 0x74, 0x0d, 0xe9, 0x4c, 0xfd, 0x04, - 0x69, 0x1c, 0xc3, 0xc0, 0x7e, 0x86, 0x44, 0xde, 0x31, 0xef, 0x7b, 0x6a, 0xef, 0x9f, 0x26, 0xef, - 0x2e, 0x9a, 0xae, 0x2c, 0x76, 0x80, 0x4c, 0x02, 0x8e, 0x83, 0xf1, 0x81, 0x04, 0xd0, 0x33, 0x5f, - 0x05, 0x11, 0xfd, 0x36, 0xa5, 0xfe, 0xd4, 0x69, 0x72, 0xb1, 0x79, 0x52, 0xb2, 0x18, 0x73, 0x16, - 0x84, 0x8e, 0x38, 0x0b, 0xc4, 0x90, 0x17, 0x52, 0x28, 0x65, 0xf9, 0x14, 0x48, 0x4b, 0xd9, 0x7e, - 0x49, 0xa4, 0xa5, 0x5c, 0x7d, 0x33, 0x64, 0x49, 0x59, 0xc6, 0x44, 0x94, 0xd0, 0xcf, 0xa1, 0xff, - 0x84, 0xbf, 0x86, 0x93, 0x0f, 0x50, 0x34, 0x65, 0xfb, 0xfd, 0x8a, 0xa6, 0x5c, 0x79, 0xa9, 0x42, - 0x2f, 0x72, 0xca, 0x3b, 0x74, 0x03, 0x29, 0x8b, 0x97, 0x75, 0xa1, 0x40, 0x91, 0x96, 0xf1, 0xbd, - 0x29, 0x5b, 0x6b, 0x36, 0x68, 0xfe, 0x1e, 0xf4, 0xad, 0xf7, 0x2b, 0xa4, 0x14, 0x68, 0xd3, 0xc3, - 0x98, 0xc9, 0x3b, 0x0b, 0x66, 0x9b, 0xd6, 0x1f, 0x4a, 0x14, 0xfe, 0xe2, 0x05, 0x79, 0x3d, 0x05, - 0xd0, 0xef, 0x40, 0xb4, 0x0b, 0xd6, 0xde, 0x9e, 0x68, 0x17, 0xac, 0x3f, 0x1b, 0xa1, 0x9b, 0x9c, - 0x45, 0x9f, 0x74, 0x85, 0x69, 0x0a, 0x5a, 0x87, 0xb0, 0x26, 0x5f, 0x3c, 0x68, 0xc9, 0xd8, 0xcf, - 0x3e, 0xb4, 0x64, 0x2a, 0x4f, 0x23, 0xe8, 0x88, 0x13, 0x04, 0xd2, 0x41, 0x82, 0x11, 0x92, 0xf8, - 0x1d, 0xe8, 0x1a, 0xcf, 0x05, 0x88, 0xb9, 0x9a, 0xca, 0xcb, 0x02, 0xed, 0xe5, 0x0d, 0xef, 0x0b, - 0xe8, 0x16, 0xa7, 0x3c, 0x20, 0x3d, 0xa4, 0xac, 0x7a, 0x25, 0x92, 0xba, 0x7a, 0x0f, 0x60, 0x51, - 0xaf, 0x3c, 0x32, 0xb0, 0xa8, 0x57, 0x1f, 0x10, 0xd8, 0xd4, 0x51, 0xc6, 0x7c, 0xed, 0x4f, 0x00, - 0xf4, 0xd5, 0xb5, 0x96, 0x71, 0xed, 0x0e, 0x5e, 0xcb, 0xb8, 0x7e, 0xd3, 0xad, 0xdc, 0x9f, 0x00, - 0x92, 0x96, 0x17, 0x3c, 0xc7, 0x30, 0xb0, 0x5f, 0x16, 0x68, 0xf7, 0x6f, 0x7c, 0x8a, 0xa0, 0xdd, - 0xbf, 0xf9, 0x41, 0x82, 0xb2, 0x48, 0x22, 0xdc, 0x5f, 0x93, 0x3d, 0x82, 0xf5, 0xf2, 0xce, 0x9b, - 0x8c, 0x4d, 0x22, 0xe6, 0xd5, 0xf8, 0xe4, 0xad, 0x86, 0x19, 0xd5, 0xea, 0xe0, 0x94, 0xbb, 0x64, - 0x1d, 0x29, 0x8b, 0xab, 0x0f, 0x45, 0x94, 0xbf, 0xbe, 0xb1, 0x89, 0x1a, 0x17, 0xe6, 0x15, 0xa2, - 0xe6, 0xb5, 0x79, 0x85, 0x28, 0xa7, 0xe3, 0x41, 0xd7, 0xb8, 0x51, 0xd5, 0x9a, 0xac, 0x5f, 0x07, - 0x6b, 0x4d, 0x36, 0x5c, 0xc1, 0xd2, 0x0b, 0x9c, 0xf4, 0x86, 0xc8, 0x06, 0xe9, 0x8c, 0x25, 0x2a, - 0x48, 0xfd, 0x2e, 0x80, 0x6e, 0x82, 0x6b, 0x65, 0xd6, 0xae, 0x47, 0xb4, 0x71, 0x57, 0x7a, 0xe6, - 0xf4, 0x2d, 0x4e, 0x7a, 0x53, 0xc4, 0x58, 0x7e, 0x31, 0xc1, 0xd5, 0x79, 0xcb, 0xb9, 0x7a, 0xc3, - 0x21, 0xcf, 0x60, 0xa0, 0xf1, 0x8f, 0x5e, 0x25, 0xc1, 0x79, 0x2c, 0x26, 0x4d, 0x53, 0x72, 0x03, - 0xef, 0x70, 0x2e, 0x17, 0x28, 0xb1, 0xb9, 0xe4, 0xaf, 0x92, 0x00, 0xfd, 0xfe, 0x67, 0xd0, 0x35, - 0xde, 0xba, 0x69, 0x39, 0xd5, 0x1f, 0xc0, 0x4d, 0x9a, 0xda, 0xf4, 0x76, 0xb6, 0x94, 0x67, 0xa4, - 0xfc, 0xcc, 0x9f, 0x21, 0xed, 0x04, 0x06, 0x76, 0x37, 0x5a, 0x9b, 0x65, 0x63, 0x6b, 0x5b, 0x9b, - 0xe5, 0x82, 0x26, 0xb6, 0xb5, 0x17, 0xd1, 0x84, 0x35, 0xb3, 0xf3, 0x14, 0x0b, 0x92, 0xb2, 0x29, - 0x6d, 0x16, 0x24, 0xd5, 0xc6, 0xb7, 0x59, 0x90, 0xd4, 0xba, 0xd8, 0xf6, 0x9e, 0x04, 0x1b, 0xa5, - 0x19, 0x92, 0xc1, 0xb0, 0xd2, 0x31, 0x26, 0x95, 0x55, 0x57, 0x9b, 0xcc, 0x93, 0xf7, 0x16, 0xce, - 0x4b, 0x7e, 0xef, 0x72, 0x7e, 0x63, 0xba, 0xa9, 0xf9, 0xf9, 0x71, 0x2c, 0xd4, 0x24, 0x72, 0x17, - 0xe8, 0xfe, 0xaf, 0xb6, 0x83, 0x5a, 0x0b, 0x79, 0x32, 0x69, 0x9a, 0x92, 0x4c, 0x2c, 0x6b, 0x13, - 0x4c, 0x54, 0x05, 0x32, 0x85, 0xae, 0xd1, 0x95, 0xd4, 0x72, 0xab, 0x37, 0x3c, 0xb5, 0xdc, 0x9a, - 0xda, 0x98, 0x96, 0xdc, 0x72, 0x56, 0xc4, 0xe9, 0x31, 0x6f, 0x7b, 0x22, 0x8f, 0x6f, 0xa1, 0xa3, - 0xfa, 0x99, 0xa4, 0xf4, 0x88, 0x4a, 0xd3, 0x73, 0x32, 0xae, 0x4f, 0x54, 0xdc, 0x90, 0x07, 0xd4, - 0x5c, 0xce, 0x22, 0x5d, 0x06, 0xc3, 0x4a, 0x4f, 0x54, 0xeb, 0xa3, 0xb9, 0x59, 0x3a, 0xb1, 0x9f, - 0xec, 0x89, 0xdb, 0x6a, 0xfa, 0x36, 0x67, 0xb0, 0x4d, 0xb8, 0x0e, 0x72, 0xf5, 0xa1, 0xd0, 0xc1, - 0x0d, 0x87, 0xcc, 0x2a, 0x3d, 0x52, 0xd9, 0x6c, 0x33, 0x02, 0x6d, 0x63, 0x0b, 0x75, 0xd2, 0x74, - 0xc9, 0x44, 0x7f, 0xc0, 0x79, 0xbd, 0x4d, 0xde, 0xb2, 0x78, 0xa1, 0xd7, 0xa8, 0x3b, 0xb6, 0x1b, - 0x0e, 0x99, 0xc2, 0xc0, 0x26, 0xf9, 0x46, 0xac, 0x2a, 0xee, 0x49, 0x48, 0x8d, 0x15, 0xf2, 0xf8, - 0x03, 0xa3, 0xa1, 0x6c, 0xb5, 0x86, 0xc9, 0xe5, 0x66, 0x5e, 0x95, 0xd6, 0xf1, 0x64, 0xcb, 0xe4, - 0xa9, 0x26, 0x29, 0xe5, 0x4c, 0x2f, 0x92, 0x49, 0x9d, 0xa9, 0x2f, 0x71, 0x78, 0x84, 0xeb, 0x99, - 0x4d, 0x0b, 0x5d, 0x4a, 0x36, 0xf4, 0x3d, 0x74, 0x29, 0xd9, 0xd4, 0xe7, 0x50, 0xca, 0x13, 0xa5, - 0x24, 0x6f, 0x6a, 0x9c, 0x08, 0x0c, 0x51, 0x1b, 0x57, 0x9a, 0x1b, 0x17, 0x17, 0x1c, 0xff, 0x2b, - 0x55, 0x54, 0x63, 0x73, 0x40, 0xb9, 0x11, 0xd9, 0x50, 0xac, 0xa2, 0xe4, 0x58, 0xf4, 0x08, 0xc8, - 0xd7, 0xd0, 0xe6, 0x27, 0x6f, 0xb2, 0xa5, 0x4f, 0x29, 0xfa, 0x80, 0x3f, 0xd9, 0xae, 0x40, 0xed, - 0x52, 0x81, 0xf2, 0xdc, 0x35, 0x4f, 0x64, 0x41, 0x3f, 0x85, 0x81, 0x28, 0x57, 0xd5, 0xf9, 0x54, - 0x3b, 0x4d, 0xe5, 0xf8, 0xac, 0x9d, 0xa6, 0x7a, 0x94, 0xb5, 0xc3, 0xa5, 0xa8, 0x58, 0xcf, 0x24, - 0xce, 0x2d, 0xe7, 0xea, 0x74, 0x95, 0xff, 0xb3, 0xe7, 0xd3, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, - 0xda, 0x35, 0x6d, 0xbb, 0x04, 0x34, 0x00, 0x00, + 0x56, 0x9d, 0xf5, 0xd1, 0x55, 0xfd, 0xea, 0xb3, 0xa3, 0x3f, 0x5c, 0x53, 0xb6, 0x67, 0xbc, 0x81, + 0x3d, 0xf2, 0xd8, 0x33, 0xb6, 0xe9, 0x61, 0x99, 0x1d, 0xef, 0x7a, 0x34, 0xdd, 0xed, 0x5a, 0xdb, + 0x33, 0x35, 0xdd, 0x56, 0xb6, 0x3d, 0x36, 0x2b, 0xd8, 0x54, 0x56, 0x66, 0xb8, 0x3b, 0x71, 0x76, + 0x66, 0x4d, 0x66, 0x96, 0xdb, 0x0d, 0x17, 0xb4, 0xe2, 0x04, 0x42, 0x1c, 0x10, 0x67, 0x38, 0x21, + 0x24, 0x10, 0x57, 0x4e, 0x48, 0x9c, 0xb9, 0x72, 0x00, 0x01, 0x17, 0x24, 0x7e, 0x01, 0xe2, 0x8a, + 0x84, 0xe2, 0x2b, 0x23, 0x22, 0x33, 0xcb, 0x6b, 0x8f, 0x80, 0x4b, 0xab, 0xe2, 0xc5, 0xcb, 0xf7, + 0x22, 0xde, 0x57, 0xbc, 0x78, 0xf1, 0x1a, 0xba, 0xaf, 0x17, 0x7e, 0x32, 0xf7, 0x6e, 0xcd, 0x93, + 0x38, 0x8b, 0xd1, 0x2a, 0x1f, 0x8d, 0xd7, 0xdd, 0x28, 0x8a, 0x33, 0x37, 0x0b, 0xe2, 0x28, 0xe5, + 0x53, 0x78, 0x0b, 0x36, 0x76, 0x7d, 0x7f, 0x7f, 0x91, 0x24, 0x24, 0xf2, 0xce, 0x6d, 0x92, 0xce, + 0xe3, 0x28, 0x25, 0xf8, 0xe7, 0xd0, 0xdf, 0xf5, 0xfd, 0xc7, 0x6e, 0x90, 0xd8, 0xe4, 0xbb, 0x05, + 0x49, 0x33, 0x74, 0x15, 0x7a, 0x33, 0x37, 0x25, 0x8e, 0x27, 0x50, 0x47, 0xd6, 0x15, 0xeb, 0xfa, + 0x9a, 0x6d, 0x02, 0xd1, 0x87, 0xd0, 0xff, 0x6e, 0x11, 0x67, 0x1a, 0x5a, 0x8d, 0xa1, 0x15, 0xa0, + 0x78, 0x1d, 0x06, 0x39, 0x7d, 0xc1, 0xf2, 0xef, 0x2c, 0x68, 0xee, 0x86, 0x24, 0xc9, 0xd0, 0x4d, + 0x68, 0x64, 0xe7, 0x73, 0xc2, 0x38, 0xf4, 0x77, 0x2e, 0xdc, 0x12, 0x7b, 0x61, 0x93, 0xfc, 0xef, + 0x93, 0xf3, 0x39, 0xb1, 0x19, 0x12, 0x1a, 0x41, 0xeb, 0x94, 0xa4, 0xa9, 0x7b, 0x4c, 0x04, 0x2b, + 0x39, 0x44, 0x3f, 0xa1, 0x2b, 0x0e, 0xdd, 0xc8, 0x23, 0x8e, 0x4b, 0x3f, 0x1a, 0xd5, 0xaf, 0x58, + 0xd7, 0x3b, 0x3b, 0x9b, 0x92, 0xde, 0x1e, 0x9f, 0x64, 0x04, 0x1f, 0xae, 0xd8, 0x26, 0x32, 0xbe, + 0x0a, 0x6b, 0x39, 0x2b, 0x74, 0x01, 0x36, 0xa6, 0x87, 0xcf, 0x9c, 0x27, 0xf6, 0xee, 0xfd, 0x47, + 0x07, 0x0f, 0x9c, 0xbd, 0xdd, 0xe9, 0xee, 0xc1, 0xfe, 0x64, 0xb8, 0xb2, 0xb7, 0x06, 0xad, 0xb9, + 0x7b, 0x1e, 0xc6, 0xae, 0x8f, 0xff, 0xb6, 0x06, 0x2d, 0x41, 0x92, 0x0a, 0x2b, 0x8b, 0x33, 0x37, + 0x74, 0x04, 0x4d, 0xb6, 0x95, 0x86, 0x6d, 0x02, 0xd1, 0x75, 0x18, 0x78, 0x27, 0x6e, 0x14, 0x11, + 0x85, 0x57, 0x63, 0x78, 0x45, 0x30, 0xfa, 0x11, 0x5c, 0x98, 0x93, 0xc8, 0x0f, 0xa2, 0x63, 0xa7, + 0xf8, 0x45, 0x9d, 0x7d, 0xb1, 0x6c, 0x1a, 0xdd, 0x85, 0x51, 0x10, 0xb9, 0x5e, 0x16, 0xbc, 0x22, + 0xa5, 0x4f, 0x1b, 0xec, 0xd3, 0xa5, 0xf3, 0x54, 0x99, 0x67, 0x6e, 0x18, 0x92, 0x2c, 0xff, 0xa2, + 0xc9, 0xbe, 0x28, 0x40, 0xd1, 0x17, 0x30, 0x5e, 0x44, 0x5e, 0x1c, 0xbd, 0x08, 0x92, 0x53, 0xe2, + 0x3b, 0x85, 0x6f, 0x56, 0xd9, 0x37, 0x6f, 0xc0, 0xc0, 0xff, 0x6c, 0x41, 0x57, 0x57, 0xc6, 0x5b, + 0x8a, 0xef, 0x13, 0x68, 0xa4, 0x81, 0xcf, 0x65, 0xd6, 0xdf, 0x79, 0xaf, 0x4a, 0xad, 0xb7, 0x8e, + 0x02, 0x9f, 0xd8, 0x0c, 0x0d, 0x6d, 0x42, 0x73, 0x16, 0x2f, 0x22, 0x9f, 0x49, 0xac, 0x67, 0xf3, + 0x01, 0xc2, 0xd0, 0xa5, 0xb3, 0x05, 0x99, 0x18, 0x30, 0x34, 0x86, 0x76, 0x6e, 0xce, 0x4d, 0x66, + 0x63, 0xf9, 0x18, 0x5f, 0x86, 0x06, 0xe5, 0x81, 0x00, 0x56, 0xed, 0xc9, 0x37, 0x87, 0x4f, 0x26, + 0xc3, 0x15, 0xb4, 0x06, 0xcd, 0xe9, 0xe1, 0xfe, 0xee, 0x74, 0x68, 0xe1, 0x5f, 0x07, 0xd8, 0x73, + 0x23, 0xe9, 0x43, 0xd7, 0x61, 0x10, 0xc5, 0x3e, 0x71, 0x02, 0x9f, 0x44, 0x59, 0xf0, 0x22, 0x20, + 0x89, 0xf0, 0xa2, 0x22, 0x18, 0xf7, 0xa0, 0xc3, 0xbe, 0x13, 0xbe, 0xf1, 0x19, 0x34, 0xf7, 0x4f, + 0xdc, 0x20, 0xa2, 0x9b, 0xf0, 0xe8, 0x0f, 0xf1, 0x1d, 0x1f, 0x50, 0x1f, 0x88, 0x48, 0x76, 0x16, + 0x27, 0x2f, 0xa5, 0x0f, 0x88, 0x21, 0x9e, 0x43, 0x7b, 0x9f, 0x6b, 0x35, 0x45, 0xdb, 0xb0, 0xca, + 0x15, 0xcd, 0x3e, 0xee, 0xd9, 0x62, 0x44, 0xb7, 0x27, 0x4d, 0x80, 0x7d, 0xde, 0xb3, 0xf3, 0x31, + 0xa5, 0x2c, 0x2c, 0x4b, 0x88, 0x4d, 0x0e, 0x29, 0x35, 0x2f, 0x8c, 0x53, 0xe2, 0x33, 0x91, 0xf5, + 0x6c, 0x31, 0xc2, 0x0e, 0x6c, 0x51, 0x8e, 0xc7, 0xe4, 0xb1, 0x9b, 0xa6, 0x67, 0x71, 0xe2, 0xcb, + 0xcd, 0x63, 0xe8, 0x46, 0xe4, 0xcc, 0x99, 0x0b, 0xb0, 0xd8, 0x81, 0x01, 0xa3, 0x38, 0x71, 0xe8, + 0x2b, 0x1c, 0xbe, 0x1b, 0x03, 0x86, 0x47, 0xb0, 0x5d, 0x64, 0xa0, 0x22, 0xc8, 0xc6, 0x3e, 0x5d, + 0x85, 0xd8, 0xf2, 0x3b, 0x8b, 0xdd, 0xd0, 0x74, 0xcd, 0xd4, 0x34, 0x15, 0xfd, 0x8b, 0x38, 0x11, + 0x1e, 0xd7, 0xb6, 0xf9, 0x00, 0x5d, 0x81, 0x8e, 0x4f, 0xd2, 0x2c, 0x88, 0x58, 0x54, 0x65, 0xb2, + 0x58, 0xb3, 0x75, 0x10, 0x13, 0xfb, 0x69, 0xbc, 0x88, 0x32, 0xe1, 0x3d, 0x62, 0x84, 0x86, 0x50, + 0x7f, 0x41, 0xa4, 0x7b, 0xd0, 0x9f, 0xf8, 0x4b, 0xd8, 0x34, 0x97, 0xcf, 0xf7, 0x45, 0xd7, 0x9f, + 0x25, 0x6e, 0x94, 0x52, 0x9d, 0xc4, 0x91, 0x13, 0xf8, 0xe9, 0xc8, 0xba, 0x52, 0xa7, 0xeb, 0x2f, + 0x80, 0xf1, 0xc7, 0xd0, 0xdf, 0x8f, 0xa3, 0x88, 0x78, 0x99, 0xdc, 0xfb, 0x18, 0xda, 0x6c, 0x93, + 0x8b, 0x24, 0x10, 0x9b, 0xce, 0xc7, 0x34, 0x08, 0xe7, 0xd8, 0x42, 0x84, 0xb7, 0x61, 0x7d, 0x3f, + 0x21, 0x6e, 0x46, 0x0e, 0x62, 0x9f, 0x68, 0x34, 0x0a, 0x5a, 0xcb, 0xc7, 0xf8, 0x4f, 0x2d, 0x40, + 0xfa, 0x17, 0x62, 0xc9, 0xbf, 0x02, 0xbd, 0x94, 0x10, 0xdf, 0x39, 0x8d, 0xc8, 0x69, 0x1c, 0x05, + 0x9e, 0x58, 0x70, 0x97, 0x02, 0xbf, 0x11, 0x30, 0xf4, 0x11, 0x0c, 0x83, 0x28, 0xc8, 0x02, 0x37, + 0x0c, 0x7e, 0x87, 0xf8, 0x4e, 0x18, 0xf9, 0xe9, 0xa8, 0xc6, 0x37, 0xa6, 0xc1, 0xa7, 0x91, 0x9f, + 0xa2, 0xdb, 0xb0, 0xa1, 0xa3, 0x7a, 0x74, 0xd9, 0xaf, 0x33, 0xa1, 0x0a, 0xa4, 0x4d, 0xed, 0xf3, + 0x19, 0xfc, 0x4f, 0x16, 0xb4, 0xe5, 0xa9, 0x66, 0xa8, 0xd5, 0x2a, 0xa8, 0xf5, 0x1e, 0x74, 0xd2, + 0x33, 0x77, 0xee, 0x78, 0x61, 0x40, 0xa2, 0x4c, 0x04, 0x93, 0x8b, 0x32, 0x98, 0x48, 0x12, 0xb7, + 0x8e, 0xce, 0xdc, 0xf9, 0x3e, 0x43, 0xb1, 0x75, 0x7c, 0x1e, 0xaa, 0x5e, 0x92, 0xc8, 0x71, 0x7d, + 0x3f, 0x21, 0x69, 0xca, 0x96, 0xb4, 0x66, 0x9b, 0x40, 0x1a, 0x49, 0x7d, 0xe2, 0x05, 0xa7, 0x6e, + 0xe8, 0xcc, 0x43, 0xd7, 0x23, 0xa9, 0x70, 0x9a, 0x02, 0x14, 0x63, 0x00, 0xc5, 0x08, 0xb5, 0xa0, + 0x3e, 0x3d, 0xb8, 0x3f, 0x5c, 0x41, 0x1d, 0x68, 0xed, 0x1f, 0x1e, 0x1c, 0x4c, 0x9e, 0x3f, 0x19, + 0xd6, 0xa8, 0x8e, 0xef, 0x93, 0x79, 0x9c, 0x06, 0xba, 0x8e, 0x97, 0x6d, 0x0f, 0xdf, 0x84, 0x41, + 0x8e, 0x2d, 0x74, 0x33, 0x82, 0x96, 0x5c, 0x2c, 0xc7, 0x96, 0x43, 0x6a, 0x80, 0xf7, 0x83, 0xd4, + 0x8b, 0x5f, 0x91, 0x84, 0x6a, 0x33, 0x7d, 0xf7, 0xb8, 0xf5, 0x43, 0xd8, 0x2a, 0x50, 0x10, 0x4c, + 0x2f, 0xc1, 0x5a, 0xb4, 0x38, 0x75, 0x28, 0x7e, 0x2a, 0xe2, 0x8f, 0x02, 0xe0, 0x3f, 0xb0, 0x00, + 0x4d, 0x5e, 0x13, 0x6f, 0x91, 0x11, 0xba, 0x7f, 0x6d, 0x63, 0x71, 0xe2, 0x93, 0xc4, 0x09, 0x72, + 0xc3, 0x93, 0x63, 0x16, 0x99, 0xdc, 0x80, 0x4d, 0x89, 0x98, 0x27, 0x86, 0x34, 0x88, 0xcc, 0x09, + 0x49, 0x9c, 0xf9, 0x62, 0xe6, 0xbc, 0x24, 0xe7, 0x42, 0x23, 0x06, 0x8c, 0x52, 0xfe, 0x6e, 0xe1, + 0x46, 0x59, 0x90, 0x9d, 0x8b, 0x90, 0x9f, 0x8f, 0xa9, 0x0f, 0x3c, 0x20, 0x99, 0x38, 0x46, 0xde, + 0x46, 0xc6, 0x7f, 0x69, 0x01, 0xd2, 0xbf, 0x10, 0x5b, 0xbe, 0x0f, 0x6d, 0x71, 0x82, 0x70, 0x7f, + 0xed, 0xec, 0x5c, 0x97, 0x66, 0x55, 0xc6, 0x96, 0xc7, 0x56, 0x3a, 0x89, 0xb2, 0xe4, 0xdc, 0xce, + 0xbf, 0x1c, 0x4f, 0xa1, 0x67, 0x4c, 0xd1, 0xb8, 0x41, 0x77, 0xc5, 0x17, 0x41, 0x7f, 0xa2, 0x6b, + 0xd0, 0x7c, 0xe5, 0x86, 0x0b, 0x1e, 0xbd, 0x3b, 0x3b, 0x83, 0xc2, 0x49, 0x68, 0xf3, 0xd9, 0xbb, + 0xb5, 0x1f, 0x59, 0x78, 0x08, 0xfd, 0x07, 0x24, 0x7b, 0x14, 0xbd, 0x88, 0xc5, 0xc6, 0xf0, 0xbf, + 0xd4, 0x61, 0x90, 0x83, 0x94, 0x85, 0xbc, 0x22, 0x49, 0x4a, 0x03, 0x9a, 0xb0, 0x10, 0x31, 0x64, + 0x41, 0x9c, 0xaa, 0x5c, 0xca, 0x56, 0x04, 0x68, 0x1d, 0x86, 0x10, 0x34, 0x16, 0x49, 0x40, 0x3d, + 0x81, 0xba, 0x32, 0xfb, 0x2d, 0xd5, 0x4f, 0x75, 0x20, 0x6d, 0x5f, 0x01, 0xf2, 0x59, 0x37, 0x48, + 0x52, 0x16, 0x25, 0xe5, 0x2c, 0x05, 0xa0, 0x9b, 0xb0, 0xca, 0xb4, 0x9e, 0xb2, 0x58, 0xd9, 0xd9, + 0xd9, 0x90, 0xfb, 0x3b, 0x64, 0xd0, 0x7d, 0x1a, 0x4d, 0x6d, 0x81, 0x82, 0x76, 0xa0, 0x1e, 0x46, + 0xfe, 0xa8, 0xc5, 0xe4, 0x7d, 0x45, 0x93, 0xb7, 0xbe, 0xc1, 0x5b, 0xd3, 0xc8, 0xe7, 0x72, 0xa6, + 0xc8, 0x34, 0xb2, 0xbb, 0x61, 0xe0, 0xa6, 0xa3, 0x35, 0x7e, 0xa8, 0xb2, 0x81, 0x7e, 0xa8, 0x82, + 0x71, 0xa8, 0xa2, 0x3b, 0xb0, 0x21, 0xd3, 0x2d, 0x16, 0x0a, 0x4e, 0xdc, 0xf4, 0x84, 0xa4, 0xa3, + 0x0e, 0xdb, 0x6f, 0xd5, 0x14, 0xfa, 0x04, 0x5a, 0x32, 0x64, 0x75, 0xcd, 0x3d, 0x88, 0x78, 0xc5, + 0x56, 0x27, 0x71, 0xc6, 0x0f, 0xa0, 0x2d, 0x57, 0xf8, 0x0e, 0xea, 0x9e, 0x46, 0x3e, 0x23, 0xa3, + 0xa9, 0x7b, 0x93, 0x19, 0xa6, 0x0c, 0xb8, 0x52, 0xe5, 0x3f, 0x86, 0x0d, 0x03, 0x2a, 0xb4, 0x7e, + 0xb5, 0x3a, 0x66, 0x9b, 0x40, 0xfc, 0x05, 0x23, 0x49, 0x9d, 0x5b, 0xb3, 0xa2, 0x77, 0x88, 0x10, + 0x36, 0x63, 0xae, 0xbe, 0xcf, 0x0f, 0x8c, 0x41, 0x42, 0xe6, 0x0b, 0x7e, 0x39, 0x39, 0xf2, 0xe2, + 0x84, 0x67, 0x29, 0xeb, 0x36, 0x28, 0x30, 0x3d, 0x4a, 0x67, 0xf4, 0x68, 0xe4, 0x2e, 0xdf, 0xb6, + 0xc5, 0x08, 0x5f, 0x80, 0xad, 0x69, 0x90, 0x66, 0x22, 0x58, 0x07, 0x79, 0xe0, 0xc2, 0x5f, 0xc1, + 0x76, 0x71, 0x42, 0xf0, 0xbb, 0x03, 0xe0, 0xe5, 0x50, 0xe1, 0x9e, 0xc3, 0x62, 0xd4, 0xb7, 0x35, + 0x1c, 0xfc, 0x0f, 0x16, 0xac, 0x53, 0x62, 0xdc, 0xea, 0xe4, 0xc6, 0xb5, 0x30, 0x64, 0x99, 0x61, + 0xe8, 0x87, 0xd0, 0x8c, 0xcf, 0x22, 0x92, 0x88, 0x23, 0xe5, 0x83, 0x5c, 0x4d, 0x45, 0x1a, 0xb7, + 0x0e, 0x29, 0x9a, 0xcd, 0xb1, 0xa9, 0x31, 0x86, 0xc1, 0x69, 0x90, 0xc9, 0x34, 0x95, 0x0d, 0xa8, + 0x7c, 0x83, 0xc8, 0x0b, 0x17, 0x3e, 0xbd, 0x9e, 0x04, 0x6e, 0x2a, 0x4e, 0x90, 0xb6, 0x5d, 0x04, + 0xe3, 0xab, 0xd0, 0x64, 0xf4, 0x50, 0x1b, 0x1a, 0x7b, 0x87, 0x4f, 0x1e, 0x0e, 0x57, 0xe8, 0x39, + 0x72, 0xf8, 0xec, 0x60, 0x68, 0x51, 0xd0, 0xe3, 0xc9, 0xc4, 0x1e, 0xd6, 0xf0, 0x9f, 0x59, 0x80, + 0xf4, 0x85, 0x08, 0xa9, 0x7c, 0x91, 0xbb, 0x1a, 0x97, 0xc8, 0x87, 0x55, 0x8b, 0x16, 0x3e, 0xc4, + 0x87, 0xdc, 0x8d, 0xc4, 0x57, 0xe3, 0x47, 0xd0, 0xd1, 0xc0, 0x15, 0xb6, 0x7b, 0xd5, 0xb4, 0xdd, + 0xbe, 0xe9, 0xca, 0xba, 0xe9, 0x22, 0x18, 0x52, 0xa6, 0xf4, 0x8a, 0x98, 0xab, 0xf3, 0x23, 0xae, + 0x01, 0x01, 0x13, 0x6b, 0xde, 0x84, 0x26, 0x0f, 0x1c, 0xdc, 0x5c, 0xf9, 0x20, 0xff, 0x9c, 0x28, + 0x39, 0xe3, 0xcf, 0xc4, 0xe7, 0x44, 0xdf, 0x32, 0x86, 0x26, 0x8f, 0x4a, 0x7c, 0xc7, 0x5d, 0xb9, + 0x22, 0x8a, 0x65, 0xf3, 0x29, 0xfc, 0x6f, 0x16, 0xb4, 0x84, 0x77, 0x51, 0x1b, 0x4c, 0x33, 0x37, + 0x5b, 0xc8, 0xc3, 0x53, 0x8c, 0xd0, 0xc7, 0xd0, 0x16, 0xf7, 0xa7, 0x54, 0x6c, 0x4e, 0x99, 0x93, + 0x80, 0xdb, 0x39, 0x06, 0xba, 0x06, 0xab, 0x2c, 0x75, 0xe7, 0x51, 0xb2, 0xb3, 0xd3, 0xd3, 0x70, + 0x83, 0xc8, 0x16, 0x93, 0x34, 0xbb, 0x9c, 0x85, 0xb1, 0xf7, 0xf2, 0x84, 0x04, 0xc7, 0x27, 0x99, + 0x08, 0x9c, 0x3a, 0x28, 0x0f, 0xb6, 0x4d, 0x2d, 0xd8, 0x6a, 0xe1, 0x7b, 0xd5, 0x0c, 0xdf, 0x79, + 0xa4, 0x6b, 0x69, 0x91, 0x0e, 0x7f, 0x05, 0x7d, 0xe6, 0x8f, 0x2a, 0x0f, 0x2e, 0x86, 0x79, 0xab, + 0x22, 0xcc, 0xe7, 0xb4, 0x6a, 0x3a, 0xad, 0xbf, 0xb0, 0x00, 0x1d, 0xce, 0x49, 0xf4, 0x7f, 0x92, + 0x82, 0xab, 0x54, 0xba, 0x6e, 0xa4, 0xd2, 0x57, 0xa0, 0x33, 0x5f, 0xa4, 0x27, 0x8e, 0x98, 0xe4, + 0x07, 0xba, 0x0e, 0x92, 0xc9, 0x76, 0x53, 0x25, 0xdb, 0xf7, 0x60, 0xc3, 0x58, 0xa7, 0x30, 0x87, + 0x0f, 0xa1, 0x6f, 0x26, 0xd5, 0x62, 0x9d, 0x05, 0x28, 0xfe, 0xfb, 0x1a, 0x34, 0x99, 0xd1, 0x32, + 0xfb, 0x4b, 0x02, 0x71, 0x49, 0xb5, 0x6c, 0x3e, 0x30, 0x12, 0x8c, 0x9a, 0x99, 0x60, 0xe8, 0x31, + 0xa3, 0x6e, 0xc6, 0x8c, 0x3e, 0xd4, 0x02, 0x5f, 0x5c, 0x22, 0x6a, 0x81, 0x8f, 0xbe, 0x2c, 0x8b, + 0xad, 0xc9, 0x6c, 0x6b, 0x5b, 0xda, 0x8b, 0xa9, 0xb8, 0x4a, 0x71, 0x86, 0xb1, 0xe7, 0x86, 0x94, + 0x19, 0x37, 0x86, 0x7c, 0x8c, 0xde, 0x07, 0xf0, 0x58, 0xea, 0xee, 0x3b, 0x6e, 0xc6, 0x4c, 0xa2, + 0x61, 0x6b, 0x10, 0x74, 0x4d, 0x5c, 0xb0, 0xdb, 0x2c, 0x80, 0xad, 0x1b, 0xbe, 0xaa, 0x5d, 0xac, + 0x31, 0x74, 0x83, 0xd4, 0x89, 0xcf, 0x22, 0x87, 0x45, 0x01, 0x76, 0x8a, 0xb6, 0x6d, 0x03, 0x46, + 0xcd, 0xf4, 0x24, 0x0e, 0x7d, 0x76, 0x92, 0x36, 0x6c, 0xf6, 0x1b, 0xff, 0xb9, 0x05, 0x5d, 0x46, + 0xcb, 0x26, 0xa7, 0xf1, 0x2b, 0x37, 0x34, 0x64, 0x66, 0x2d, 0x97, 0x59, 0x21, 0xdd, 0xd3, 0x93, + 0xc4, 0x7a, 0x21, 0x49, 0xd4, 0x77, 0xdf, 0x28, 0xec, 0xbe, 0xb8, 0xec, 0x66, 0x79, 0xd9, 0xf8, + 0x04, 0x56, 0x79, 0x64, 0x42, 0x9f, 0x00, 0xcc, 0x16, 0xe7, 0x8e, 0x11, 0x1d, 0x7b, 0x86, 0x44, + 0x6c, 0x0d, 0x01, 0xdd, 0x86, 0x4e, 0x4a, 0xc2, 0x50, 0xe2, 0xd7, 0xaa, 0xf0, 0x75, 0x0c, 0xfc, + 0xa9, 0x8c, 0x9c, 0x2c, 0x9d, 0xa1, 0xf2, 0xa2, 0xa1, 0x47, 0x64, 0xca, 0xec, 0x37, 0xb5, 0xe1, + 0xf8, 0x2c, 0x12, 0x57, 0x74, 0xfa, 0x13, 0xff, 0xc2, 0x12, 0x5f, 0x3d, 0x9d, 0xfb, 0x6e, 0x46, + 0x68, 0x66, 0xc0, 0xf7, 0x62, 0x31, 0x23, 0x31, 0xf9, 0x3d, 0x5c, 0xb1, 0xf9, 0x2c, 0xfa, 0x09, + 0xf4, 0xb8, 0x84, 0x12, 0x2e, 0x78, 0x11, 0xaf, 0x36, 0xcd, 0xe5, 0xf1, 0xb9, 0x87, 0x2b, 0xb6, + 0x89, 0xbc, 0xd7, 0x87, 0x2e, 0x07, 0x2c, 0x18, 0x53, 0xfc, 0xaf, 0x35, 0x68, 0xd0, 0x60, 0xb9, + 0xfc, 0x5e, 0xf1, 0x56, 0x59, 0xe3, 0x97, 0xd0, 0x0d, 0x23, 0x5f, 0x0e, 0x65, 0x5c, 0xbc, 0xa4, + 0x87, 0x63, 0x9a, 0xe1, 0x3c, 0x5e, 0xcc, 0xbe, 0x26, 0xe7, 0xe2, 0xd8, 0x31, 0xbe, 0xa0, 0xfc, + 0x83, 0x88, 0x97, 0x78, 0xf8, 0xd9, 0x28, 0x87, 0xea, 0x88, 0x68, 0x6a, 0x47, 0x04, 0x8d, 0x1a, + 0xaf, 0x17, 0xbe, 0x63, 0x86, 0x4a, 0x1d, 0x84, 0x3e, 0x86, 0xf5, 0x94, 0x78, 0x71, 0xe4, 0xa7, + 0xfc, 0xc6, 0xe9, 0x65, 0xc4, 0x67, 0x7e, 0xd2, 0xb3, 0xcb, 0x13, 0xd5, 0x69, 0xe4, 0xf8, 0x1e, + 0x0c, 0x0a, 0xcb, 0xae, 0x38, 0x16, 0x37, 0xf5, 0x63, 0x71, 0x4d, 0x3f, 0x06, 0x7f, 0xaf, 0x06, + 0xeb, 0x8f, 0xe9, 0xe5, 0x50, 0x28, 0x85, 0x87, 0xd3, 0xff, 0xcd, 0x98, 0xa3, 0xfb, 0x4f, 0xa3, + 0xe0, 0x3f, 0x32, 0x02, 0x34, 0xdf, 0x1c, 0x01, 0x6e, 0xc0, 0x30, 0x21, 0xec, 0x0a, 0xeb, 0xe4, + 0xa4, 0xb8, 0x38, 0x4b, 0x70, 0x9a, 0x3c, 0x07, 0xa7, 0xa7, 0xc4, 0x0f, 0xdc, 0x8c, 0x42, 0x1d, + 0x8f, 0x5e, 0x51, 0x42, 0x26, 0xd5, 0xb6, 0x5d, 0x35, 0x45, 0x45, 0x80, 0x74, 0x11, 0x88, 0x48, + 0xfd, 0x39, 0x0c, 0x83, 0x28, 0x23, 0x49, 0xe4, 0x86, 0xce, 0xa9, 0x9b, 0x79, 0x27, 0x64, 0x89, + 0x5f, 0x96, 0xd0, 0xd0, 0x8f, 0xa1, 0xcf, 0xb2, 0xf3, 0x74, 0xe1, 0x79, 0x24, 0xa5, 0xc9, 0x14, + 0x77, 0xd0, 0x3c, 0x2b, 0xa7, 0x97, 0xd0, 0x23, 0x3e, 0x69, 0x17, 0x50, 0xd1, 0x67, 0x34, 0x53, + 0x3d, 0x75, 0x83, 0x88, 0x26, 0xf9, 0xdc, 0xdd, 0xea, 0x15, 0xee, 0x66, 0x17, 0xb1, 0xd0, 0xe7, + 0xd0, 0x63, 0xa4, 0x5e, 0xb8, 0x41, 0xb8, 0x48, 0x58, 0x06, 0x57, 0x62, 0xfa, 0x53, 0x3e, 0x67, + 0x9b, 0x98, 0xf8, 0x3f, 0x2d, 0x18, 0x28, 0x11, 0x4c, 0x5e, 0x91, 0x88, 0x46, 0xe7, 0x26, 0xdb, + 0xcf, 0x52, 0x67, 0x67, 0xb3, 0xe8, 0x73, 0xe8, 0xea, 0x1b, 0x10, 0xbe, 0x5e, 0xb5, 0xd3, 0x87, + 0x2b, 0xb6, 0x81, 0x8a, 0x3e, 0x7f, 0xbb, 0x9d, 0x3e, 0x5c, 0xa9, 0xda, 0x6b, 0x57, 0xdf, 0x01, + 0x33, 0xac, 0xea, 0xad, 0xe6, 0x5c, 0x05, 0xea, 0x5e, 0x0b, 0x9a, 0x84, 0x6e, 0x10, 0xc7, 0xd0, + 0xd1, 0x6e, 0x47, 0x4b, 0x13, 0x2f, 0x2d, 0xec, 0xd4, 0xcc, 0xb0, 0xa3, 0xe5, 0x41, 0x8d, 0x52, + 0x1e, 0xc4, 0xcb, 0xa8, 0x4d, 0xad, 0x8c, 0x8a, 0x3f, 0x85, 0x2d, 0x16, 0xf5, 0x88, 0x7a, 0x0e, + 0xf9, 0xe5, 0x97, 0xff, 0x11, 0x6c, 0x17, 0x3f, 0x12, 0xb5, 0xb4, 0x29, 0x20, 0x3e, 0x63, 0xb8, + 0xee, 0x9b, 0x6a, 0x1a, 0x6f, 0x70, 0x60, 0xfc, 0x57, 0x16, 0x6c, 0x18, 0xe4, 0x84, 0x1b, 0xbc, + 0x0f, 0x43, 0x89, 0xe3, 0xc4, 0x91, 0xc3, 0x4e, 0x59, 0x4b, 0x9d, 0xb2, 0xe8, 0x16, 0x20, 0xa5, + 0x9c, 0x02, 0xf5, 0x8a, 0x19, 0xee, 0xcb, 0x94, 0x8d, 0xaf, 0xb0, 0x79, 0xb6, 0x55, 0x82, 0xeb, + 0x41, 0xa5, 0x61, 0x04, 0x15, 0x25, 0x95, 0xdd, 0x30, 0x34, 0x2e, 0x3b, 0x78, 0x01, 0x17, 0x4a, + 0x33, 0x62, 0x2b, 0x1f, 0xc3, 0xba, 0x64, 0x21, 0x45, 0x22, 0xb3, 0xfa, 0xf2, 0x04, 0xc5, 0x16, + 0xfb, 0xd5, 0xb0, 0x79, 0xf9, 0xb0, 0x3c, 0x81, 0x3f, 0x81, 0x75, 0xce, 0x56, 0x7f, 0xd3, 0x5a, + 0x7a, 0x79, 0xa3, 0x17, 0x67, 0x1d, 0x5d, 0x68, 0xf4, 0xf7, 0x6b, 0x14, 0x9c, 0x66, 0x71, 0x62, + 0xd4, 0x47, 0xdf, 0xaa, 0xd8, 0xa9, 0x17, 0x51, 0x6b, 0x66, 0x11, 0x15, 0x7d, 0x0d, 0x1d, 0x7a, + 0x92, 0xcd, 0x5c, 0xef, 0xe5, 0x62, 0x2e, 0x8f, 0xbe, 0x1b, 0xd2, 0x59, 0xca, 0x1c, 0xe9, 0x41, + 0xb8, 0xc7, 0x91, 0xf9, 0x41, 0x08, 0x61, 0x0e, 0x40, 0x3f, 0x60, 0x8f, 0x7f, 0x8e, 0xef, 0x66, + 0xee, 0xcc, 0x4d, 0x79, 0x81, 0xb9, 0xcb, 0xce, 0xb5, 0xfb, 0x02, 0x24, 0xce, 0x24, 0x9d, 0xc2, + 0x2f, 0x3b, 0x93, 0xba, 0xfa, 0x99, 0x44, 0xa8, 0x25, 0x6a, 0x6b, 0x52, 0x35, 0xdf, 0x84, 0x83, + 0x45, 0x2d, 0x57, 0x88, 0x41, 0x02, 0x59, 0x21, 0xf7, 0x23, 0x6a, 0x5e, 0x02, 0x49, 0x96, 0x44, + 0xf8, 0x65, 0x7e, 0x20, 0xe1, 0xb2, 0x84, 0x7b, 0x1f, 0xd0, 0x11, 0xc9, 0xa6, 0xf1, 0xf1, 0x94, + 0xbc, 0x52, 0x37, 0x89, 0x5b, 0xb0, 0x16, 0xc6, 0xc7, 0x4e, 0x48, 0x61, 0xe2, 0x85, 0x30, 0xbf, + 0x68, 0xe5, 0xb8, 0x0a, 0x05, 0x6f, 0xc1, 0x86, 0x41, 0x45, 0xa8, 0x72, 0x1d, 0x06, 0x47, 0x27, + 0x8b, 0xcc, 0x8f, 0xcf, 0xe4, 0xeb, 0x0c, 0xbd, 0x32, 0x2a, 0x90, 0x40, 0xfb, 0x35, 0xd8, 0x3e, + 0x5a, 0xcc, 0x52, 0x2f, 0x09, 0x66, 0xc4, 0xbc, 0xf8, 0x8f, 0xa1, 0x4d, 0x5e, 0x07, 0x69, 0x16, + 0x44, 0xc7, 0x6c, 0x19, 0x6d, 0x3b, 0x1f, 0x53, 0xeb, 0xcf, 0xbf, 0x62, 0xef, 0x50, 0xb9, 0xf5, + 0x7f, 0x00, 0x97, 0xf3, 0x19, 0x1a, 0x04, 0xd3, 0x5d, 0xcf, 0x23, 0xf3, 0x8c, 0xc8, 0x57, 0x12, + 0x7c, 0x0f, 0xb6, 0x4c, 0x04, 0xed, 0xfd, 0x55, 0x5e, 0xf5, 0x33, 0xf7, 0xa5, 0xc8, 0xf1, 0xda, + 0xb6, 0x09, 0xc4, 0xff, 0x5d, 0x83, 0x2e, 0xfd, 0x4c, 0x92, 0x45, 0xef, 0x95, 0xc2, 0x4d, 0x8b, + 0x8d, 0x1f, 0x99, 0xc9, 0x71, 0xad, 0x90, 0x1c, 0xbf, 0x31, 0x5d, 0x58, 0x56, 0x39, 0x55, 0x69, + 0x49, 0x53, 0x4f, 0x4b, 0x8a, 0xf5, 0xd8, 0xd5, 0x8a, 0x7a, 0xec, 0x36, 0xac, 0x26, 0xac, 0x58, + 0x26, 0x6e, 0xa6, 0x62, 0x44, 0xa3, 0x11, 0xbf, 0xc1, 0x39, 0x09, 0xf1, 0x48, 0xf0, 0x8a, 0x4a, + 0xbb, 0xcd, 0xa3, 0x51, 0x11, 0x4e, 0xaf, 0x6e, 0x02, 0x96, 0x8a, 0x27, 0xab, 0x35, 0xfe, 0x5c, + 0x69, 0x42, 0x69, 0x44, 0x94, 0xd1, 0x5b, 0xa3, 0xca, 0x6b, 0x7c, 0x15, 0x33, 0x74, 0x0d, 0x39, + 0x54, 0x52, 0xee, 0xf0, 0xec, 0xa6, 0x08, 0xa7, 0x51, 0xba, 0xa3, 0x1d, 0x6e, 0xdf, 0xb3, 0x82, + 0xad, 0xcb, 0xb8, 0x5e, 0x90, 0x71, 0x51, 0x9a, 0x8d, 0x0a, 0x69, 0x7e, 0x08, 0x7d, 0x71, 0x9a, + 0x3a, 0x09, 0x71, 0xd3, 0x58, 0x9e, 0x73, 0x05, 0x28, 0xfe, 0x9b, 0x3a, 0x5f, 0xad, 0x48, 0x00, + 0xfe, 0x7f, 0x8d, 0x45, 0xa9, 0xbc, 0x69, 0xa8, 0xfc, 0x3a, 0x0c, 0x0c, 0xd5, 0x12, 0x5f, 0x68, + 0xbc, 0x08, 0xa6, 0x09, 0xbc, 0x52, 0x6d, 0x26, 0xb4, 0xad, 0x83, 0x4a, 0xc2, 0x82, 0x0a, 0x61, + 0x5d, 0x81, 0x46, 0x12, 0x87, 0x84, 0xa9, 0xb4, 0xaf, 0xea, 0x3f, 0x76, 0x1c, 0x12, 0x9b, 0xcd, + 0xd0, 0x93, 0xa6, 0x60, 0x16, 0xc4, 0x67, 0x75, 0xdc, 0x35, 0xbb, 0x3c, 0x41, 0x1d, 0x55, 0x37, + 0x8b, 0x6c, 0xd4, 0xe3, 0x2f, 0x42, 0x06, 0x90, 0xde, 0xbd, 0x13, 0x67, 0x9e, 0x90, 0xe0, 0xd4, + 0x3d, 0x26, 0xa3, 0x3e, 0x43, 0xd1, 0x20, 0xca, 0x95, 0x06, 0x9a, 0x2b, 0xe1, 0xff, 0xaa, 0x41, + 0xf3, 0x49, 0xe2, 0xfa, 0x84, 0x5e, 0x30, 0x4f, 0xa9, 0xc7, 0x3b, 0xcb, 0x2f, 0x7c, 0xb6, 0x8e, + 0x41, 0x3f, 0xc8, 0xb4, 0x0f, 0x6a, 0x95, 0x1f, 0x68, 0x18, 0x9a, 0x7e, 0xea, 0x86, 0x7e, 0xde, + 0xa4, 0x53, 0xcd, 0x12, 0x9a, 0xa6, 0x25, 0xe4, 0xfb, 0x59, 0xd5, 0x43, 0x83, 0x94, 0x7d, 0x6b, + 0xa9, 0xec, 0xaf, 0x40, 0x87, 0xf0, 0x87, 0x21, 0x56, 0xa4, 0xe0, 0x96, 0xa0, 0x83, 0xf2, 0x3b, + 0xca, 0xda, 0x9b, 0xef, 0x28, 0x77, 0xa1, 0xeb, 0x51, 0xc3, 0x20, 0xc9, 0xdc, 0x4d, 0x32, 0x6e, + 0x0a, 0xcb, 0xeb, 0x28, 0x06, 0x2e, 0xbe, 0x09, 0x1b, 0x4c, 0xea, 0x0f, 0x03, 0x7a, 0x42, 0x9d, + 0x6b, 0xb7, 0x30, 0x5e, 0xaa, 0xb5, 0xb4, 0x52, 0x2d, 0xbe, 0x07, 0x9b, 0x26, 0xb2, 0x38, 0x1e, + 0xaf, 0xc1, 0x6a, 0x46, 0xe1, 0xa5, 0x5b, 0x0a, 0xc3, 0xb6, 0xc5, 0x24, 0xfe, 0x63, 0x0b, 0x7a, + 0x14, 0x12, 0x44, 0xc7, 0x53, 0x4a, 0x2f, 0xa5, 0x02, 0x3f, 0x75, 0x5f, 0x3b, 0x29, 0x09, 0x43, + 0x59, 0x16, 0x91, 0x63, 0xd6, 0xfd, 0xe2, 0xbe, 0x76, 0x66, 0x0b, 0x99, 0xd2, 0xc9, 0x21, 0x35, + 0xc3, 0x84, 0xa4, 0x24, 0xa1, 0x49, 0x13, 0xfb, 0x94, 0x07, 0x12, 0x13, 0x48, 0x1d, 0x24, 0x07, + 0x50, 0x22, 0xa2, 0xfd, 0x41, 0x87, 0xe1, 0x1d, 0xbe, 0xa1, 0x7c, 0x41, 0x6f, 0x93, 0x15, 0xff, + 0xb5, 0x05, 0x5b, 0x85, 0x8f, 0x84, 0x18, 0x76, 0x61, 0x95, 0xc9, 0x49, 0x8a, 0xe1, 0x23, 0x5d, + 0x0c, 0x25, 0xf4, 0x5b, 0x7c, 0x28, 0xaa, 0xcc, 0xfc, 0xc3, 0xf1, 0x63, 0xe8, 0x68, 0xe0, 0x8a, + 0xd4, 0xe5, 0xa6, 0x59, 0x65, 0xde, 0xaa, 0x66, 0xa1, 0x65, 0x34, 0xdf, 0x42, 0xf7, 0x69, 0x34, + 0xfb, 0x1e, 0x8d, 0x1a, 0xe8, 0x12, 0xac, 0x25, 0x44, 0xd4, 0x00, 0x44, 0x22, 0xa3, 0x00, 0x78, + 0x00, 0x3d, 0x41, 0x57, 0xbd, 0xaf, 0x3f, 0x8d, 0xc2, 0xd8, 0x7b, 0xf9, 0xb6, 0xef, 0xeb, 0x3f, + 0x03, 0xa4, 0x7f, 0xa0, 0x52, 0xad, 0x05, 0x83, 0x16, 0x52, 0x2d, 0x09, 0x64, 0xa9, 0xd6, 0x07, + 0xd0, 0xd1, 0x51, 0xf8, 0x73, 0x1c, 0x28, 0x04, 0xfc, 0x87, 0x16, 0x0c, 0x9e, 0x05, 0xd9, 0x89, + 0x9f, 0xb8, 0x67, 0x6f, 0xa1, 0xd4, 0x62, 0xaf, 0x43, 0xed, 0x4d, 0xbd, 0x0e, 0xf5, 0x62, 0xaf, + 0x83, 0x1b, 0x86, 0xa2, 0x2c, 0x43, 0x7f, 0xea, 0x05, 0xd9, 0x1e, 0x2f, 0xc8, 0xde, 0x85, 0xa1, + 0x5a, 0xcc, 0xbb, 0x55, 0x63, 0x6f, 0x5c, 0x87, 0xb5, 0xdc, 0xdf, 0x51, 0x0b, 0xea, 0x7b, 0x4f, + 0x7f, 0x63, 0xb8, 0x82, 0xda, 0xd0, 0x38, 0x9a, 0x4c, 0xa7, 0xfc, 0xe1, 0x83, 0xbd, 0x85, 0xd4, + 0x6e, 0xdc, 0x80, 0x06, 0x8d, 0x2e, 0x68, 0x0d, 0x9a, 0x4f, 0x76, 0xbf, 0x9e, 0xd8, 0xbc, 0x5d, + 0xe7, 0x1b, 0xf6, 0xd3, 0x42, 0x5d, 0x68, 0x3f, 0x3a, 0x78, 0x32, 0xb1, 0x0f, 0x76, 0xa7, 0xc3, + 0xda, 0x8d, 0x67, 0xd0, 0x96, 0x79, 0x23, 0x45, 0xda, 0x9d, 0x4e, 0xec, 0x27, 0x1c, 0x7f, 0x62, + 0xdb, 0x87, 0x36, 0xa7, 0xfb, 0x6c, 0xd7, 0x3e, 0x18, 0xd6, 0xe8, 0xaf, 0x47, 0x07, 0x3f, 0x3d, + 0x1c, 0xd6, 0x51, 0x07, 0x5a, 0xdf, 0x4e, 0xec, 0xbd, 0xc3, 0xa3, 0xc9, 0xb0, 0x41, 0x71, 0xef, + 0x4f, 0xf6, 0x9e, 0x3e, 0x18, 0x36, 0x19, 0x47, 0x7b, 0x77, 0x7f, 0x32, 0x5c, 0xdd, 0xf9, 0x77, + 0x0b, 0x5a, 0xcf, 0x17, 0xfe, 0xa3, 0x28, 0xc8, 0xd0, 0x04, 0x40, 0xf5, 0x4f, 0xa0, 0xbc, 0x8b, + 0xa9, 0xd4, 0x85, 0x31, 0x1e, 0x57, 0x4d, 0x09, 0xb3, 0x5a, 0x41, 0x0f, 0xa1, 0xa3, 0xe5, 0xe4, + 0x68, 0xbc, 0xfc, 0xf2, 0x30, 0xbe, 0x58, 0x39, 0x97, 0x53, 0x9a, 0x00, 0x28, 0x8b, 0x53, 0x0b, + 0x2a, 0x99, 0xad, 0x5a, 0x50, 0xd9, 0x40, 0xf1, 0xca, 0xce, 0x1f, 0x5d, 0x84, 0xfa, 0xf3, 0x85, + 0x8f, 0x9e, 0x43, 0x47, 0x6b, 0x30, 0x44, 0xa5, 0x37, 0x36, 0xb5, 0x9c, 0xaa, 0x3e, 0xc4, 0xf1, + 0x2f, 0xfe, 0xf1, 0x3f, 0xfe, 0xa4, 0xb6, 0x89, 0x07, 0xb7, 0x5f, 0xfd, 0xea, 0x6d, 0xd7, 0xf7, + 0xa5, 0x2d, 0xde, 0xb5, 0x6e, 0x20, 0x1b, 0x5a, 0xa2, 0x87, 0x10, 0x6d, 0x6b, 0x34, 0xb4, 0x0b, + 0xde, 0xf8, 0x42, 0x09, 0x2e, 0xe8, 0x6e, 0x33, 0xba, 0x43, 0xdc, 0x11, 0x74, 0xe9, 0x31, 0x45, + 0x69, 0xee, 0x41, 0x7d, 0xcf, 0x8d, 0x10, 0x52, 0x4f, 0xe8, 0x32, 0x26, 0x8c, 0x37, 0x0c, 0x98, + 0xa0, 0x83, 0x18, 0x9d, 0x2e, 0x6e, 0x51, 0x3a, 0x33, 0x37, 0xa2, 0x34, 0x8e, 0xa1, 0x6f, 0x36, + 0x28, 0xa1, 0xcb, 0xfa, 0x4b, 0x50, 0xa9, 0x33, 0x6a, 0xfc, 0xfe, 0xb2, 0xe9, 0xc2, 0x62, 0xfb, + 0x94, 0x89, 0xc7, 0x70, 0x68, 0x7c, 0x40, 0x1e, 0x74, 0xf5, 0x7e, 0x21, 0xa4, 0xba, 0x56, 0xca, + 0x4d, 0x50, 0xe3, 0x4b, 0xd5, 0x93, 0x82, 0xc5, 0x88, 0xb1, 0x40, 0x78, 0xc8, 0x58, 0x50, 0x0c, + 0xf1, 0x54, 0x45, 0xa5, 0x2c, 0x9a, 0x84, 0x94, 0x94, 0xcd, 0x1e, 0x23, 0x25, 0xe5, 0x62, 0x37, + 0x91, 0x21, 0x65, 0x11, 0x13, 0xa9, 0x84, 0x7e, 0x0e, 0xbd, 0x67, 0xac, 0x05, 0x50, 0xb4, 0xa6, + 0x28, 0xca, 0x66, 0x67, 0x8b, 0xa2, 0x5c, 0xe8, 0x61, 0xc1, 0x97, 0x18, 0xe5, 0x6d, 0xbc, 0x4e, + 0x29, 0xf3, 0x76, 0x42, 0x9f, 0xa3, 0x08, 0xcb, 0xf8, 0xde, 0x94, 0x8d, 0x35, 0x6b, 0x34, 0x7f, + 0x1b, 0x7a, 0x46, 0x67, 0x0b, 0xca, 0x05, 0x5a, 0xd5, 0x32, 0x33, 0xbe, 0xbc, 0x64, 0xb6, 0x6a, + 0xfd, 0xbe, 0x40, 0x61, 0xbd, 0x30, 0x94, 0xd7, 0x73, 0x00, 0xd5, 0x21, 0xa2, 0x5c, 0xb0, 0xd4, + 0x95, 0xa2, 0x5c, 0xb0, 0xdc, 0x50, 0x82, 0x37, 0x18, 0x8b, 0x1e, 0xea, 0x70, 0xd3, 0xe4, 0xb4, + 0xa6, 0xd0, 0x12, 0xbd, 0x10, 0x4a, 0x32, 0x66, 0x43, 0x88, 0x92, 0x4c, 0xa1, 0x69, 0x02, 0x0f, + 0x19, 0x41, 0x40, 0x6d, 0x4a, 0x30, 0xa0, 0x24, 0x7e, 0x13, 0x3a, 0x5a, 0x23, 0x01, 0xd2, 0x57, + 0x53, 0xe8, 0x39, 0x50, 0x5e, 0x5e, 0xd1, 0x79, 0x80, 0x37, 0x19, 0xe5, 0x3e, 0xea, 0x52, 0xca, + 0xb2, 0x8a, 0x22, 0xa8, 0xcb, 0x4e, 0x01, 0x83, 0x7a, 0xa1, 0xfd, 0xc0, 0xa0, 0x5e, 0x6c, 0x2d, + 0x30, 0xa9, 0x53, 0x19, 0xb3, 0xb5, 0x3f, 0x03, 0x50, 0x8f, 0xda, 0x4a, 0xc6, 0xa5, 0xd7, 0x79, + 0x25, 0xe3, 0xf2, 0x1b, 0xb8, 0x74, 0x7f, 0x04, 0x94, 0xb4, 0x78, 0xfa, 0x39, 0x86, 0xbe, 0xd9, + 0x73, 0xa0, 0xdc, 0xbf, 0xb2, 0x49, 0x41, 0xb9, 0x7f, 0x75, 0xab, 0x82, 0xb4, 0x48, 0xc4, 0xdd, + 0x5f, 0x91, 0x3d, 0x82, 0xb5, 0xfc, 0x35, 0x1c, 0x8d, 0x74, 0x22, 0xfa, 0xa3, 0xf9, 0xf8, 0xbd, + 0x8a, 0x19, 0x59, 0x04, 0x61, 0x94, 0x3b, 0x68, 0x8d, 0x52, 0xe6, 0x8f, 0x22, 0x92, 0x28, 0xeb, + 0xcb, 0x31, 0x89, 0x6a, 0x4f, 0xe9, 0x05, 0xa2, 0xfa, 0x83, 0x7a, 0x81, 0x28, 0xa3, 0xe3, 0x40, + 0x47, 0x7b, 0x6b, 0x55, 0x9a, 0x2c, 0x3f, 0x14, 0x2b, 0x4d, 0x56, 0x3c, 0xce, 0xe2, 0x0b, 0x8c, + 0xf4, 0x3a, 0x3f, 0x0d, 0xe2, 0x39, 0x89, 0x64, 0x90, 0xfa, 0x2d, 0x00, 0x55, 0x1e, 0x57, 0xca, + 0x2c, 0x3d, 0x9c, 0x28, 0xe3, 0x2e, 0x54, 0xd3, 0xf1, 0x7b, 0x8c, 0xf4, 0x06, 0x8f, 0xb1, 0xec, + 0xc9, 0x82, 0xa9, 0xf3, 0xae, 0x75, 0xe3, 0x8e, 0x85, 0x5e, 0x40, 0x5f, 0xe1, 0x1f, 0x9d, 0x47, + 0xde, 0x9b, 0x58, 0x8c, 0xab, 0xa6, 0xc4, 0x06, 0x2e, 0x33, 0x2e, 0x17, 0x30, 0x32, 0xb9, 0xa4, + 0xe7, 0x91, 0x47, 0xfd, 0xfe, 0x67, 0xd0, 0xd1, 0xba, 0xe0, 0x94, 0x9c, 0xca, 0xad, 0x71, 0xe3, + 0xaa, 0x02, 0xbe, 0x79, 0x5a, 0x8a, 0x3b, 0x52, 0x7a, 0xe6, 0xce, 0x29, 0xed, 0x08, 0xfa, 0x66, + 0x9d, 0x5a, 0x99, 0x65, 0x65, 0xd1, 0x5b, 0x99, 0xe5, 0x92, 0xf2, 0xb6, 0xb1, 0x17, 0x5e, 0x9e, + 0xd5, 0x4f, 0xe7, 0x19, 0x4d, 0x48, 0xf2, 0x72, 0xb5, 0x9e, 0x90, 0x14, 0x4b, 0xe2, 0x7a, 0x42, + 0x52, 0xaa, 0x6f, 0x9b, 0x7b, 0xe2, 0x6c, 0xa4, 0x66, 0x50, 0x02, 0x83, 0x42, 0x2d, 0x19, 0x15, + 0x56, 0x5d, 0x2c, 0x3f, 0x8f, 0x3f, 0x58, 0x3a, 0x2f, 0xf8, 0xbd, 0xcf, 0xf8, 0x8d, 0xf0, 0x86, + 0xe2, 0xe7, 0x86, 0x21, 0x57, 0x13, 0x3f, 0xbb, 0x40, 0x55, 0x86, 0x95, 0x1d, 0x94, 0x8a, 0xcb, + 0xe3, 0x71, 0xd5, 0x94, 0x60, 0x62, 0x58, 0x1b, 0x67, 0x22, 0x33, 0x90, 0x19, 0x74, 0xb4, 0x7a, + 0xa5, 0x92, 0x5b, 0xb9, 0x14, 0xaa, 0xe4, 0x56, 0x55, 0xe0, 0x34, 0xe4, 0x96, 0x92, 0x2c, 0x8c, + 0x8f, 0x59, 0x41, 0x94, 0xf2, 0xf8, 0x16, 0xda, 0xb2, 0xd2, 0x89, 0x72, 0x8f, 0x28, 0x94, 0x43, + 0xc7, 0xa3, 0xf2, 0x44, 0xc1, 0x0d, 0x59, 0x40, 0x4d, 0xc5, 0x2c, 0xa5, 0xeb, 0xc0, 0xa0, 0x50, + 0xf7, 0x54, 0xfa, 0xa8, 0x2e, 0x88, 0x8e, 0x7b, 0xc6, 0x7f, 0x77, 0xe0, 0x8b, 0x8c, 0xf4, 0x16, + 0x62, 0xd2, 0x4f, 0xe5, 0x27, 0xec, 0x3f, 0x32, 0xd2, 0x3b, 0x16, 0x22, 0x1a, 0x83, 0xa2, 0xc2, + 0xab, 0xeb, 0xb4, 0x63, 0xb3, 0x5b, 0x90, 0x3f, 0x94, 0x2f, 0x61, 0xc3, 0x95, 0x7c, 0xc7, 0x42, + 0xf3, 0x42, 0x11, 0x56, 0x54, 0xf3, 0xb4, 0x48, 0x5e, 0x59, 0xa3, 0x1d, 0x57, 0xbd, 0x6f, 0xe1, + 0x1f, 0x30, 0x5e, 0x17, 0xd1, 0x7b, 0x06, 0x2f, 0xea, 0x96, 0xf2, 0x79, 0xef, 0x8e, 0x85, 0x66, + 0xd0, 0x37, 0x49, 0xbe, 0x13, 0xab, 0x82, 0xff, 0x23, 0x54, 0x62, 0x45, 0x79, 0xfc, 0xae, 0x56, + 0x95, 0x36, 0x6a, 0xcf, 0xe8, 0x5a, 0x35, 0xaf, 0x42, 0x6d, 0x7a, 0xbc, 0xa9, 0xf3, 0x94, 0x93, + 0x18, 0x33, 0xa6, 0x97, 0xd0, 0xb8, 0xcc, 0xd4, 0x15, 0x38, 0x2c, 0x84, 0x76, 0xf5, 0xaa, 0x88, + 0xca, 0x55, 0x2b, 0x0a, 0x2b, 0x2a, 0x57, 0xad, 0x2a, 0xa4, 0x48, 0xe5, 0xf1, 0x5c, 0x95, 0x55, + 0x4d, 0x4e, 0x38, 0x06, 0x4f, 0xbe, 0x0b, 0xd5, 0x93, 0x4b, 0x4b, 0xea, 0x0b, 0x85, 0x34, 0xad, + 0xb2, 0xfa, 0x20, 0xfd, 0x14, 0xad, 0x4b, 0x56, 0x41, 0x74, 0xcc, 0x8b, 0x10, 0xe8, 0x2b, 0x68, + 0xb2, 0xab, 0x3d, 0xda, 0x54, 0xd7, 0x20, 0x55, 0x41, 0x18, 0x6f, 0x15, 0xa0, 0x66, 0x2e, 0x82, + 0xd9, 0xe1, 0xb8, 0x88, 0xc4, 0x8d, 0x61, 0x06, 0x7d, 0x9e, 0x0f, 0xcb, 0x0b, 0xb0, 0xf2, 0xca, + 0xc2, 0xfd, 0x5c, 0x79, 0x65, 0xf1, 0xae, 0x6c, 0xc6, 0x63, 0x9e, 0x12, 0x9f, 0x09, 0x9c, 0xbb, + 0xd6, 0x8d, 0xd9, 0x2a, 0xfb, 0x7f, 0xaf, 0x4f, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0x59, 0x5f, + 0xf3, 0xd1, 0x1a, 0x36, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -5326,6 +5583,8 @@ type XudClient interface { // Begin gracefully shutting down xud. // shell: xucli shutdown Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) + // Subscribes to alerts such as low balance. + SubscribeAlerts(ctx context.Context, in *SubscribeAlertsRequest, opts ...grpc.CallOption) (Xud_SubscribeAlertsClient, error) // Subscribes to orders being added to and removed from the order book. This call allows the client // to maintain an up-to-date view of the order book. For example, an exchange that wants to show // its users a real time view of the orders available to them would subscribe to this streaming @@ -5633,8 +5892,40 @@ func (c *xudClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...g return out, nil } +func (c *xudClient) SubscribeAlerts(ctx context.Context, in *SubscribeAlertsRequest, opts ...grpc.CallOption) (Xud_SubscribeAlertsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[1], "/xudrpc.Xud/SubscribeAlerts", opts...) + if err != nil { + return nil, err + } + x := &xudSubscribeAlertsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Xud_SubscribeAlertsClient interface { + Recv() (*Alert, error) + grpc.ClientStream +} + +type xudSubscribeAlertsClient struct { + grpc.ClientStream +} + +func (x *xudSubscribeAlertsClient) Recv() (*Alert, error) { + m := new(Alert) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + func (c *xudClient) SubscribeOrders(ctx context.Context, in *SubscribeOrdersRequest, opts ...grpc.CallOption) (Xud_SubscribeOrdersClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[1], "/xudrpc.Xud/SubscribeOrders", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[2], "/xudrpc.Xud/SubscribeOrders", opts...) if err != nil { return nil, err } @@ -5666,7 +5957,7 @@ func (x *xudSubscribeOrdersClient) Recv() (*OrderUpdate, error) { } func (c *xudClient) SubscribeSwapFailures(ctx context.Context, in *SubscribeSwapsRequest, opts ...grpc.CallOption) (Xud_SubscribeSwapFailuresClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[2], "/xudrpc.Xud/SubscribeSwapFailures", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[3], "/xudrpc.Xud/SubscribeSwapFailures", opts...) if err != nil { return nil, err } @@ -5698,7 +5989,7 @@ func (x *xudSubscribeSwapFailuresClient) Recv() (*SwapFailure, error) { } func (c *xudClient) SubscribeSwaps(ctx context.Context, in *SubscribeSwapsRequest, opts ...grpc.CallOption) (Xud_SubscribeSwapsClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[3], "/xudrpc.Xud/SubscribeSwaps", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[4], "/xudrpc.Xud/SubscribeSwaps", opts...) if err != nil { return nil, err } @@ -5730,7 +6021,7 @@ func (x *xudSubscribeSwapsClient) Recv() (*SwapSuccess, error) { } func (c *xudClient) SubscribeSwapsAccepted(ctx context.Context, in *SubscribeSwapsAcceptedRequest, opts ...grpc.CallOption) (Xud_SubscribeSwapsAcceptedClient, error) { - stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[4], "/xudrpc.Xud/SubscribeSwapsAccepted", opts...) + stream, err := c.cc.NewStream(ctx, &_Xud_serviceDesc.Streams[5], "/xudrpc.Xud/SubscribeSwapsAccepted", opts...) if err != nil { return nil, err } @@ -5898,6 +6189,8 @@ type XudServer interface { // Begin gracefully shutting down xud. // shell: xucli shutdown Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error) + // Subscribes to alerts such as low balance. + SubscribeAlerts(*SubscribeAlertsRequest, Xud_SubscribeAlertsServer) error // Subscribes to orders being added to and removed from the order book. This call allows the client // to maintain an up-to-date view of the order book. For example, an exchange that wants to show // its users a real time view of the orders available to them would subscribe to this streaming @@ -6424,6 +6717,27 @@ func _Xud_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interf return interceptor(ctx, in, info, handler) } +func _Xud_SubscribeAlerts_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SubscribeAlertsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(XudServer).SubscribeAlerts(m, &xudSubscribeAlertsServer{stream}) +} + +type Xud_SubscribeAlertsServer interface { + Send(*Alert) error + grpc.ServerStream +} + +type xudSubscribeAlertsServer struct { + grpc.ServerStream +} + +func (x *xudSubscribeAlertsServer) Send(m *Alert) error { + return x.ServerStream.SendMsg(m) +} + func _Xud_SubscribeOrders_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(SubscribeOrdersRequest) if err := stream.RecvMsg(m); err != nil { @@ -6711,6 +7025,11 @@ var _Xud_serviceDesc = grpc.ServiceDesc{ Handler: _Xud_PlaceOrder_Handler, ServerStreams: true, }, + { + StreamName: "SubscribeAlerts", + Handler: _Xud_SubscribeAlerts_Handler, + ServerStreams: true, + }, { StreamName: "SubscribeOrders", Handler: _Xud_SubscribeOrders_Handler, From 032482ff4fe642b8ba87b1e244d1a7f117ef7cea Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 12 Dec 2020 09:17:52 +0300 Subject: [PATCH 03/16] rebased and fixed import --- lib/connextclient/ConnextClient.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/connextclient/ConnextClient.ts b/lib/connextclient/ConnextClient.ts index 9535aca94..d1ec373ca 100644 --- a/lib/connextclient/ConnextClient.ts +++ b/lib/connextclient/ConnextClient.ts @@ -5,6 +5,7 @@ import { combineLatest, defer, from, fromEvent, interval, Observable, of, Subscr import { catchError, distinctUntilChanged, filter, mergeMap, mergeMapTo, pluck, take, timeout } from 'rxjs/operators'; import { SwapClientType, SwapRole, SwapState } from '../constants/enums'; import { CurrencyInstance } from '../db/types'; +import { BalanceAlert } from '../alerts/types'; import Logger from '../Logger'; import swapErrors from '../swaps/errors'; import SwapClient, { From 6458e813c24fe41b038aa5b3caf97df3e1ac3d6f Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 12 Dec 2020 09:30:09 +0300 Subject: [PATCH 04/16] fixed eslint issues --- lib/cli/commands/streamalerts.ts | 6 ++---- lib/cli/utils.ts | 4 ++-- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/lib/cli/commands/streamalerts.ts b/lib/cli/commands/streamalerts.ts index be05e0eef..966cc1a6f 100644 --- a/lib/cli/commands/streamalerts.ts +++ b/lib/cli/commands/streamalerts.ts @@ -1,19 +1,17 @@ import { Arguments, Argv } from 'yargs'; +import moment from 'moment'; import { XudClient } from '../../proto/xudrpc_grpc_pb'; import * as xudrpc from '../../proto/xudrpc_pb'; import { loadXudClient } from '../command'; import { AlertType, ChannelSide } from '../../constants/enums'; import { onStreamError, waitForClient } from '../utils'; -import moment from 'moment'; export const command = 'streamalerts'; export const describe = 'stream alert notifications from xud'; export const builder = (argv: Argv) => argv - .option('pretty', { - type: 'boolean', - }) + .option('pretty', {type: 'boolean',}) .example('$0 streamalerts -j', 'prints alert payload in a JSON structure') .example('$0 streamalerts', 'prints alert message only'); diff --git a/lib/cli/utils.ts b/lib/cli/utils.ts index df8d54c4a..3a1ab3b77 100644 --- a/lib/cli/utils.ts +++ b/lib/cli/utils.ts @@ -2,9 +2,9 @@ import colors from 'colors/safe'; import { accessSync, watch } from 'fs'; import os from 'os'; import path from 'path'; -import { XudClient } from '../proto/xudrpc_grpc_pb'; import { Arguments } from 'yargs'; import { ServiceError, status } from 'grpc'; +import { XudClient } from '../proto/xudrpc_grpc_pb'; import { setTimeoutPromise } from '../utils/utils'; const SATOSHIS_PER_COIN = 10 ** 8; @@ -114,7 +114,7 @@ export const waitForClient = (client: XudClient, argv: Arguments, ensureConnecti } if (printError) console.error(`${error.name}: ${error.message}`); - setTimeout(ensureConnection.bind(undefined, argv, printError), 3000); + setTimeout(ensureConnection, 3000); } else { console.log('Successfully connected, streaming'); successCallback(argv); From 947ab1a8e303c8e9401371e30bd81450c519229d Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 12 Dec 2020 09:34:01 +0300 Subject: [PATCH 05/16] fixed prettier formatting --- lib/alerts/Alerts.ts | 10 +++-- lib/alerts/types.ts | 10 ++--- lib/cli/commands/streamalerts.ts | 26 +++++++----- lib/cli/utils.ts | 8 +++- lib/connextclient/ConnextClient.ts | 23 +++++++---- lib/grpc/GrpcService.ts | 2 +- lib/service/Service.ts | 7 +++- lib/swaps/SwapClient.ts | 27 +++++++++++-- test/jest/LndClient.spec.ts | 63 ++++-------------------------- 9 files changed, 87 insertions(+), 89 deletions(-) diff --git a/lib/alerts/Alerts.ts b/lib/alerts/Alerts.ts index 59480c63d..ccbc93575 100644 --- a/lib/alerts/Alerts.ts +++ b/lib/alerts/Alerts.ts @@ -20,7 +20,7 @@ class Alerts extends EventEmitter { private alerts = new Map(); private logger: Logger; - constructor({ swapClientManager, logger }: {swapClientManager: SwapClientManager, logger: Logger}) { + constructor({ swapClientManager, logger }: { swapClientManager: SwapClientManager; logger: Logger }) { super(); this.logger = logger; this.listenLowTradingBalanceAlerts(swapClientManager); @@ -40,13 +40,17 @@ class Alerts extends EventEmitter { if (this.alerts.get(stringRepresentation) === undefined || this.checkAlertThreshold(stringRepresentation)) { this.logger.trace(`triggering low balance alert ${stringRepresentation}`); - balanceAlert.message = `${ChannelSide[balanceAlert.side || 0]} trading balance (${satsToCoinsStr(balanceAlert.sideBalance || 0)} ${balanceAlert.currency}) is lower than 10% of trading capacity (${satsToCoinsStr(balanceAlert.totalBalance || 0)} ${balanceAlert.currency})`; + balanceAlert.message = `${ChannelSide[balanceAlert.side || 0]} trading balance (${satsToCoinsStr( + balanceAlert.sideBalance || 0, + )} ${balanceAlert.currency}) is lower than 10% of trading capacity (${satsToCoinsStr( + balanceAlert.totalBalance || 0, + )} ${balanceAlert.currency})`; balanceAlert.type = AlertType.LowTradingBalance; this.alerts.set(stringRepresentation, Date.now()); this.emit('alert', balanceAlert); } - } + }; private checkAlertThreshold(stringRepresentation: string) { const lastThrownTime = this.alerts.get(stringRepresentation) || 0; diff --git a/lib/alerts/types.ts b/lib/alerts/types.ts index e99dd6390..c276e8b7e 100644 --- a/lib/alerts/types.ts +++ b/lib/alerts/types.ts @@ -1,15 +1,15 @@ import { AlertType, ChannelSide } from '../constants/enums'; export type BalanceAlert = Alert & { - /** The total balance of the channel when the alert is triggered. */ + /** The total balance of the channel when the alert is triggered. */ totalBalance: number; - /** The side of the balance either local or remote. */ + /** The side of the balance either local or remote. */ side: ChannelSide; - /** The balance that triggered the alert. */ + /** The balance that triggered the alert. */ sideBalance: number; - /** The alert threshold in percentage, e.g. 10 means %10. */ + /** The alert threshold in percentage, e.g. 10 means %10. */ bound: number; - /** The currency of the channel. */ + /** The currency of the channel. */ currency: string; }; diff --git a/lib/cli/commands/streamalerts.ts b/lib/cli/commands/streamalerts.ts index 966cc1a6f..c09b9e858 100644 --- a/lib/cli/commands/streamalerts.ts +++ b/lib/cli/commands/streamalerts.ts @@ -10,8 +10,9 @@ export const command = 'streamalerts'; export const describe = 'stream alert notifications from xud'; -export const builder = (argv: Argv) => argv - .option('pretty', {type: 'boolean',}) +export const builder = (argv: Argv) => + argv + .option('pretty', { type: 'boolean' }) .example('$0 streamalerts -j', 'prints alert payload in a JSON structure') .example('$0 streamalerts', 'prints alert message only'); @@ -30,14 +31,19 @@ const ensureConnection = async (argv: Arguments, printError?: boolean) => { }; const structAlertJson = (alertObject: xudrpc.Alert.AsObject) => { - const result: {type: string, payload: { - totalBalance?: number, - side?: string, - bound?: number, - sideBalance?: number, - channelPoint?: string, - currency?: string, - } | undefined } = { + const result: { + type: string; + payload: + | { + totalBalance?: number; + side?: string; + bound?: number; + sideBalance?: number; + channelPoint?: string; + currency?: string; + } + | undefined; + } = { type: AlertType[alertObject.type], payload: undefined, }; diff --git a/lib/cli/utils.ts b/lib/cli/utils.ts index 3a1ab3b77..6ede77086 100644 --- a/lib/cli/utils.ts +++ b/lib/cli/utils.ts @@ -105,7 +105,13 @@ somewhere safe, it is your ONLY backup in case of data loss. `); } -export const waitForClient = (client: XudClient, argv: Arguments, ensureConnection: Function, successCallback: Function, printError?: boolean) => { +export const waitForClient = ( + client: XudClient, + argv: Arguments, + ensureConnection: Function, + successCallback: Function, + printError?: boolean, +) => { client.waitForReady(Date.now() + 3000, (error: Error | null) => { if (error) { if (error.message === 'Failed to connect before the deadline') { diff --git a/lib/connextclient/ConnextClient.ts b/lib/connextclient/ConnextClient.ts index d1ec373ca..434360da7 100644 --- a/lib/connextclient/ConnextClient.ts +++ b/lib/connextclient/ConnextClient.ts @@ -47,18 +47,31 @@ import { interface ConnextClient { on(event: 'preimage', listener: (preimageRequest: ProvidePreimageEvent) => void): void; + on(event: 'transferReceived', listener: (transferReceivedRequest: TransferReceivedEvent) => void): void; + on(event: 'htlcAccepted', listener: (rHash: string, amount: number, currency: string) => void): this; + on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; + on(event: 'depositConfirmed', listener: (hash: string) => void): this; + on(event: 'lowTradingBalance', listener: (alert: BalanceAlert) => void): this; + once(event: 'initialized', listener: () => void): this; + emit(event: 'htlcAccepted', rHash: string, amount: number, currency: string): boolean; + emit(event: 'connectionVerified', swapClientInfo: SwapClientInfo): boolean; + emit(event: 'initialized'): boolean; + emit(event: 'preimage', preimageRequest: ProvidePreimageEvent): void; + emit(event: 'transferReceived', transferReceivedRequest: TransferReceivedEvent): void; + emit(event: 'depositConfirmed', hash: string): void; + emit(event: 'lowTradingBalance', alert: BalanceAlert): boolean; } @@ -140,6 +153,7 @@ class ConnextClient extends SwapClient { public get label() { return 'Connext'; } + public readonly type = SwapClientType.Connext; public readonly finalLock = 200; public address?: string; @@ -343,14 +357,7 @@ class ConnextClient extends SwapClient { const totalBalance = remoteBalance + localBalance; const alertThreshold = totalBalance * 0.1; - this.checkLowBalance( - remoteBalance, - localBalance, - totalBalance, - alertThreshold, - currency, - this.emit.bind(this), - ); + this.checkLowBalance(remoteBalance, localBalance, totalBalance, alertThreshold, currency, this.emit.bind(this)); } } catch (e) { this.logger.error('failed to update total outbound capacity', e); diff --git a/lib/grpc/GrpcService.ts b/lib/grpc/GrpcService.ts index 39d8e1f80..08d0b27c1 100644 --- a/lib/grpc/GrpcService.ts +++ b/lib/grpc/GrpcService.ts @@ -1009,7 +1009,7 @@ class GrpcService { call.write(alert); }, cancelled$); this.addStream(call); - } + }; /* * See [[Service.subscribeOrders]] diff --git a/lib/service/Service.ts b/lib/service/Service.ts index 1e4d339d8..c173d51ba 100644 --- a/lib/service/Service.ts +++ b/lib/service/Service.ts @@ -75,8 +75,9 @@ const argChecks = { } }, VALID_PORT: ({ port }: { port: number }) => { - if (port < 1024 || port > 65535 || !Number.isInteger(port)) + if (port < 1024 || port > 65535 || !Number.isInteger(port)) { throw errors.INVALID_ARGUMENT('port must be an integer between 1024 and 65535'); + } }, VALID_SWAP_CLIENT: ({ swapClient }: { swapClient: number }) => { if (!SwapClientType[swapClient]) throw errors.INVALID_ARGUMENT('swap client is not recognized'); @@ -88,6 +89,7 @@ const argChecks = { interface Service { on(event: 'logLevel', listener: (level: Level) => void): this; + emit(event: 'logLevel', level: Level): boolean; } @@ -834,7 +836,7 @@ class Service extends EventEmitter { private getMergedObservable$(observables: Observable[], cancelled$: Observable) { return merge(...observables).pipe(takeUntil(cancelled$)); - }; + } /* * Subscribe to orders being added to the order book. @@ -985,4 +987,5 @@ class Service extends EventEmitter { await this.swapClientManager.changeLndPasswords(oldPassword, newPassword); }; } + export default Service; diff --git a/lib/swaps/SwapClient.ts b/lib/swaps/SwapClient.ts index 98060328c..4ba378671 100644 --- a/lib/swaps/SwapClient.ts +++ b/lib/swaps/SwapClient.ts @@ -71,8 +71,11 @@ export type WithdrawArguments = { interface SwapClient { on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; + once(event: 'initialized', listener: () => void): this; + emit(event: 'connectionVerified', swapClientInfo: SwapClientInfo): boolean; + emit(event: 'initialized'): boolean; } @@ -111,6 +114,7 @@ abstract class SwapClient extends EventEmitter { * currencies supported by this client are included in the balance. */ public abstract channelBalance(currency?: string): Promise; + /** * Returns total unspent outputs (confirmed and unconfirmed), * all confirmed unspent outputs @@ -119,6 +123,7 @@ abstract class SwapClient extends EventEmitter { * currencies supported by this client are included in the balance. */ public abstract walletBalance(currency?: string): Promise; + /** * Returns and updates the maximum outbound and inbound capacities for a distinct channel. * @param currency the currency whose trading limits to query for, otherwise all/any @@ -127,6 +132,7 @@ abstract class SwapClient extends EventEmitter { public abstract swapCapacities(currency?: string): Promise; public abstract setReservedInboundAmount(reservedInboundAmount: number, currency?: string): void; + protected abstract updateCapacity(): Promise; public verifyConnectionWithTimeout = () => { @@ -228,8 +234,14 @@ abstract class SwapClient extends EventEmitter { } }; - protected checkLowBalance = (remoteBalance: number, localBalance: number, totalBalance: number, - alertThreshold: number, currency: string, emit: Function) => { + protected checkLowBalance = ( + remoteBalance: number, + localBalance: number, + totalBalance: number, + alertThreshold: number, + currency: string, + emit: Function, + ) => { if (localBalance < alertThreshold) { emit('lowTradingBalance', { totalBalance, @@ -249,7 +261,7 @@ abstract class SwapClient extends EventEmitter { bound: 10, }); } - } + }; private updateCapacityTimerCallback = async () => { if (this.isConnected()) { @@ -393,30 +405,38 @@ abstract class SwapClient extends EventEmitter { public isConnected(): boolean { return this.status === ClientStatus.ConnectionVerified; } + public isDisabled(): boolean { return this.status === ClientStatus.Disabled; } + public isMisconfigured(): boolean { return this.status === ClientStatus.Misconfigured; } + /** * Returns `true` if the client is enabled and configured properly. */ public isOperational(): boolean { return !this.isDisabled() && !this.isMisconfigured() && !this.isNotInitialized(); } + public isDisconnected(): boolean { return this.status === ClientStatus.Disconnected; } + public isWaitingUnlock(): boolean { return this.status === ClientStatus.WaitingUnlock; } + public isNotInitialized(): boolean { return this.status === ClientStatus.NotInitialized; } + public isOutOfSync(): boolean { return this.status === ClientStatus.OutOfSync; } + public hasNoInvoiceSupport(): boolean { return this.status === ClientStatus.NoHoldInvoiceSupport; } @@ -434,6 +454,7 @@ abstract class SwapClient extends EventEmitter { } this.removeAllListeners(); } + protected abstract disconnect(): void; } diff --git a/test/jest/LndClient.spec.ts b/test/jest/LndClient.spec.ts index fcb1adbd1..4aa1972c3 100644 --- a/test/jest/LndClient.spec.ts +++ b/test/jest/LndClient.spec.ts @@ -289,14 +289,7 @@ describe('LndClient', () => { const remoteBalance = 110; const currency = 'BTC'; - lnd['checkLowBalance']( - remoteBalance, - localBalance, - totalBalance, - alertThreshold, - currency, - emit, - ); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); expect(emit).toHaveBeenCalledTimes(1); expect(emit).toHaveBeenCalledWith('lowTradingBalance', { @@ -315,14 +308,7 @@ describe('LndClient', () => { const remoteBalance = 110; const currency = 'BTC'; - lnd['checkLowBalance']( - remoteBalance, - localBalance, - totalBalance, - alertThreshold, - currency, - emit, - ); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); expect(emit).toHaveBeenCalledTimes(1); expect(emit).toHaveBeenCalledWith('lowTradingBalance', { @@ -341,14 +327,7 @@ describe('LndClient', () => { const remoteBalance = 110; const currency = 'BTC'; - lnd['checkLowBalance']( - remoteBalance, - localBalance, - totalBalance, - alertThreshold, - currency, - emit, - ); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); expect(emit).toHaveBeenCalledTimes(0); }); @@ -360,14 +339,7 @@ describe('LndClient', () => { const remoteBalance = 110; const currency = 'BTC'; - lnd['checkLowBalance']( - remoteBalance, - localBalance, - totalBalance, - alertThreshold, - currency, - emit, - ); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); expect(emit).toHaveBeenCalledTimes(0); }); @@ -379,14 +351,7 @@ describe('LndClient', () => { const remoteBalance = 10; const currency = 'BTC'; - lnd['checkLowBalance']( - remoteBalance, - localBalance, - totalBalance, - alertThreshold, - currency, - emit, - ); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); expect(emit).toHaveBeenCalledTimes(1); expect(emit).toHaveBeenCalledWith('lowTradingBalance', { @@ -405,14 +370,7 @@ describe('LndClient', () => { const remoteBalance = 12; const currency = 'BTC'; - lnd['checkLowBalance']( - remoteBalance, - localBalance, - totalBalance, - alertThreshold, - currency, - emit, - ); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); expect(emit).toHaveBeenCalledTimes(0); }); @@ -424,14 +382,7 @@ describe('LndClient', () => { const remoteBalance = 12.5; const currency = 'BTC'; - lnd['checkLowBalance']( - remoteBalance, - localBalance, - totalBalance, - alertThreshold, - currency, - emit, - ); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); expect(emit).toHaveBeenCalledTimes(0); }); From d2cff5c1cafc4d0ecf2f99941881bc0cae27a4ca Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 12 Dec 2020 10:02:13 +0300 Subject: [PATCH 06/16] fixed prettier formatting --- lib/lndclient/LndClient.ts | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/lib/lndclient/LndClient.ts b/lib/lndclient/LndClient.ts index 69cfb8327..c17001145 100644 --- a/lib/lndclient/LndClient.ts +++ b/lib/lndclient/LndClient.ts @@ -247,20 +247,22 @@ class LndClient extends SwapClient { }; protected updateCapacity = async () => { - await this.channelBalance().then(() => { - const totalBalance = this.totalOutboundAmount + this.totalInboundAmount; - const alertThreshold = totalBalance * 0.1; - this.checkLowBalance( + await this.channelBalance() + .then(() => { + const totalBalance = this.totalOutboundAmount + this.totalInboundAmount; + const alertThreshold = totalBalance * 0.1; + this.checkLowBalance( this.totalInboundAmount, this.totalOutboundAmount, totalBalance, alertThreshold, this.currency, this.emit.bind(this), - ); - }).catch(async (err) => { - this.logger.error('failed to update total outbound capacity', err); - }); + ); + }) + .catch(async (err) => { + this.logger.error('failed to update total outbound capacity', err); + }); }; private unaryCall = (methodName: Exclude, params: T): Promise => { From 6f3ee1cc9b69a952eeee7fd3690834e66a3ec165 Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 12 Dec 2020 10:03:39 +0300 Subject: [PATCH 07/16] fixed prettier formatting --- lib/connextclient/ConnextClient.ts | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/lib/connextclient/ConnextClient.ts b/lib/connextclient/ConnextClient.ts index 434360da7..9b6f99489 100644 --- a/lib/connextclient/ConnextClient.ts +++ b/lib/connextclient/ConnextClient.ts @@ -47,31 +47,18 @@ import { interface ConnextClient { on(event: 'preimage', listener: (preimageRequest: ProvidePreimageEvent) => void): void; - on(event: 'transferReceived', listener: (transferReceivedRequest: TransferReceivedEvent) => void): void; - on(event: 'htlcAccepted', listener: (rHash: string, amount: number, currency: string) => void): this; - on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; - on(event: 'depositConfirmed', listener: (hash: string) => void): this; - on(event: 'lowTradingBalance', listener: (alert: BalanceAlert) => void): this; - once(event: 'initialized', listener: () => void): this; - emit(event: 'htlcAccepted', rHash: string, amount: number, currency: string): boolean; - emit(event: 'connectionVerified', swapClientInfo: SwapClientInfo): boolean; - emit(event: 'initialized'): boolean; - emit(event: 'preimage', preimageRequest: ProvidePreimageEvent): void; - emit(event: 'transferReceived', transferReceivedRequest: TransferReceivedEvent): void; - emit(event: 'depositConfirmed', hash: string): void; - emit(event: 'lowTradingBalance', alert: BalanceAlert): boolean; } @@ -153,7 +140,6 @@ class ConnextClient extends SwapClient { public get label() { return 'Connext'; } - public readonly type = SwapClientType.Connext; public readonly finalLock = 200; public address?: string; From 9ccda04c756db3e14171b4ca34e51169eb35841d Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 12 Dec 2020 10:05:22 +0300 Subject: [PATCH 08/16] fixed prettier formatting --- lib/service/Service.ts | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/lib/service/Service.ts b/lib/service/Service.ts index c173d51ba..60162d847 100644 --- a/lib/service/Service.ts +++ b/lib/service/Service.ts @@ -75,9 +75,8 @@ const argChecks = { } }, VALID_PORT: ({ port }: { port: number }) => { - if (port < 1024 || port > 65535 || !Number.isInteger(port)) { + if (port < 1024 || port > 65535 || !Number.isInteger(port)) throw errors.INVALID_ARGUMENT('port must be an integer between 1024 and 65535'); - } }, VALID_SWAP_CLIENT: ({ swapClient }: { swapClient: number }) => { if (!SwapClientType[swapClient]) throw errors.INVALID_ARGUMENT('swap client is not recognized'); @@ -89,7 +88,6 @@ const argChecks = { interface Service { on(event: 'logLevel', listener: (level: Level) => void): this; - emit(event: 'logLevel', level: Level): boolean; } @@ -987,5 +985,4 @@ class Service extends EventEmitter { await this.swapClientManager.changeLndPasswords(oldPassword, newPassword); }; } - export default Service; From 8dcf5cfe994c4ff9b7073c6fd2e5540cef8014e9 Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 12 Dec 2020 10:06:36 +0300 Subject: [PATCH 09/16] fixed prettier formatting --- lib/swaps/SwapClient.ts | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/lib/swaps/SwapClient.ts b/lib/swaps/SwapClient.ts index 4ba378671..5f8d14b36 100644 --- a/lib/swaps/SwapClient.ts +++ b/lib/swaps/SwapClient.ts @@ -71,11 +71,8 @@ export type WithdrawArguments = { interface SwapClient { on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; - once(event: 'initialized', listener: () => void): this; - emit(event: 'connectionVerified', swapClientInfo: SwapClientInfo): boolean; - emit(event: 'initialized'): boolean; } @@ -114,7 +111,6 @@ abstract class SwapClient extends EventEmitter { * currencies supported by this client are included in the balance. */ public abstract channelBalance(currency?: string): Promise; - /** * Returns total unspent outputs (confirmed and unconfirmed), * all confirmed unspent outputs @@ -123,7 +119,6 @@ abstract class SwapClient extends EventEmitter { * currencies supported by this client are included in the balance. */ public abstract walletBalance(currency?: string): Promise; - /** * Returns and updates the maximum outbound and inbound capacities for a distinct channel. * @param currency the currency whose trading limits to query for, otherwise all/any @@ -132,7 +127,6 @@ abstract class SwapClient extends EventEmitter { public abstract swapCapacities(currency?: string): Promise; public abstract setReservedInboundAmount(reservedInboundAmount: number, currency?: string): void; - protected abstract updateCapacity(): Promise; public verifyConnectionWithTimeout = () => { @@ -405,38 +399,30 @@ abstract class SwapClient extends EventEmitter { public isConnected(): boolean { return this.status === ClientStatus.ConnectionVerified; } - public isDisabled(): boolean { return this.status === ClientStatus.Disabled; } - public isMisconfigured(): boolean { return this.status === ClientStatus.Misconfigured; } - /** * Returns `true` if the client is enabled and configured properly. */ public isOperational(): boolean { return !this.isDisabled() && !this.isMisconfigured() && !this.isNotInitialized(); } - public isDisconnected(): boolean { return this.status === ClientStatus.Disconnected; } - public isWaitingUnlock(): boolean { return this.status === ClientStatus.WaitingUnlock; } - public isNotInitialized(): boolean { return this.status === ClientStatus.NotInitialized; } - public isOutOfSync(): boolean { return this.status === ClientStatus.OutOfSync; } - public hasNoInvoiceSupport(): boolean { return this.status === ClientStatus.NoHoldInvoiceSupport; } @@ -454,7 +440,6 @@ abstract class SwapClient extends EventEmitter { } this.removeAllListeners(); } - protected abstract disconnect(): void; } From f7b7aabf894d1e009ed92b60e6c4b369de33cb56 Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 12 Dec 2020 10:19:17 +0300 Subject: [PATCH 10/16] fixed review --- docs/api.md | 1 + lib/alerts/Alerts.ts | 3 +- lib/alerts/types.ts | 1 + lib/cli/commands/streamalerts.ts | 4 +- lib/grpc/GrpcService.ts | 1 + lib/proto/xudrpc.swagger.json | 5 + lib/proto/xudrpc_pb.d.ts | 6 +- lib/proto/xudrpc_pb.js | 41 +- lib/swaps/SwapClient.ts | 2 +- proto/xudrpc.proto | 4 +- test/simulation/xudrpc/xudrpc.pb.go | 560 ++++++++++++++-------------- 11 files changed, 341 insertions(+), 287 deletions(-) diff --git a/docs/api.md b/docs/api.md index 12da08a64..7ae6e4f74 100644 --- a/docs/api.md +++ b/docs/api.md @@ -166,6 +166,7 @@ | ----- | ---- | ----- | ----------- | | type | [Alert.AlertType](#xudrpc.Alert.AlertType) | | | | message | [string](#string) | | The human readable alert message. | +| date | [int64](#int64) | | The human readable alert message. | | balance_alert | [BalanceAlert](#xudrpc.BalanceAlert) | | | diff --git a/lib/alerts/Alerts.ts b/lib/alerts/Alerts.ts index ccbc93575..ba16a549c 100644 --- a/lib/alerts/Alerts.ts +++ b/lib/alerts/Alerts.ts @@ -46,8 +46,9 @@ class Alerts extends EventEmitter { balanceAlert.totalBalance || 0, )} ${balanceAlert.currency})`; balanceAlert.type = AlertType.LowTradingBalance; + balanceAlert.date = Date.now(); - this.alerts.set(stringRepresentation, Date.now()); + this.alerts.set(stringRepresentation, balanceAlert.date); this.emit('alert', balanceAlert); } }; diff --git a/lib/alerts/types.ts b/lib/alerts/types.ts index c276e8b7e..0e3084eec 100644 --- a/lib/alerts/types.ts +++ b/lib/alerts/types.ts @@ -16,4 +16,5 @@ export type BalanceAlert = Alert & { export type Alert = { type: AlertType; message: string; + date: number; }; diff --git a/lib/cli/commands/streamalerts.ts b/lib/cli/commands/streamalerts.ts index c09b9e858..17011224c 100644 --- a/lib/cli/commands/streamalerts.ts +++ b/lib/cli/commands/streamalerts.ts @@ -33,6 +33,7 @@ const ensureConnection = async (argv: Arguments, printError?: boolean) => { const structAlertJson = (alertObject: xudrpc.Alert.AsObject) => { const result: { type: string; + date: number; payload: | { totalBalance?: number; @@ -45,6 +46,7 @@ const structAlertJson = (alertObject: xudrpc.Alert.AsObject) => { | undefined; } = { type: AlertType[alertObject.type], + date: alertObject.date, payload: undefined, }; @@ -69,7 +71,7 @@ const streamalerts = (argv: Arguments) => { if (argv.json) { console.log(JSON.stringify(structAlertJson(alert.toObject()), undefined, 2)); } else { - console.log(`(${moment()}) ${AlertType[alert.getType()]}: ${alert.getMessage()}`); + console.log(`(${moment(alert.getDate())}) ${AlertType[alert.getType()]}: ${alert.getMessage()}`); } }); alertsSubscription.on('end', reconnect.bind(undefined, argv)); diff --git a/lib/grpc/GrpcService.ts b/lib/grpc/GrpcService.ts index 08d0b27c1..c991046be 100644 --- a/lib/grpc/GrpcService.ts +++ b/lib/grpc/GrpcService.ts @@ -996,6 +996,7 @@ class GrpcService { const alert = new xudrpc.Alert(); alert.setType(serviceAlert.type as number); alert.setMessage(serviceAlert.message); + alert.setDate(serviceAlert.date); if (serviceAlert.type === AlertType.LowTradingBalance) { const balanceServiceAlert = serviceAlert as BalanceAlert; const balanceAlert = new xudrpc.BalanceAlert(); diff --git a/lib/proto/xudrpc.swagger.json b/lib/proto/xudrpc.swagger.json index 9757cae3a..fece642e4 100644 --- a/lib/proto/xudrpc.swagger.json +++ b/lib/proto/xudrpc.swagger.json @@ -1014,6 +1014,11 @@ "type": "string", "description": "The human readable alert message." }, + "date": { + "type": "string", + "format": "int64", + "description": "The human readable alert message." + }, "balance_alert": { "$ref": "#/definitions/xudrpcBalanceAlert" } diff --git a/lib/proto/xudrpc_pb.d.ts b/lib/proto/xudrpc_pb.d.ts index 3999dc547..dd8736fd7 100644 --- a/lib/proto/xudrpc_pb.d.ts +++ b/lib/proto/xudrpc_pb.d.ts @@ -72,6 +72,9 @@ export class Alert extends jspb.Message { getMessage(): string; setMessage(value: string): void; + getDate(): number; + setDate(value: number): void; + hasBalanceAlert(): boolean; clearBalanceAlert(): void; @@ -95,6 +98,7 @@ export namespace Alert { export type AsObject = { type: Alert.AlertType, message: string, + date: number, balanceAlert?: BalanceAlert.AsObject, } @@ -106,7 +110,7 @@ export namespace Alert { export enum PayloadCase { PAYLOAD_NOT_SET = 0, - BALANCE_ALERT = 3, + BALANCE_ALERT = 4, } diff --git a/lib/proto/xudrpc_pb.js b/lib/proto/xudrpc_pb.js index c190e4abc..4b2488bd7 100644 --- a/lib/proto/xudrpc_pb.js +++ b/lib/proto/xudrpc_pb.js @@ -534,14 +534,14 @@ if (goog.DEBUG && !COMPILED) { * @private {!Array>} * @const */ -proto.xudrpc.Alert.oneofGroups_ = [[3]]; +proto.xudrpc.Alert.oneofGroups_ = [[4]]; /** * @enum {number} */ proto.xudrpc.Alert.PayloadCase = { PAYLOAD_NOT_SET: 0, - BALANCE_ALERT: 3 + BALANCE_ALERT: 4 }; /** @@ -582,6 +582,7 @@ proto.xudrpc.Alert.toObject = function(includeInstance, msg) { var f, obj = { type: jspb.Message.getFieldWithDefault(msg, 1, 0), message: jspb.Message.getFieldWithDefault(msg, 2, ""), + date: jspb.Message.getFieldWithDefault(msg, 3, 0), balanceAlert: (f = msg.getBalanceAlert()) && proto.xudrpc.BalanceAlert.toObject(includeInstance, f) }; @@ -628,6 +629,10 @@ proto.xudrpc.Alert.deserializeBinaryFromReader = function(msg, reader) { msg.setMessage(value); break; case 3: + var value = /** @type {number} */ (reader.readInt64()); + msg.setDate(value); + break; + case 4: var value = new proto.xudrpc.BalanceAlert; reader.readMessage(value,proto.xudrpc.BalanceAlert.deserializeBinaryFromReader); msg.setBalanceAlert(value); @@ -675,10 +680,17 @@ proto.xudrpc.Alert.serializeBinaryToWriter = function(message, writer) { f ); } + f = message.getDate(); + if (f !== 0) { + writer.writeInt64( + 3, + f + ); + } f = message.getBalanceAlert(); if (f != null) { writer.writeMessage( - 3, + 4, f, proto.xudrpc.BalanceAlert.serializeBinaryToWriter ); @@ -724,18 +736,33 @@ proto.xudrpc.Alert.prototype.setMessage = function(value) { /** - * optional BalanceAlert balance_alert = 3; + * optional int64 date = 3; + * @return {number} + */ +proto.xudrpc.Alert.prototype.getDate = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** @param {number} value */ +proto.xudrpc.Alert.prototype.setDate = function(value) { + jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * optional BalanceAlert balance_alert = 4; * @return {?proto.xudrpc.BalanceAlert} */ proto.xudrpc.Alert.prototype.getBalanceAlert = function() { return /** @type{?proto.xudrpc.BalanceAlert} */ ( - jspb.Message.getWrapperField(this, proto.xudrpc.BalanceAlert, 3)); + jspb.Message.getWrapperField(this, proto.xudrpc.BalanceAlert, 4)); }; /** @param {?proto.xudrpc.BalanceAlert|undefined} value */ proto.xudrpc.Alert.prototype.setBalanceAlert = function(value) { - jspb.Message.setOneofWrapperField(this, 3, proto.xudrpc.Alert.oneofGroups_[0], value); + jspb.Message.setOneofWrapperField(this, 4, proto.xudrpc.Alert.oneofGroups_[0], value); }; @@ -749,7 +776,7 @@ proto.xudrpc.Alert.prototype.clearBalanceAlert = function() { * @return {boolean} */ proto.xudrpc.Alert.prototype.hasBalanceAlert = function() { - return jspb.Message.getField(this, 3) != null; + return jspb.Message.getField(this, 4) != null; }; diff --git a/lib/swaps/SwapClient.ts b/lib/swaps/SwapClient.ts index 5f8d14b36..0fda8a1ad 100644 --- a/lib/swaps/SwapClient.ts +++ b/lib/swaps/SwapClient.ts @@ -236,7 +236,7 @@ abstract class SwapClient extends EventEmitter { currency: string, emit: Function, ) => { - if (localBalance < alertThreshold) { + if (localBalance < 490000001) { emit('lowTradingBalance', { totalBalance, currency, diff --git a/proto/xudrpc.proto b/proto/xudrpc.proto index bec029a9e..9ec3a5230 100644 --- a/proto/xudrpc.proto +++ b/proto/xudrpc.proto @@ -416,9 +416,11 @@ message Alert { AlertType type = 1 [json_name = "type"]; // The human readable alert message. string message = 2 [json_name = "message"]; + // The human readable alert message. + int64 date = 3 [json_name = "date"]; // The structured payload. oneof payload { - BalanceAlert balance_alert = 3 [json_name = "balance_alert"]; + BalanceAlert balance_alert = 4 [json_name = "balance_alert"]; } } diff --git a/test/simulation/xudrpc/xudrpc.pb.go b/test/simulation/xudrpc/xudrpc.pb.go index 3e2ac8c65..093f95fc0 100644 --- a/test/simulation/xudrpc/xudrpc.pb.go +++ b/test/simulation/xudrpc/xudrpc.pb.go @@ -336,6 +336,8 @@ type Alert struct { Type Alert_AlertType `protobuf:"varint,1,opt,name=type,proto3,enum=xudrpc.Alert_AlertType" json:"type,omitempty"` // The human readable alert message. Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + // The human readable alert message. + Date int64 `protobuf:"varint,3,opt,name=date,proto3" json:"date,omitempty"` // The structured payload. // // Types that are valid to be assigned to Payload: @@ -385,12 +387,19 @@ func (m *Alert) GetMessage() string { return "" } +func (m *Alert) GetDate() int64 { + if m != nil { + return m.Date + } + return 0 +} + type isAlert_Payload interface { isAlert_Payload() } type Alert_BalanceAlert struct { - BalanceAlert *BalanceAlert `protobuf:"bytes,3,opt,name=balance_alert,proto3,oneof"` + BalanceAlert *BalanceAlert `protobuf:"bytes,4,opt,name=balance_alert,proto3,oneof"` } func (*Alert_BalanceAlert) isAlert_Payload() {} @@ -5049,281 +5058,282 @@ func init() { func init() { proto.RegisterFile("xudrpc.proto", fileDescriptor_6960a02cc0a63cf6) } var fileDescriptor_6960a02cc0a63cf6 = []byte{ - // 4374 bytes of a gzipped FileDescriptorProto + // 4392 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x4d, 0x8f, 0x1c, 0x49, - 0x56, 0x9d, 0xf5, 0xd1, 0x55, 0xfd, 0xea, 0xb3, 0xa3, 0x3f, 0x5c, 0x53, 0xb6, 0x67, 0xbc, 0x81, - 0x3d, 0xf2, 0xd8, 0x33, 0xb6, 0xe9, 0x61, 0x99, 0x1d, 0xef, 0x7a, 0x34, 0xdd, 0xed, 0x5a, 0xdb, - 0x33, 0x35, 0xdd, 0x56, 0xb6, 0x3d, 0x36, 0x2b, 0xd8, 0x54, 0x56, 0x66, 0xb8, 0x3b, 0x71, 0x76, - 0x66, 0x4d, 0x66, 0x96, 0xdb, 0x0d, 0x17, 0xb4, 0xe2, 0x04, 0x42, 0x1c, 0x10, 0x67, 0x38, 0x21, - 0x24, 0x10, 0x57, 0x4e, 0x48, 0x9c, 0xb9, 0x72, 0x00, 0x01, 0x17, 0x24, 0x7e, 0x01, 0xe2, 0x8a, - 0x84, 0xe2, 0x2b, 0x23, 0x22, 0x33, 0xcb, 0x6b, 0x8f, 0x80, 0x4b, 0xab, 0xe2, 0xc5, 0xcb, 0xf7, - 0x22, 0xde, 0x57, 0xbc, 0x78, 0xf1, 0x1a, 0xba, 0xaf, 0x17, 0x7e, 0x32, 0xf7, 0x6e, 0xcd, 0x93, - 0x38, 0x8b, 0xd1, 0x2a, 0x1f, 0x8d, 0xd7, 0xdd, 0x28, 0x8a, 0x33, 0x37, 0x0b, 0xe2, 0x28, 0xe5, - 0x53, 0x78, 0x0b, 0x36, 0x76, 0x7d, 0x7f, 0x7f, 0x91, 0x24, 0x24, 0xf2, 0xce, 0x6d, 0x92, 0xce, - 0xe3, 0x28, 0x25, 0xf8, 0xe7, 0xd0, 0xdf, 0xf5, 0xfd, 0xc7, 0x6e, 0x90, 0xd8, 0xe4, 0xbb, 0x05, - 0x49, 0x33, 0x74, 0x15, 0x7a, 0x33, 0x37, 0x25, 0x8e, 0x27, 0x50, 0x47, 0xd6, 0x15, 0xeb, 0xfa, - 0x9a, 0x6d, 0x02, 0xd1, 0x87, 0xd0, 0xff, 0x6e, 0x11, 0x67, 0x1a, 0x5a, 0x8d, 0xa1, 0x15, 0xa0, - 0x78, 0x1d, 0x06, 0x39, 0x7d, 0xc1, 0xf2, 0xef, 0x2c, 0x68, 0xee, 0x86, 0x24, 0xc9, 0xd0, 0x4d, - 0x68, 0x64, 0xe7, 0x73, 0xc2, 0x38, 0xf4, 0x77, 0x2e, 0xdc, 0x12, 0x7b, 0x61, 0x93, 0xfc, 0xef, - 0x93, 0xf3, 0x39, 0xb1, 0x19, 0x12, 0x1a, 0x41, 0xeb, 0x94, 0xa4, 0xa9, 0x7b, 0x4c, 0x04, 0x2b, - 0x39, 0x44, 0x3f, 0xa1, 0x2b, 0x0e, 0xdd, 0xc8, 0x23, 0x8e, 0x4b, 0x3f, 0x1a, 0xd5, 0xaf, 0x58, - 0xd7, 0x3b, 0x3b, 0x9b, 0x92, 0xde, 0x1e, 0x9f, 0x64, 0x04, 0x1f, 0xae, 0xd8, 0x26, 0x32, 0xbe, - 0x0a, 0x6b, 0x39, 0x2b, 0x74, 0x01, 0x36, 0xa6, 0x87, 0xcf, 0x9c, 0x27, 0xf6, 0xee, 0xfd, 0x47, - 0x07, 0x0f, 0x9c, 0xbd, 0xdd, 0xe9, 0xee, 0xc1, 0xfe, 0x64, 0xb8, 0xb2, 0xb7, 0x06, 0xad, 0xb9, - 0x7b, 0x1e, 0xc6, 0xae, 0x8f, 0xff, 0xb6, 0x06, 0x2d, 0x41, 0x92, 0x0a, 0x2b, 0x8b, 0x33, 0x37, - 0x74, 0x04, 0x4d, 0xb6, 0x95, 0x86, 0x6d, 0x02, 0xd1, 0x75, 0x18, 0x78, 0x27, 0x6e, 0x14, 0x11, - 0x85, 0x57, 0x63, 0x78, 0x45, 0x30, 0xfa, 0x11, 0x5c, 0x98, 0x93, 0xc8, 0x0f, 0xa2, 0x63, 0xa7, - 0xf8, 0x45, 0x9d, 0x7d, 0xb1, 0x6c, 0x1a, 0xdd, 0x85, 0x51, 0x10, 0xb9, 0x5e, 0x16, 0xbc, 0x22, - 0xa5, 0x4f, 0x1b, 0xec, 0xd3, 0xa5, 0xf3, 0x54, 0x99, 0x67, 0x6e, 0x18, 0x92, 0x2c, 0xff, 0xa2, - 0xc9, 0xbe, 0x28, 0x40, 0xd1, 0x17, 0x30, 0x5e, 0x44, 0x5e, 0x1c, 0xbd, 0x08, 0x92, 0x53, 0xe2, - 0x3b, 0x85, 0x6f, 0x56, 0xd9, 0x37, 0x6f, 0xc0, 0xc0, 0xff, 0x6c, 0x41, 0x57, 0x57, 0xc6, 0x5b, - 0x8a, 0xef, 0x13, 0x68, 0xa4, 0x81, 0xcf, 0x65, 0xd6, 0xdf, 0x79, 0xaf, 0x4a, 0xad, 0xb7, 0x8e, - 0x02, 0x9f, 0xd8, 0x0c, 0x0d, 0x6d, 0x42, 0x73, 0x16, 0x2f, 0x22, 0x9f, 0x49, 0xac, 0x67, 0xf3, - 0x01, 0xc2, 0xd0, 0xa5, 0xb3, 0x05, 0x99, 0x18, 0x30, 0x34, 0x86, 0x76, 0x6e, 0xce, 0x4d, 0x66, - 0x63, 0xf9, 0x18, 0x5f, 0x86, 0x06, 0xe5, 0x81, 0x00, 0x56, 0xed, 0xc9, 0x37, 0x87, 0x4f, 0x26, - 0xc3, 0x15, 0xb4, 0x06, 0xcd, 0xe9, 0xe1, 0xfe, 0xee, 0x74, 0x68, 0xe1, 0x5f, 0x07, 0xd8, 0x73, - 0x23, 0xe9, 0x43, 0xd7, 0x61, 0x10, 0xc5, 0x3e, 0x71, 0x02, 0x9f, 0x44, 0x59, 0xf0, 0x22, 0x20, - 0x89, 0xf0, 0xa2, 0x22, 0x18, 0xf7, 0xa0, 0xc3, 0xbe, 0x13, 0xbe, 0xf1, 0x19, 0x34, 0xf7, 0x4f, - 0xdc, 0x20, 0xa2, 0x9b, 0xf0, 0xe8, 0x0f, 0xf1, 0x1d, 0x1f, 0x50, 0x1f, 0x88, 0x48, 0x76, 0x16, - 0x27, 0x2f, 0xa5, 0x0f, 0x88, 0x21, 0x9e, 0x43, 0x7b, 0x9f, 0x6b, 0x35, 0x45, 0xdb, 0xb0, 0xca, - 0x15, 0xcd, 0x3e, 0xee, 0xd9, 0x62, 0x44, 0xb7, 0x27, 0x4d, 0x80, 0x7d, 0xde, 0xb3, 0xf3, 0x31, - 0xa5, 0x2c, 0x2c, 0x4b, 0x88, 0x4d, 0x0e, 0x29, 0x35, 0x2f, 0x8c, 0x53, 0xe2, 0x33, 0x91, 0xf5, - 0x6c, 0x31, 0xc2, 0x0e, 0x6c, 0x51, 0x8e, 0xc7, 0xe4, 0xb1, 0x9b, 0xa6, 0x67, 0x71, 0xe2, 0xcb, - 0xcd, 0x63, 0xe8, 0x46, 0xe4, 0xcc, 0x99, 0x0b, 0xb0, 0xd8, 0x81, 0x01, 0xa3, 0x38, 0x71, 0xe8, - 0x2b, 0x1c, 0xbe, 0x1b, 0x03, 0x86, 0x47, 0xb0, 0x5d, 0x64, 0xa0, 0x22, 0xc8, 0xc6, 0x3e, 0x5d, - 0x85, 0xd8, 0xf2, 0x3b, 0x8b, 0xdd, 0xd0, 0x74, 0xcd, 0xd4, 0x34, 0x15, 0xfd, 0x8b, 0x38, 0x11, - 0x1e, 0xd7, 0xb6, 0xf9, 0x00, 0x5d, 0x81, 0x8e, 0x4f, 0xd2, 0x2c, 0x88, 0x58, 0x54, 0x65, 0xb2, - 0x58, 0xb3, 0x75, 0x10, 0x13, 0xfb, 0x69, 0xbc, 0x88, 0x32, 0xe1, 0x3d, 0x62, 0x84, 0x86, 0x50, - 0x7f, 0x41, 0xa4, 0x7b, 0xd0, 0x9f, 0xf8, 0x4b, 0xd8, 0x34, 0x97, 0xcf, 0xf7, 0x45, 0xd7, 0x9f, - 0x25, 0x6e, 0x94, 0x52, 0x9d, 0xc4, 0x91, 0x13, 0xf8, 0xe9, 0xc8, 0xba, 0x52, 0xa7, 0xeb, 0x2f, - 0x80, 0xf1, 0xc7, 0xd0, 0xdf, 0x8f, 0xa3, 0x88, 0x78, 0x99, 0xdc, 0xfb, 0x18, 0xda, 0x6c, 0x93, - 0x8b, 0x24, 0x10, 0x9b, 0xce, 0xc7, 0x34, 0x08, 0xe7, 0xd8, 0x42, 0x84, 0xb7, 0x61, 0x7d, 0x3f, - 0x21, 0x6e, 0x46, 0x0e, 0x62, 0x9f, 0x68, 0x34, 0x0a, 0x5a, 0xcb, 0xc7, 0xf8, 0x4f, 0x2d, 0x40, - 0xfa, 0x17, 0x62, 0xc9, 0xbf, 0x02, 0xbd, 0x94, 0x10, 0xdf, 0x39, 0x8d, 0xc8, 0x69, 0x1c, 0x05, - 0x9e, 0x58, 0x70, 0x97, 0x02, 0xbf, 0x11, 0x30, 0xf4, 0x11, 0x0c, 0x83, 0x28, 0xc8, 0x02, 0x37, - 0x0c, 0x7e, 0x87, 0xf8, 0x4e, 0x18, 0xf9, 0xe9, 0xa8, 0xc6, 0x37, 0xa6, 0xc1, 0xa7, 0x91, 0x9f, - 0xa2, 0xdb, 0xb0, 0xa1, 0xa3, 0x7a, 0x74, 0xd9, 0xaf, 0x33, 0xa1, 0x0a, 0xa4, 0x4d, 0xed, 0xf3, - 0x19, 0xfc, 0x4f, 0x16, 0xb4, 0xe5, 0xa9, 0x66, 0xa8, 0xd5, 0x2a, 0xa8, 0xf5, 0x1e, 0x74, 0xd2, - 0x33, 0x77, 0xee, 0x78, 0x61, 0x40, 0xa2, 0x4c, 0x04, 0x93, 0x8b, 0x32, 0x98, 0x48, 0x12, 0xb7, - 0x8e, 0xce, 0xdc, 0xf9, 0x3e, 0x43, 0xb1, 0x75, 0x7c, 0x1e, 0xaa, 0x5e, 0x92, 0xc8, 0x71, 0x7d, - 0x3f, 0x21, 0x69, 0xca, 0x96, 0xb4, 0x66, 0x9b, 0x40, 0x1a, 0x49, 0x7d, 0xe2, 0x05, 0xa7, 0x6e, - 0xe8, 0xcc, 0x43, 0xd7, 0x23, 0xa9, 0x70, 0x9a, 0x02, 0x14, 0x63, 0x00, 0xc5, 0x08, 0xb5, 0xa0, - 0x3e, 0x3d, 0xb8, 0x3f, 0x5c, 0x41, 0x1d, 0x68, 0xed, 0x1f, 0x1e, 0x1c, 0x4c, 0x9e, 0x3f, 0x19, - 0xd6, 0xa8, 0x8e, 0xef, 0x93, 0x79, 0x9c, 0x06, 0xba, 0x8e, 0x97, 0x6d, 0x0f, 0xdf, 0x84, 0x41, - 0x8e, 0x2d, 0x74, 0x33, 0x82, 0x96, 0x5c, 0x2c, 0xc7, 0x96, 0x43, 0x6a, 0x80, 0xf7, 0x83, 0xd4, - 0x8b, 0x5f, 0x91, 0x84, 0x6a, 0x33, 0x7d, 0xf7, 0xb8, 0xf5, 0x43, 0xd8, 0x2a, 0x50, 0x10, 0x4c, - 0x2f, 0xc1, 0x5a, 0xb4, 0x38, 0x75, 0x28, 0x7e, 0x2a, 0xe2, 0x8f, 0x02, 0xe0, 0x3f, 0xb0, 0x00, - 0x4d, 0x5e, 0x13, 0x6f, 0x91, 0x11, 0xba, 0x7f, 0x6d, 0x63, 0x71, 0xe2, 0x93, 0xc4, 0x09, 0x72, - 0xc3, 0x93, 0x63, 0x16, 0x99, 0xdc, 0x80, 0x4d, 0x89, 0x98, 0x27, 0x86, 0x34, 0x88, 0xcc, 0x09, - 0x49, 0x9c, 0xf9, 0x62, 0xe6, 0xbc, 0x24, 0xe7, 0x42, 0x23, 0x06, 0x8c, 0x52, 0xfe, 0x6e, 0xe1, - 0x46, 0x59, 0x90, 0x9d, 0x8b, 0x90, 0x9f, 0x8f, 0xa9, 0x0f, 0x3c, 0x20, 0x99, 0x38, 0x46, 0xde, - 0x46, 0xc6, 0x7f, 0x69, 0x01, 0xd2, 0xbf, 0x10, 0x5b, 0xbe, 0x0f, 0x6d, 0x71, 0x82, 0x70, 0x7f, - 0xed, 0xec, 0x5c, 0x97, 0x66, 0x55, 0xc6, 0x96, 0xc7, 0x56, 0x3a, 0x89, 0xb2, 0xe4, 0xdc, 0xce, - 0xbf, 0x1c, 0x4f, 0xa1, 0x67, 0x4c, 0xd1, 0xb8, 0x41, 0x77, 0xc5, 0x17, 0x41, 0x7f, 0xa2, 0x6b, - 0xd0, 0x7c, 0xe5, 0x86, 0x0b, 0x1e, 0xbd, 0x3b, 0x3b, 0x83, 0xc2, 0x49, 0x68, 0xf3, 0xd9, 0xbb, - 0xb5, 0x1f, 0x59, 0x78, 0x08, 0xfd, 0x07, 0x24, 0x7b, 0x14, 0xbd, 0x88, 0xc5, 0xc6, 0xf0, 0xbf, - 0xd4, 0x61, 0x90, 0x83, 0x94, 0x85, 0xbc, 0x22, 0x49, 0x4a, 0x03, 0x9a, 0xb0, 0x10, 0x31, 0x64, - 0x41, 0x9c, 0xaa, 0x5c, 0xca, 0x56, 0x04, 0x68, 0x1d, 0x86, 0x10, 0x34, 0x16, 0x49, 0x40, 0x3d, - 0x81, 0xba, 0x32, 0xfb, 0x2d, 0xd5, 0x4f, 0x75, 0x20, 0x6d, 0x5f, 0x01, 0xf2, 0x59, 0x37, 0x48, - 0x52, 0x16, 0x25, 0xe5, 0x2c, 0x05, 0xa0, 0x9b, 0xb0, 0xca, 0xb4, 0x9e, 0xb2, 0x58, 0xd9, 0xd9, - 0xd9, 0x90, 0xfb, 0x3b, 0x64, 0xd0, 0x7d, 0x1a, 0x4d, 0x6d, 0x81, 0x82, 0x76, 0xa0, 0x1e, 0x46, - 0xfe, 0xa8, 0xc5, 0xe4, 0x7d, 0x45, 0x93, 0xb7, 0xbe, 0xc1, 0x5b, 0xd3, 0xc8, 0xe7, 0x72, 0xa6, - 0xc8, 0x34, 0xb2, 0xbb, 0x61, 0xe0, 0xa6, 0xa3, 0x35, 0x7e, 0xa8, 0xb2, 0x81, 0x7e, 0xa8, 0x82, - 0x71, 0xa8, 0xa2, 0x3b, 0xb0, 0x21, 0xd3, 0x2d, 0x16, 0x0a, 0x4e, 0xdc, 0xf4, 0x84, 0xa4, 0xa3, - 0x0e, 0xdb, 0x6f, 0xd5, 0x14, 0xfa, 0x04, 0x5a, 0x32, 0x64, 0x75, 0xcd, 0x3d, 0x88, 0x78, 0xc5, - 0x56, 0x27, 0x71, 0xc6, 0x0f, 0xa0, 0x2d, 0x57, 0xf8, 0x0e, 0xea, 0x9e, 0x46, 0x3e, 0x23, 0xa3, - 0xa9, 0x7b, 0x93, 0x19, 0xa6, 0x0c, 0xb8, 0x52, 0xe5, 0x3f, 0x86, 0x0d, 0x03, 0x2a, 0xb4, 0x7e, - 0xb5, 0x3a, 0x66, 0x9b, 0x40, 0xfc, 0x05, 0x23, 0x49, 0x9d, 0x5b, 0xb3, 0xa2, 0x77, 0x88, 0x10, - 0x36, 0x63, 0xae, 0xbe, 0xcf, 0x0f, 0x8c, 0x41, 0x42, 0xe6, 0x0b, 0x7e, 0x39, 0x39, 0xf2, 0xe2, - 0x84, 0x67, 0x29, 0xeb, 0x36, 0x28, 0x30, 0x3d, 0x4a, 0x67, 0xf4, 0x68, 0xe4, 0x2e, 0xdf, 0xb6, - 0xc5, 0x08, 0x5f, 0x80, 0xad, 0x69, 0x90, 0x66, 0x22, 0x58, 0x07, 0x79, 0xe0, 0xc2, 0x5f, 0xc1, - 0x76, 0x71, 0x42, 0xf0, 0xbb, 0x03, 0xe0, 0xe5, 0x50, 0xe1, 0x9e, 0xc3, 0x62, 0xd4, 0xb7, 0x35, - 0x1c, 0xfc, 0x0f, 0x16, 0xac, 0x53, 0x62, 0xdc, 0xea, 0xe4, 0xc6, 0xb5, 0x30, 0x64, 0x99, 0x61, - 0xe8, 0x87, 0xd0, 0x8c, 0xcf, 0x22, 0x92, 0x88, 0x23, 0xe5, 0x83, 0x5c, 0x4d, 0x45, 0x1a, 0xb7, - 0x0e, 0x29, 0x9a, 0xcd, 0xb1, 0xa9, 0x31, 0x86, 0xc1, 0x69, 0x90, 0xc9, 0x34, 0x95, 0x0d, 0xa8, - 0x7c, 0x83, 0xc8, 0x0b, 0x17, 0x3e, 0xbd, 0x9e, 0x04, 0x6e, 0x2a, 0x4e, 0x90, 0xb6, 0x5d, 0x04, - 0xe3, 0xab, 0xd0, 0x64, 0xf4, 0x50, 0x1b, 0x1a, 0x7b, 0x87, 0x4f, 0x1e, 0x0e, 0x57, 0xe8, 0x39, - 0x72, 0xf8, 0xec, 0x60, 0x68, 0x51, 0xd0, 0xe3, 0xc9, 0xc4, 0x1e, 0xd6, 0xf0, 0x9f, 0x59, 0x80, - 0xf4, 0x85, 0x08, 0xa9, 0x7c, 0x91, 0xbb, 0x1a, 0x97, 0xc8, 0x87, 0x55, 0x8b, 0x16, 0x3e, 0xc4, - 0x87, 0xdc, 0x8d, 0xc4, 0x57, 0xe3, 0x47, 0xd0, 0xd1, 0xc0, 0x15, 0xb6, 0x7b, 0xd5, 0xb4, 0xdd, - 0xbe, 0xe9, 0xca, 0xba, 0xe9, 0x22, 0x18, 0x52, 0xa6, 0xf4, 0x8a, 0x98, 0xab, 0xf3, 0x23, 0xae, - 0x01, 0x01, 0x13, 0x6b, 0xde, 0x84, 0x26, 0x0f, 0x1c, 0xdc, 0x5c, 0xf9, 0x20, 0xff, 0x9c, 0x28, - 0x39, 0xe3, 0xcf, 0xc4, 0xe7, 0x44, 0xdf, 0x32, 0x86, 0x26, 0x8f, 0x4a, 0x7c, 0xc7, 0x5d, 0xb9, - 0x22, 0x8a, 0x65, 0xf3, 0x29, 0xfc, 0x6f, 0x16, 0xb4, 0x84, 0x77, 0x51, 0x1b, 0x4c, 0x33, 0x37, - 0x5b, 0xc8, 0xc3, 0x53, 0x8c, 0xd0, 0xc7, 0xd0, 0x16, 0xf7, 0xa7, 0x54, 0x6c, 0x4e, 0x99, 0x93, - 0x80, 0xdb, 0x39, 0x06, 0xba, 0x06, 0xab, 0x2c, 0x75, 0xe7, 0x51, 0xb2, 0xb3, 0xd3, 0xd3, 0x70, - 0x83, 0xc8, 0x16, 0x93, 0x34, 0xbb, 0x9c, 0x85, 0xb1, 0xf7, 0xf2, 0x84, 0x04, 0xc7, 0x27, 0x99, - 0x08, 0x9c, 0x3a, 0x28, 0x0f, 0xb6, 0x4d, 0x2d, 0xd8, 0x6a, 0xe1, 0x7b, 0xd5, 0x0c, 0xdf, 0x79, - 0xa4, 0x6b, 0x69, 0x91, 0x0e, 0x7f, 0x05, 0x7d, 0xe6, 0x8f, 0x2a, 0x0f, 0x2e, 0x86, 0x79, 0xab, - 0x22, 0xcc, 0xe7, 0xb4, 0x6a, 0x3a, 0xad, 0xbf, 0xb0, 0x00, 0x1d, 0xce, 0x49, 0xf4, 0x7f, 0x92, - 0x82, 0xab, 0x54, 0xba, 0x6e, 0xa4, 0xd2, 0x57, 0xa0, 0x33, 0x5f, 0xa4, 0x27, 0x8e, 0x98, 0xe4, - 0x07, 0xba, 0x0e, 0x92, 0xc9, 0x76, 0x53, 0x25, 0xdb, 0xf7, 0x60, 0xc3, 0x58, 0xa7, 0x30, 0x87, - 0x0f, 0xa1, 0x6f, 0x26, 0xd5, 0x62, 0x9d, 0x05, 0x28, 0xfe, 0xfb, 0x1a, 0x34, 0x99, 0xd1, 0x32, - 0xfb, 0x4b, 0x02, 0x71, 0x49, 0xb5, 0x6c, 0x3e, 0x30, 0x12, 0x8c, 0x9a, 0x99, 0x60, 0xe8, 0x31, - 0xa3, 0x6e, 0xc6, 0x8c, 0x3e, 0xd4, 0x02, 0x5f, 0x5c, 0x22, 0x6a, 0x81, 0x8f, 0xbe, 0x2c, 0x8b, - 0xad, 0xc9, 0x6c, 0x6b, 0x5b, 0xda, 0x8b, 0xa9, 0xb8, 0x4a, 0x71, 0x86, 0xb1, 0xe7, 0x86, 0x94, - 0x19, 0x37, 0x86, 0x7c, 0x8c, 0xde, 0x07, 0xf0, 0x58, 0xea, 0xee, 0x3b, 0x6e, 0xc6, 0x4c, 0xa2, - 0x61, 0x6b, 0x10, 0x74, 0x4d, 0x5c, 0xb0, 0xdb, 0x2c, 0x80, 0xad, 0x1b, 0xbe, 0xaa, 0x5d, 0xac, - 0x31, 0x74, 0x83, 0xd4, 0x89, 0xcf, 0x22, 0x87, 0x45, 0x01, 0x76, 0x8a, 0xb6, 0x6d, 0x03, 0x46, - 0xcd, 0xf4, 0x24, 0x0e, 0x7d, 0x76, 0x92, 0x36, 0x6c, 0xf6, 0x1b, 0xff, 0xb9, 0x05, 0x5d, 0x46, - 0xcb, 0x26, 0xa7, 0xf1, 0x2b, 0x37, 0x34, 0x64, 0x66, 0x2d, 0x97, 0x59, 0x21, 0xdd, 0xd3, 0x93, - 0xc4, 0x7a, 0x21, 0x49, 0xd4, 0x77, 0xdf, 0x28, 0xec, 0xbe, 0xb8, 0xec, 0x66, 0x79, 0xd9, 0xf8, - 0x04, 0x56, 0x79, 0x64, 0x42, 0x9f, 0x00, 0xcc, 0x16, 0xe7, 0x8e, 0x11, 0x1d, 0x7b, 0x86, 0x44, - 0x6c, 0x0d, 0x01, 0xdd, 0x86, 0x4e, 0x4a, 0xc2, 0x50, 0xe2, 0xd7, 0xaa, 0xf0, 0x75, 0x0c, 0xfc, - 0xa9, 0x8c, 0x9c, 0x2c, 0x9d, 0xa1, 0xf2, 0xa2, 0xa1, 0x47, 0x64, 0xca, 0xec, 0x37, 0xb5, 0xe1, - 0xf8, 0x2c, 0x12, 0x57, 0x74, 0xfa, 0x13, 0xff, 0xc2, 0x12, 0x5f, 0x3d, 0x9d, 0xfb, 0x6e, 0x46, - 0x68, 0x66, 0xc0, 0xf7, 0x62, 0x31, 0x23, 0x31, 0xf9, 0x3d, 0x5c, 0xb1, 0xf9, 0x2c, 0xfa, 0x09, - 0xf4, 0xb8, 0x84, 0x12, 0x2e, 0x78, 0x11, 0xaf, 0x36, 0xcd, 0xe5, 0xf1, 0xb9, 0x87, 0x2b, 0xb6, - 0x89, 0xbc, 0xd7, 0x87, 0x2e, 0x07, 0x2c, 0x18, 0x53, 0xfc, 0xaf, 0x35, 0x68, 0xd0, 0x60, 0xb9, - 0xfc, 0x5e, 0xf1, 0x56, 0x59, 0xe3, 0x97, 0xd0, 0x0d, 0x23, 0x5f, 0x0e, 0x65, 0x5c, 0xbc, 0xa4, - 0x87, 0x63, 0x9a, 0xe1, 0x3c, 0x5e, 0xcc, 0xbe, 0x26, 0xe7, 0xe2, 0xd8, 0x31, 0xbe, 0xa0, 0xfc, - 0x83, 0x88, 0x97, 0x78, 0xf8, 0xd9, 0x28, 0x87, 0xea, 0x88, 0x68, 0x6a, 0x47, 0x04, 0x8d, 0x1a, - 0xaf, 0x17, 0xbe, 0x63, 0x86, 0x4a, 0x1d, 0x84, 0x3e, 0x86, 0xf5, 0x94, 0x78, 0x71, 0xe4, 0xa7, - 0xfc, 0xc6, 0xe9, 0x65, 0xc4, 0x67, 0x7e, 0xd2, 0xb3, 0xcb, 0x13, 0xd5, 0x69, 0xe4, 0xf8, 0x1e, - 0x0c, 0x0a, 0xcb, 0xae, 0x38, 0x16, 0x37, 0xf5, 0x63, 0x71, 0x4d, 0x3f, 0x06, 0x7f, 0xaf, 0x06, - 0xeb, 0x8f, 0xe9, 0xe5, 0x50, 0x28, 0x85, 0x87, 0xd3, 0xff, 0xcd, 0x98, 0xa3, 0xfb, 0x4f, 0xa3, - 0xe0, 0x3f, 0x32, 0x02, 0x34, 0xdf, 0x1c, 0x01, 0x6e, 0xc0, 0x30, 0x21, 0xec, 0x0a, 0xeb, 0xe4, - 0xa4, 0xb8, 0x38, 0x4b, 0x70, 0x9a, 0x3c, 0x07, 0xa7, 0xa7, 0xc4, 0x0f, 0xdc, 0x8c, 0x42, 0x1d, - 0x8f, 0x5e, 0x51, 0x42, 0x26, 0xd5, 0xb6, 0x5d, 0x35, 0x45, 0x45, 0x80, 0x74, 0x11, 0x88, 0x48, - 0xfd, 0x39, 0x0c, 0x83, 0x28, 0x23, 0x49, 0xe4, 0x86, 0xce, 0xa9, 0x9b, 0x79, 0x27, 0x64, 0x89, - 0x5f, 0x96, 0xd0, 0xd0, 0x8f, 0xa1, 0xcf, 0xb2, 0xf3, 0x74, 0xe1, 0x79, 0x24, 0xa5, 0xc9, 0x14, - 0x77, 0xd0, 0x3c, 0x2b, 0xa7, 0x97, 0xd0, 0x23, 0x3e, 0x69, 0x17, 0x50, 0xd1, 0x67, 0x34, 0x53, - 0x3d, 0x75, 0x83, 0x88, 0x26, 0xf9, 0xdc, 0xdd, 0xea, 0x15, 0xee, 0x66, 0x17, 0xb1, 0xd0, 0xe7, - 0xd0, 0x63, 0xa4, 0x5e, 0xb8, 0x41, 0xb8, 0x48, 0x58, 0x06, 0x57, 0x62, 0xfa, 0x53, 0x3e, 0x67, - 0x9b, 0x98, 0xf8, 0x3f, 0x2d, 0x18, 0x28, 0x11, 0x4c, 0x5e, 0x91, 0x88, 0x46, 0xe7, 0x26, 0xdb, - 0xcf, 0x52, 0x67, 0x67, 0xb3, 0xe8, 0x73, 0xe8, 0xea, 0x1b, 0x10, 0xbe, 0x5e, 0xb5, 0xd3, 0x87, - 0x2b, 0xb6, 0x81, 0x8a, 0x3e, 0x7f, 0xbb, 0x9d, 0x3e, 0x5c, 0xa9, 0xda, 0x6b, 0x57, 0xdf, 0x01, - 0x33, 0xac, 0xea, 0xad, 0xe6, 0x5c, 0x05, 0xea, 0x5e, 0x0b, 0x9a, 0x84, 0x6e, 0x10, 0xc7, 0xd0, - 0xd1, 0x6e, 0x47, 0x4b, 0x13, 0x2f, 0x2d, 0xec, 0xd4, 0xcc, 0xb0, 0xa3, 0xe5, 0x41, 0x8d, 0x52, - 0x1e, 0xc4, 0xcb, 0xa8, 0x4d, 0xad, 0x8c, 0x8a, 0x3f, 0x85, 0x2d, 0x16, 0xf5, 0x88, 0x7a, 0x0e, - 0xf9, 0xe5, 0x97, 0xff, 0x11, 0x6c, 0x17, 0x3f, 0x12, 0xb5, 0xb4, 0x29, 0x20, 0x3e, 0x63, 0xb8, - 0xee, 0x9b, 0x6a, 0x1a, 0x6f, 0x70, 0x60, 0xfc, 0x57, 0x16, 0x6c, 0x18, 0xe4, 0x84, 0x1b, 0xbc, - 0x0f, 0x43, 0x89, 0xe3, 0xc4, 0x91, 0xc3, 0x4e, 0x59, 0x4b, 0x9d, 0xb2, 0xe8, 0x16, 0x20, 0xa5, - 0x9c, 0x02, 0xf5, 0x8a, 0x19, 0xee, 0xcb, 0x94, 0x8d, 0xaf, 0xb0, 0x79, 0xb6, 0x55, 0x82, 0xeb, - 0x41, 0xa5, 0x61, 0x04, 0x15, 0x25, 0x95, 0xdd, 0x30, 0x34, 0x2e, 0x3b, 0x78, 0x01, 0x17, 0x4a, - 0x33, 0x62, 0x2b, 0x1f, 0xc3, 0xba, 0x64, 0x21, 0x45, 0x22, 0xb3, 0xfa, 0xf2, 0x04, 0xc5, 0x16, - 0xfb, 0xd5, 0xb0, 0x79, 0xf9, 0xb0, 0x3c, 0x81, 0x3f, 0x81, 0x75, 0xce, 0x56, 0x7f, 0xd3, 0x5a, - 0x7a, 0x79, 0xa3, 0x17, 0x67, 0x1d, 0x5d, 0x68, 0xf4, 0xf7, 0x6b, 0x14, 0x9c, 0x66, 0x71, 0x62, - 0xd4, 0x47, 0xdf, 0xaa, 0xd8, 0xa9, 0x17, 0x51, 0x6b, 0x66, 0x11, 0x15, 0x7d, 0x0d, 0x1d, 0x7a, - 0x92, 0xcd, 0x5c, 0xef, 0xe5, 0x62, 0x2e, 0x8f, 0xbe, 0x1b, 0xd2, 0x59, 0xca, 0x1c, 0xe9, 0x41, - 0xb8, 0xc7, 0x91, 0xf9, 0x41, 0x08, 0x61, 0x0e, 0x40, 0x3f, 0x60, 0x8f, 0x7f, 0x8e, 0xef, 0x66, - 0xee, 0xcc, 0x4d, 0x79, 0x81, 0xb9, 0xcb, 0xce, 0xb5, 0xfb, 0x02, 0x24, 0xce, 0x24, 0x9d, 0xc2, - 0x2f, 0x3b, 0x93, 0xba, 0xfa, 0x99, 0x44, 0xa8, 0x25, 0x6a, 0x6b, 0x52, 0x35, 0xdf, 0x84, 0x83, - 0x45, 0x2d, 0x57, 0x88, 0x41, 0x02, 0x59, 0x21, 0xf7, 0x23, 0x6a, 0x5e, 0x02, 0x49, 0x96, 0x44, - 0xf8, 0x65, 0x7e, 0x20, 0xe1, 0xb2, 0x84, 0x7b, 0x1f, 0xd0, 0x11, 0xc9, 0xa6, 0xf1, 0xf1, 0x94, - 0xbc, 0x52, 0x37, 0x89, 0x5b, 0xb0, 0x16, 0xc6, 0xc7, 0x4e, 0x48, 0x61, 0xe2, 0x85, 0x30, 0xbf, - 0x68, 0xe5, 0xb8, 0x0a, 0x05, 0x6f, 0xc1, 0x86, 0x41, 0x45, 0xa8, 0x72, 0x1d, 0x06, 0x47, 0x27, - 0x8b, 0xcc, 0x8f, 0xcf, 0xe4, 0xeb, 0x0c, 0xbd, 0x32, 0x2a, 0x90, 0x40, 0xfb, 0x35, 0xd8, 0x3e, - 0x5a, 0xcc, 0x52, 0x2f, 0x09, 0x66, 0xc4, 0xbc, 0xf8, 0x8f, 0xa1, 0x4d, 0x5e, 0x07, 0x69, 0x16, - 0x44, 0xc7, 0x6c, 0x19, 0x6d, 0x3b, 0x1f, 0x53, 0xeb, 0xcf, 0xbf, 0x62, 0xef, 0x50, 0xb9, 0xf5, - 0x7f, 0x00, 0x97, 0xf3, 0x19, 0x1a, 0x04, 0xd3, 0x5d, 0xcf, 0x23, 0xf3, 0x8c, 0xc8, 0x57, 0x12, - 0x7c, 0x0f, 0xb6, 0x4c, 0x04, 0xed, 0xfd, 0x55, 0x5e, 0xf5, 0x33, 0xf7, 0xa5, 0xc8, 0xf1, 0xda, - 0xb6, 0x09, 0xc4, 0xff, 0x5d, 0x83, 0x2e, 0xfd, 0x4c, 0x92, 0x45, 0xef, 0x95, 0xc2, 0x4d, 0x8b, - 0x8d, 0x1f, 0x99, 0xc9, 0x71, 0xad, 0x90, 0x1c, 0xbf, 0x31, 0x5d, 0x58, 0x56, 0x39, 0x55, 0x69, - 0x49, 0x53, 0x4f, 0x4b, 0x8a, 0xf5, 0xd8, 0xd5, 0x8a, 0x7a, 0xec, 0x36, 0xac, 0x26, 0xac, 0x58, - 0x26, 0x6e, 0xa6, 0x62, 0x44, 0xa3, 0x11, 0xbf, 0xc1, 0x39, 0x09, 0xf1, 0x48, 0xf0, 0x8a, 0x4a, - 0xbb, 0xcd, 0xa3, 0x51, 0x11, 0x4e, 0xaf, 0x6e, 0x02, 0x96, 0x8a, 0x27, 0xab, 0x35, 0xfe, 0x5c, - 0x69, 0x42, 0x69, 0x44, 0x94, 0xd1, 0x5b, 0xa3, 0xca, 0x6b, 0x7c, 0x15, 0x33, 0x74, 0x0d, 0x39, - 0x54, 0x52, 0xee, 0xf0, 0xec, 0xa6, 0x08, 0xa7, 0x51, 0xba, 0xa3, 0x1d, 0x6e, 0xdf, 0xb3, 0x82, - 0xad, 0xcb, 0xb8, 0x5e, 0x90, 0x71, 0x51, 0x9a, 0x8d, 0x0a, 0x69, 0x7e, 0x08, 0x7d, 0x71, 0x9a, - 0x3a, 0x09, 0x71, 0xd3, 0x58, 0x9e, 0x73, 0x05, 0x28, 0xfe, 0x9b, 0x3a, 0x5f, 0xad, 0x48, 0x00, - 0xfe, 0x7f, 0x8d, 0x45, 0xa9, 0xbc, 0x69, 0xa8, 0xfc, 0x3a, 0x0c, 0x0c, 0xd5, 0x12, 0x5f, 0x68, - 0xbc, 0x08, 0xa6, 0x09, 0xbc, 0x52, 0x6d, 0x26, 0xb4, 0xad, 0x83, 0x4a, 0xc2, 0x82, 0x0a, 0x61, - 0x5d, 0x81, 0x46, 0x12, 0x87, 0x84, 0xa9, 0xb4, 0xaf, 0xea, 0x3f, 0x76, 0x1c, 0x12, 0x9b, 0xcd, - 0xd0, 0x93, 0xa6, 0x60, 0x16, 0xc4, 0x67, 0x75, 0xdc, 0x35, 0xbb, 0x3c, 0x41, 0x1d, 0x55, 0x37, - 0x8b, 0x6c, 0xd4, 0xe3, 0x2f, 0x42, 0x06, 0x90, 0xde, 0xbd, 0x13, 0x67, 0x9e, 0x90, 0xe0, 0xd4, - 0x3d, 0x26, 0xa3, 0x3e, 0x43, 0xd1, 0x20, 0xca, 0x95, 0x06, 0x9a, 0x2b, 0xe1, 0xff, 0xaa, 0x41, - 0xf3, 0x49, 0xe2, 0xfa, 0x84, 0x5e, 0x30, 0x4f, 0xa9, 0xc7, 0x3b, 0xcb, 0x2f, 0x7c, 0xb6, 0x8e, - 0x41, 0x3f, 0xc8, 0xb4, 0x0f, 0x6a, 0x95, 0x1f, 0x68, 0x18, 0x9a, 0x7e, 0xea, 0x86, 0x7e, 0xde, - 0xa4, 0x53, 0xcd, 0x12, 0x9a, 0xa6, 0x25, 0xe4, 0xfb, 0x59, 0xd5, 0x43, 0x83, 0x94, 0x7d, 0x6b, - 0xa9, 0xec, 0xaf, 0x40, 0x87, 0xf0, 0x87, 0x21, 0x56, 0xa4, 0xe0, 0x96, 0xa0, 0x83, 0xf2, 0x3b, - 0xca, 0xda, 0x9b, 0xef, 0x28, 0x77, 0xa1, 0xeb, 0x51, 0xc3, 0x20, 0xc9, 0xdc, 0x4d, 0x32, 0x6e, - 0x0a, 0xcb, 0xeb, 0x28, 0x06, 0x2e, 0xbe, 0x09, 0x1b, 0x4c, 0xea, 0x0f, 0x03, 0x7a, 0x42, 0x9d, - 0x6b, 0xb7, 0x30, 0x5e, 0xaa, 0xb5, 0xb4, 0x52, 0x2d, 0xbe, 0x07, 0x9b, 0x26, 0xb2, 0x38, 0x1e, - 0xaf, 0xc1, 0x6a, 0x46, 0xe1, 0xa5, 0x5b, 0x0a, 0xc3, 0xb6, 0xc5, 0x24, 0xfe, 0x63, 0x0b, 0x7a, - 0x14, 0x12, 0x44, 0xc7, 0x53, 0x4a, 0x2f, 0xa5, 0x02, 0x3f, 0x75, 0x5f, 0x3b, 0x29, 0x09, 0x43, - 0x59, 0x16, 0x91, 0x63, 0xd6, 0xfd, 0xe2, 0xbe, 0x76, 0x66, 0x0b, 0x99, 0xd2, 0xc9, 0x21, 0x35, - 0xc3, 0x84, 0xa4, 0x24, 0xa1, 0x49, 0x13, 0xfb, 0x94, 0x07, 0x12, 0x13, 0x48, 0x1d, 0x24, 0x07, - 0x50, 0x22, 0xa2, 0xfd, 0x41, 0x87, 0xe1, 0x1d, 0xbe, 0xa1, 0x7c, 0x41, 0x6f, 0x93, 0x15, 0xff, - 0xb5, 0x05, 0x5b, 0x85, 0x8f, 0x84, 0x18, 0x76, 0x61, 0x95, 0xc9, 0x49, 0x8a, 0xe1, 0x23, 0x5d, - 0x0c, 0x25, 0xf4, 0x5b, 0x7c, 0x28, 0xaa, 0xcc, 0xfc, 0xc3, 0xf1, 0x63, 0xe8, 0x68, 0xe0, 0x8a, - 0xd4, 0xe5, 0xa6, 0x59, 0x65, 0xde, 0xaa, 0x66, 0xa1, 0x65, 0x34, 0xdf, 0x42, 0xf7, 0x69, 0x34, - 0xfb, 0x1e, 0x8d, 0x1a, 0xe8, 0x12, 0xac, 0x25, 0x44, 0xd4, 0x00, 0x44, 0x22, 0xa3, 0x00, 0x78, - 0x00, 0x3d, 0x41, 0x57, 0xbd, 0xaf, 0x3f, 0x8d, 0xc2, 0xd8, 0x7b, 0xf9, 0xb6, 0xef, 0xeb, 0x3f, - 0x03, 0xa4, 0x7f, 0xa0, 0x52, 0xad, 0x05, 0x83, 0x16, 0x52, 0x2d, 0x09, 0x64, 0xa9, 0xd6, 0x07, - 0xd0, 0xd1, 0x51, 0xf8, 0x73, 0x1c, 0x28, 0x04, 0xfc, 0x87, 0x16, 0x0c, 0x9e, 0x05, 0xd9, 0x89, - 0x9f, 0xb8, 0x67, 0x6f, 0xa1, 0xd4, 0x62, 0xaf, 0x43, 0xed, 0x4d, 0xbd, 0x0e, 0xf5, 0x62, 0xaf, - 0x83, 0x1b, 0x86, 0xa2, 0x2c, 0x43, 0x7f, 0xea, 0x05, 0xd9, 0x1e, 0x2f, 0xc8, 0xde, 0x85, 0xa1, - 0x5a, 0xcc, 0xbb, 0x55, 0x63, 0x6f, 0x5c, 0x87, 0xb5, 0xdc, 0xdf, 0x51, 0x0b, 0xea, 0x7b, 0x4f, - 0x7f, 0x63, 0xb8, 0x82, 0xda, 0xd0, 0x38, 0x9a, 0x4c, 0xa7, 0xfc, 0xe1, 0x83, 0xbd, 0x85, 0xd4, - 0x6e, 0xdc, 0x80, 0x06, 0x8d, 0x2e, 0x68, 0x0d, 0x9a, 0x4f, 0x76, 0xbf, 0x9e, 0xd8, 0xbc, 0x5d, - 0xe7, 0x1b, 0xf6, 0xd3, 0x42, 0x5d, 0x68, 0x3f, 0x3a, 0x78, 0x32, 0xb1, 0x0f, 0x76, 0xa7, 0xc3, - 0xda, 0x8d, 0x67, 0xd0, 0x96, 0x79, 0x23, 0x45, 0xda, 0x9d, 0x4e, 0xec, 0x27, 0x1c, 0x7f, 0x62, - 0xdb, 0x87, 0x36, 0xa7, 0xfb, 0x6c, 0xd7, 0x3e, 0x18, 0xd6, 0xe8, 0xaf, 0x47, 0x07, 0x3f, 0x3d, - 0x1c, 0xd6, 0x51, 0x07, 0x5a, 0xdf, 0x4e, 0xec, 0xbd, 0xc3, 0xa3, 0xc9, 0xb0, 0x41, 0x71, 0xef, - 0x4f, 0xf6, 0x9e, 0x3e, 0x18, 0x36, 0x19, 0x47, 0x7b, 0x77, 0x7f, 0x32, 0x5c, 0xdd, 0xf9, 0x77, - 0x0b, 0x5a, 0xcf, 0x17, 0xfe, 0xa3, 0x28, 0xc8, 0xd0, 0x04, 0x40, 0xf5, 0x4f, 0xa0, 0xbc, 0x8b, - 0xa9, 0xd4, 0x85, 0x31, 0x1e, 0x57, 0x4d, 0x09, 0xb3, 0x5a, 0x41, 0x0f, 0xa1, 0xa3, 0xe5, 0xe4, - 0x68, 0xbc, 0xfc, 0xf2, 0x30, 0xbe, 0x58, 0x39, 0x97, 0x53, 0x9a, 0x00, 0x28, 0x8b, 0x53, 0x0b, - 0x2a, 0x99, 0xad, 0x5a, 0x50, 0xd9, 0x40, 0xf1, 0xca, 0xce, 0x1f, 0x5d, 0x84, 0xfa, 0xf3, 0x85, - 0x8f, 0x9e, 0x43, 0x47, 0x6b, 0x30, 0x44, 0xa5, 0x37, 0x36, 0xb5, 0x9c, 0xaa, 0x3e, 0xc4, 0xf1, - 0x2f, 0xfe, 0xf1, 0x3f, 0xfe, 0xa4, 0xb6, 0x89, 0x07, 0xb7, 0x5f, 0xfd, 0xea, 0x6d, 0xd7, 0xf7, - 0xa5, 0x2d, 0xde, 0xb5, 0x6e, 0x20, 0x1b, 0x5a, 0xa2, 0x87, 0x10, 0x6d, 0x6b, 0x34, 0xb4, 0x0b, - 0xde, 0xf8, 0x42, 0x09, 0x2e, 0xe8, 0x6e, 0x33, 0xba, 0x43, 0xdc, 0x11, 0x74, 0xe9, 0x31, 0x45, - 0x69, 0xee, 0x41, 0x7d, 0xcf, 0x8d, 0x10, 0x52, 0x4f, 0xe8, 0x32, 0x26, 0x8c, 0x37, 0x0c, 0x98, - 0xa0, 0x83, 0x18, 0x9d, 0x2e, 0x6e, 0x51, 0x3a, 0x33, 0x37, 0xa2, 0x34, 0x8e, 0xa1, 0x6f, 0x36, - 0x28, 0xa1, 0xcb, 0xfa, 0x4b, 0x50, 0xa9, 0x33, 0x6a, 0xfc, 0xfe, 0xb2, 0xe9, 0xc2, 0x62, 0xfb, - 0x94, 0x89, 0xc7, 0x70, 0x68, 0x7c, 0x40, 0x1e, 0x74, 0xf5, 0x7e, 0x21, 0xa4, 0xba, 0x56, 0xca, - 0x4d, 0x50, 0xe3, 0x4b, 0xd5, 0x93, 0x82, 0xc5, 0x88, 0xb1, 0x40, 0x78, 0xc8, 0x58, 0x50, 0x0c, - 0xf1, 0x54, 0x45, 0xa5, 0x2c, 0x9a, 0x84, 0x94, 0x94, 0xcd, 0x1e, 0x23, 0x25, 0xe5, 0x62, 0x37, - 0x91, 0x21, 0x65, 0x11, 0x13, 0xa9, 0x84, 0x7e, 0x0e, 0xbd, 0x67, 0xac, 0x05, 0x50, 0xb4, 0xa6, - 0x28, 0xca, 0x66, 0x67, 0x8b, 0xa2, 0x5c, 0xe8, 0x61, 0xc1, 0x97, 0x18, 0xe5, 0x6d, 0xbc, 0x4e, - 0x29, 0xf3, 0x76, 0x42, 0x9f, 0xa3, 0x08, 0xcb, 0xf8, 0xde, 0x94, 0x8d, 0x35, 0x6b, 0x34, 0x7f, - 0x1b, 0x7a, 0x46, 0x67, 0x0b, 0xca, 0x05, 0x5a, 0xd5, 0x32, 0x33, 0xbe, 0xbc, 0x64, 0xb6, 0x6a, - 0xfd, 0xbe, 0x40, 0x61, 0xbd, 0x30, 0x94, 0xd7, 0x73, 0x00, 0xd5, 0x21, 0xa2, 0x5c, 0xb0, 0xd4, - 0x95, 0xa2, 0x5c, 0xb0, 0xdc, 0x50, 0x82, 0x37, 0x18, 0x8b, 0x1e, 0xea, 0x70, 0xd3, 0xe4, 0xb4, - 0xa6, 0xd0, 0x12, 0xbd, 0x10, 0x4a, 0x32, 0x66, 0x43, 0x88, 0x92, 0x4c, 0xa1, 0x69, 0x02, 0x0f, - 0x19, 0x41, 0x40, 0x6d, 0x4a, 0x30, 0xa0, 0x24, 0x7e, 0x13, 0x3a, 0x5a, 0x23, 0x01, 0xd2, 0x57, - 0x53, 0xe8, 0x39, 0x50, 0x5e, 0x5e, 0xd1, 0x79, 0x80, 0x37, 0x19, 0xe5, 0x3e, 0xea, 0x52, 0xca, - 0xb2, 0x8a, 0x22, 0xa8, 0xcb, 0x4e, 0x01, 0x83, 0x7a, 0xa1, 0xfd, 0xc0, 0xa0, 0x5e, 0x6c, 0x2d, - 0x30, 0xa9, 0x53, 0x19, 0xb3, 0xb5, 0x3f, 0x03, 0x50, 0x8f, 0xda, 0x4a, 0xc6, 0xa5, 0xd7, 0x79, - 0x25, 0xe3, 0xf2, 0x1b, 0xb8, 0x74, 0x7f, 0x04, 0x94, 0xb4, 0x78, 0xfa, 0x39, 0x86, 0xbe, 0xd9, - 0x73, 0xa0, 0xdc, 0xbf, 0xb2, 0x49, 0x41, 0xb9, 0x7f, 0x75, 0xab, 0x82, 0xb4, 0x48, 0xc4, 0xdd, - 0x5f, 0x91, 0x3d, 0x82, 0xb5, 0xfc, 0x35, 0x1c, 0x8d, 0x74, 0x22, 0xfa, 0xa3, 0xf9, 0xf8, 0xbd, - 0x8a, 0x19, 0x59, 0x04, 0x61, 0x94, 0x3b, 0x68, 0x8d, 0x52, 0xe6, 0x8f, 0x22, 0x92, 0x28, 0xeb, - 0xcb, 0x31, 0x89, 0x6a, 0x4f, 0xe9, 0x05, 0xa2, 0xfa, 0x83, 0x7a, 0x81, 0x28, 0xa3, 0xe3, 0x40, - 0x47, 0x7b, 0x6b, 0x55, 0x9a, 0x2c, 0x3f, 0x14, 0x2b, 0x4d, 0x56, 0x3c, 0xce, 0xe2, 0x0b, 0x8c, - 0xf4, 0x3a, 0x3f, 0x0d, 0xe2, 0x39, 0x89, 0x64, 0x90, 0xfa, 0x2d, 0x00, 0x55, 0x1e, 0x57, 0xca, - 0x2c, 0x3d, 0x9c, 0x28, 0xe3, 0x2e, 0x54, 0xd3, 0xf1, 0x7b, 0x8c, 0xf4, 0x06, 0x8f, 0xb1, 0xec, - 0xc9, 0x82, 0xa9, 0xf3, 0xae, 0x75, 0xe3, 0x8e, 0x85, 0x5e, 0x40, 0x5f, 0xe1, 0x1f, 0x9d, 0x47, - 0xde, 0x9b, 0x58, 0x8c, 0xab, 0xa6, 0xc4, 0x06, 0x2e, 0x33, 0x2e, 0x17, 0x30, 0x32, 0xb9, 0xa4, - 0xe7, 0x91, 0x47, 0xfd, 0xfe, 0x67, 0xd0, 0xd1, 0xba, 0xe0, 0x94, 0x9c, 0xca, 0xad, 0x71, 0xe3, - 0xaa, 0x02, 0xbe, 0x79, 0x5a, 0x8a, 0x3b, 0x52, 0x7a, 0xe6, 0xce, 0x29, 0xed, 0x08, 0xfa, 0x66, - 0x9d, 0x5a, 0x99, 0x65, 0x65, 0xd1, 0x5b, 0x99, 0xe5, 0x92, 0xf2, 0xb6, 0xb1, 0x17, 0x5e, 0x9e, - 0xd5, 0x4f, 0xe7, 0x19, 0x4d, 0x48, 0xf2, 0x72, 0xb5, 0x9e, 0x90, 0x14, 0x4b, 0xe2, 0x7a, 0x42, - 0x52, 0xaa, 0x6f, 0x9b, 0x7b, 0xe2, 0x6c, 0xa4, 0x66, 0x50, 0x02, 0x83, 0x42, 0x2d, 0x19, 0x15, - 0x56, 0x5d, 0x2c, 0x3f, 0x8f, 0x3f, 0x58, 0x3a, 0x2f, 0xf8, 0xbd, 0xcf, 0xf8, 0x8d, 0xf0, 0x86, - 0xe2, 0xe7, 0x86, 0x21, 0x57, 0x13, 0x3f, 0xbb, 0x40, 0x55, 0x86, 0x95, 0x1d, 0x94, 0x8a, 0xcb, - 0xe3, 0x71, 0xd5, 0x94, 0x60, 0x62, 0x58, 0x1b, 0x67, 0x22, 0x33, 0x90, 0x19, 0x74, 0xb4, 0x7a, - 0xa5, 0x92, 0x5b, 0xb9, 0x14, 0xaa, 0xe4, 0x56, 0x55, 0xe0, 0x34, 0xe4, 0x96, 0x92, 0x2c, 0x8c, - 0x8f, 0x59, 0x41, 0x94, 0xf2, 0xf8, 0x16, 0xda, 0xb2, 0xd2, 0x89, 0x72, 0x8f, 0x28, 0x94, 0x43, - 0xc7, 0xa3, 0xf2, 0x44, 0xc1, 0x0d, 0x59, 0x40, 0x4d, 0xc5, 0x2c, 0xa5, 0xeb, 0xc0, 0xa0, 0x50, - 0xf7, 0x54, 0xfa, 0xa8, 0x2e, 0x88, 0x8e, 0x7b, 0xc6, 0x7f, 0x77, 0xe0, 0x8b, 0x8c, 0xf4, 0x16, - 0x62, 0xd2, 0x4f, 0xe5, 0x27, 0xec, 0x3f, 0x32, 0xd2, 0x3b, 0x16, 0x22, 0x1a, 0x83, 0xa2, 0xc2, - 0xab, 0xeb, 0xb4, 0x63, 0xb3, 0x5b, 0x90, 0x3f, 0x94, 0x2f, 0x61, 0xc3, 0x95, 0x7c, 0xc7, 0x42, - 0xf3, 0x42, 0x11, 0x56, 0x54, 0xf3, 0xb4, 0x48, 0x5e, 0x59, 0xa3, 0x1d, 0x57, 0xbd, 0x6f, 0xe1, - 0x1f, 0x30, 0x5e, 0x17, 0xd1, 0x7b, 0x06, 0x2f, 0xea, 0x96, 0xf2, 0x79, 0xef, 0x8e, 0x85, 0x66, - 0xd0, 0x37, 0x49, 0xbe, 0x13, 0xab, 0x82, 0xff, 0x23, 0x54, 0x62, 0x45, 0x79, 0xfc, 0xae, 0x56, - 0x95, 0x36, 0x6a, 0xcf, 0xe8, 0x5a, 0x35, 0xaf, 0x42, 0x6d, 0x7a, 0xbc, 0xa9, 0xf3, 0x94, 0x93, - 0x18, 0x33, 0xa6, 0x97, 0xd0, 0xb8, 0xcc, 0xd4, 0x15, 0x38, 0x2c, 0x84, 0x76, 0xf5, 0xaa, 0x88, - 0xca, 0x55, 0x2b, 0x0a, 0x2b, 0x2a, 0x57, 0xad, 0x2a, 0xa4, 0x48, 0xe5, 0xf1, 0x5c, 0x95, 0x55, - 0x4d, 0x4e, 0x38, 0x06, 0x4f, 0xbe, 0x0b, 0xd5, 0x93, 0x4b, 0x4b, 0xea, 0x0b, 0x85, 0x34, 0xad, - 0xb2, 0xfa, 0x20, 0xfd, 0x14, 0xad, 0x4b, 0x56, 0x41, 0x74, 0xcc, 0x8b, 0x10, 0xe8, 0x2b, 0x68, - 0xb2, 0xab, 0x3d, 0xda, 0x54, 0xd7, 0x20, 0x55, 0x41, 0x18, 0x6f, 0x15, 0xa0, 0x66, 0x2e, 0x82, - 0xd9, 0xe1, 0xb8, 0x88, 0xc4, 0x8d, 0x61, 0x06, 0x7d, 0x9e, 0x0f, 0xcb, 0x0b, 0xb0, 0xf2, 0xca, - 0xc2, 0xfd, 0x5c, 0x79, 0x65, 0xf1, 0xae, 0x6c, 0xc6, 0x63, 0x9e, 0x12, 0x9f, 0x09, 0x9c, 0xbb, - 0xd6, 0x8d, 0xd9, 0x2a, 0xfb, 0x7f, 0xaf, 0x4f, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0x59, 0x5f, - 0xf3, 0xd1, 0x1a, 0x36, 0x00, 0x00, + 0x56, 0x9d, 0xf5, 0xd1, 0x55, 0xfd, 0xea, 0xa3, 0xab, 0xa3, 0x3f, 0x5c, 0x2e, 0xdb, 0x33, 0xde, + 0xc0, 0x1e, 0x79, 0xec, 0x19, 0xdb, 0xf4, 0xb0, 0xcc, 0x8e, 0x77, 0x3d, 0x9a, 0xee, 0x76, 0xad, + 0xed, 0x99, 0x9a, 0x6e, 0x2b, 0xdb, 0x1e, 0x9b, 0x15, 0x6c, 0x2a, 0x2b, 0x33, 0xdc, 0x9d, 0x38, + 0x3b, 0xb3, 0x26, 0x33, 0xcb, 0xed, 0x86, 0x0b, 0x5a, 0x71, 0x02, 0x21, 0x0e, 0x88, 0x33, 0x9c, + 0x10, 0x12, 0x88, 0x2b, 0x27, 0x24, 0xce, 0xdc, 0x10, 0x07, 0x10, 0x70, 0x41, 0xe2, 0x17, 0x20, + 0xae, 0x48, 0x28, 0xbe, 0x32, 0x22, 0x32, 0xb3, 0x7a, 0xec, 0x11, 0xec, 0xa5, 0x55, 0xf1, 0xe2, + 0xe5, 0x7b, 0x11, 0xef, 0x2b, 0x5e, 0xbc, 0x78, 0x0d, 0xdd, 0x37, 0x73, 0x3f, 0x99, 0x79, 0xb7, + 0x67, 0x49, 0x9c, 0xc5, 0x68, 0x99, 0x8f, 0x46, 0x6b, 0x6e, 0x14, 0xc5, 0x99, 0x9b, 0x05, 0x71, + 0x94, 0xf2, 0x29, 0xbc, 0x09, 0xeb, 0x3b, 0xbe, 0xbf, 0x37, 0x4f, 0x12, 0x12, 0x79, 0x67, 0x36, + 0x49, 0x67, 0x71, 0x94, 0x12, 0xfc, 0x73, 0xe8, 0xef, 0xf8, 0xfe, 0x13, 0x37, 0x48, 0x6c, 0xf2, + 0xed, 0x9c, 0xa4, 0x19, 0xba, 0x06, 0xbd, 0xa9, 0x9b, 0x12, 0xc7, 0x13, 0xa8, 0x43, 0xeb, 0xaa, + 0x75, 0x63, 0xc5, 0x36, 0x81, 0xe8, 0x03, 0xe8, 0x7f, 0x3b, 0x8f, 0x33, 0x0d, 0xad, 0xc6, 0xd0, + 0x0a, 0x50, 0xbc, 0x06, 0xab, 0x39, 0x7d, 0xc1, 0xf2, 0x1f, 0x2d, 0x68, 0xee, 0x84, 0x24, 0xc9, + 0xd0, 0x2d, 0x68, 0x64, 0x67, 0x33, 0xc2, 0x38, 0xf4, 0xb7, 0x2f, 0xdc, 0x16, 0x7b, 0x61, 0x93, + 0xfc, 0xef, 0xd3, 0xb3, 0x19, 0xb1, 0x19, 0x12, 0x1a, 0x42, 0xeb, 0x84, 0xa4, 0xa9, 0x7b, 0x44, + 0x04, 0x2b, 0x39, 0x44, 0x08, 0x1a, 0xbe, 0x9b, 0x91, 0x61, 0xfd, 0xaa, 0x75, 0xa3, 0x6e, 0xb3, + 0xdf, 0xe8, 0x27, 0x74, 0x17, 0xa1, 0x1b, 0x79, 0xc4, 0x71, 0x29, 0xa1, 0x61, 0xe3, 0xaa, 0x75, + 0xa3, 0xb3, 0xbd, 0x21, 0x79, 0xec, 0xf2, 0x49, 0xc6, 0xe4, 0xd1, 0x92, 0x6d, 0x22, 0xe3, 0x6b, + 0xb0, 0x92, 0xb3, 0x47, 0x17, 0x60, 0x7d, 0x72, 0xf0, 0xdc, 0x79, 0x6a, 0xef, 0x3c, 0x78, 0xbc, + 0xff, 0xd0, 0xd9, 0xdd, 0x99, 0xec, 0xec, 0xef, 0x8d, 0x07, 0x4b, 0xbb, 0x2b, 0xd0, 0x9a, 0xb9, + 0x67, 0x61, 0xec, 0xfa, 0xf8, 0x6f, 0x6b, 0xd0, 0x12, 0x24, 0xa9, 0x00, 0xb3, 0x38, 0x73, 0x43, + 0x47, 0xd0, 0x64, 0xdb, 0x6b, 0xd8, 0x26, 0x10, 0xdd, 0x80, 0x55, 0xef, 0xd8, 0x8d, 0x22, 0xa2, + 0xf0, 0x6a, 0x0c, 0xaf, 0x08, 0x46, 0x3f, 0x82, 0x0b, 0x33, 0x12, 0xf9, 0x41, 0x74, 0xe4, 0x14, + 0xbf, 0xa8, 0xb3, 0x2f, 0x16, 0x4d, 0xa3, 0x7b, 0x30, 0x0c, 0x22, 0xd7, 0xcb, 0x82, 0xd7, 0xa4, + 0xf4, 0x69, 0x83, 0x7d, 0xba, 0x70, 0x9e, 0x2a, 0xf8, 0xd4, 0x0d, 0x43, 0x92, 0xe5, 0x5f, 0x34, + 0xd9, 0x17, 0x05, 0x28, 0xfa, 0x1c, 0x46, 0xf3, 0xc8, 0x8b, 0xa3, 0x97, 0x41, 0x72, 0x42, 0x7c, + 0xa7, 0xf0, 0xcd, 0x32, 0xfb, 0xe6, 0x1c, 0x0c, 0xfc, 0x2f, 0x16, 0x74, 0x75, 0x65, 0xbc, 0xa5, + 0xf8, 0x3e, 0x86, 0x46, 0x1a, 0xf8, 0x5c, 0x66, 0xfd, 0xed, 0x8b, 0x55, 0x6a, 0xbd, 0x7d, 0x18, + 0xf8, 0xc4, 0x66, 0x68, 0x68, 0x03, 0x9a, 0xd3, 0x78, 0x1e, 0xf9, 0x4c, 0x62, 0x3d, 0x9b, 0x0f, + 0x10, 0x86, 0x2e, 0x9d, 0x2d, 0xc8, 0xc4, 0x80, 0xa1, 0x11, 0xb4, 0x73, 0x13, 0x6f, 0x32, 0xbb, + 0xcb, 0xc7, 0xf8, 0x0a, 0x34, 0x28, 0x0f, 0x04, 0xb0, 0x6c, 0x8f, 0xbf, 0x3e, 0x78, 0x3a, 0x1e, + 0x2c, 0xa1, 0x15, 0x68, 0x4e, 0x0e, 0xf6, 0x76, 0x26, 0x03, 0x0b, 0xff, 0x3a, 0xc0, 0xae, 0x1b, + 0x49, 0xbf, 0xba, 0x01, 0xab, 0x51, 0xec, 0x13, 0x27, 0xf0, 0x49, 0x94, 0x05, 0x2f, 0x03, 0x92, + 0x08, 0xcf, 0x2a, 0x82, 0x71, 0x0f, 0x3a, 0xec, 0x3b, 0xe1, 0x2f, 0x9f, 0x42, 0x73, 0xef, 0xd8, + 0x0d, 0x22, 0xba, 0x09, 0x8f, 0xfe, 0x10, 0xdf, 0xf1, 0x01, 0xf5, 0x8b, 0x88, 0x64, 0xa7, 0x71, + 0xf2, 0x4a, 0xfa, 0x85, 0x18, 0xe2, 0x19, 0xb4, 0xf7, 0xb8, 0x56, 0x53, 0xb4, 0x05, 0xcb, 0x5c, + 0xd1, 0xec, 0xe3, 0x9e, 0x2d, 0x46, 0x74, 0x7b, 0xd2, 0x04, 0xd8, 0xe7, 0x3d, 0x3b, 0x1f, 0x53, + 0xca, 0xc2, 0xb2, 0x84, 0xd8, 0xe4, 0x90, 0x52, 0xf3, 0xc2, 0x38, 0x25, 0x3e, 0x13, 0x59, 0xcf, + 0x16, 0x23, 0xec, 0xc0, 0x26, 0xe5, 0x78, 0x44, 0x9e, 0xb8, 0x69, 0x7a, 0x1a, 0x27, 0xbe, 0xdc, + 0x3c, 0x86, 0x6e, 0x44, 0x4e, 0x9d, 0x99, 0x00, 0x8b, 0x1d, 0x18, 0x30, 0x8a, 0x13, 0x87, 0xbe, + 0xc2, 0xe1, 0xbb, 0x31, 0x60, 0x78, 0x08, 0x5b, 0x45, 0x06, 0x42, 0x4a, 0x7f, 0x67, 0xc1, 0xfa, + 0x1e, 0x5d, 0x85, 0xd8, 0xf2, 0x3b, 0x8b, 0xdd, 0xd0, 0x74, 0xcd, 0xd4, 0x34, 0x15, 0xfd, 0xcb, + 0x38, 0x11, 0x1e, 0xd7, 0xb6, 0xf9, 0x00, 0x5d, 0x85, 0x8e, 0x4f, 0xd2, 0x2c, 0x88, 0x58, 0xa4, + 0x65, 0xb2, 0x58, 0xb1, 0x75, 0x10, 0x13, 0xfb, 0x49, 0x3c, 0x8f, 0x32, 0xe1, 0x3d, 0x62, 0x84, + 0x06, 0x50, 0x7f, 0x49, 0xa4, 0x7b, 0xd0, 0x9f, 0xf8, 0x0b, 0xd8, 0x30, 0x97, 0xcf, 0xf7, 0x45, + 0xd7, 0x9f, 0x25, 0x6e, 0x94, 0x52, 0x9d, 0xc4, 0x91, 0x13, 0xf8, 0xe9, 0xd0, 0xba, 0x5a, 0xa7, + 0xeb, 0x2f, 0x80, 0xf1, 0x47, 0xd0, 0xdf, 0x8b, 0xa3, 0x88, 0x78, 0x99, 0xdc, 0xfb, 0x08, 0xda, + 0x6c, 0x93, 0xf3, 0x24, 0x10, 0x9b, 0xce, 0xc7, 0x34, 0x30, 0xe7, 0xd8, 0x42, 0x84, 0x77, 0x60, + 0x6d, 0x2f, 0x21, 0x6e, 0x46, 0xf6, 0x63, 0x9f, 0x68, 0x34, 0x0a, 0x5a, 0xcb, 0xc7, 0xf8, 0x4f, + 0x2d, 0x40, 0xfa, 0x17, 0x62, 0xc9, 0xbf, 0x02, 0xbd, 0x94, 0x10, 0xdf, 0x39, 0x89, 0xc8, 0x49, + 0x1c, 0x05, 0x9e, 0x58, 0x70, 0x97, 0x02, 0xbf, 0x16, 0x30, 0xf4, 0x21, 0x0c, 0x82, 0x28, 0xc8, + 0x02, 0x37, 0x0c, 0x7e, 0x87, 0xf8, 0x4e, 0x18, 0xf9, 0xe9, 0xb0, 0xc6, 0x37, 0xa6, 0xc1, 0x27, + 0x91, 0x9f, 0xa2, 0x3b, 0xb0, 0xae, 0xa3, 0x7a, 0x74, 0xd9, 0x6f, 0x32, 0xa1, 0x0a, 0xa4, 0x4d, + 0xed, 0xf1, 0x19, 0xfc, 0xcf, 0x16, 0xb4, 0xe5, 0x49, 0x67, 0xa8, 0xd5, 0x2a, 0xa8, 0xf5, 0x3e, + 0x74, 0xd2, 0x53, 0x77, 0xe6, 0x78, 0x61, 0x40, 0xa2, 0x4c, 0x04, 0x93, 0x4b, 0x32, 0x98, 0x48, + 0x12, 0xb7, 0x0f, 0x4f, 0xdd, 0xd9, 0x1e, 0x43, 0xb1, 0x75, 0x7c, 0x1e, 0xaa, 0x5e, 0x91, 0xc8, + 0x71, 0x7d, 0x3f, 0x21, 0x69, 0xca, 0x96, 0xb4, 0x62, 0x9b, 0x40, 0x1a, 0x49, 0x7d, 0xe2, 0x05, + 0x27, 0x6e, 0xe8, 0xcc, 0x42, 0xd7, 0x23, 0xa9, 0x70, 0x9a, 0x02, 0x14, 0x63, 0x00, 0xc5, 0x08, + 0xb5, 0xa0, 0x3e, 0xd9, 0x7f, 0x30, 0x58, 0x42, 0x1d, 0x68, 0xed, 0x1d, 0xec, 0xef, 0x8f, 0x5f, + 0x3c, 0x1d, 0xd4, 0xa8, 0x8e, 0x1f, 0x90, 0x59, 0x9c, 0x06, 0xba, 0x8e, 0x17, 0x6d, 0x0f, 0xdf, + 0x82, 0xd5, 0x1c, 0x5b, 0xe8, 0x66, 0x08, 0x2d, 0xb9, 0x58, 0x8e, 0x2d, 0x87, 0xd4, 0x00, 0x1f, + 0x04, 0xa9, 0x17, 0xbf, 0x26, 0x09, 0xd5, 0x66, 0xfa, 0xee, 0x71, 0xeb, 0x87, 0xb0, 0x59, 0xa0, + 0x20, 0x98, 0x5e, 0x86, 0x95, 0x68, 0x7e, 0xe2, 0x50, 0xfc, 0x54, 0xc4, 0x1f, 0x05, 0xc0, 0x7f, + 0x60, 0x01, 0x1a, 0xbf, 0x21, 0xde, 0x3c, 0x23, 0x74, 0xff, 0xda, 0xc6, 0xe2, 0xc4, 0x27, 0x89, + 0x13, 0xe4, 0x86, 0x27, 0xc7, 0x2c, 0x32, 0xb9, 0x01, 0x9b, 0x12, 0x31, 0x4f, 0x0c, 0x69, 0x10, + 0x99, 0x11, 0x92, 0x38, 0xb3, 0xf9, 0xd4, 0x79, 0x45, 0xce, 0x84, 0x46, 0x0c, 0x18, 0xa5, 0xfc, + 0xed, 0xdc, 0x8d, 0xb2, 0x20, 0x3b, 0x13, 0x21, 0x3f, 0x1f, 0x53, 0x1f, 0x78, 0x48, 0x32, 0x71, + 0x8c, 0xbc, 0x8d, 0x8c, 0xff, 0xd2, 0x02, 0xa4, 0x7f, 0x21, 0xb6, 0xfc, 0x00, 0xda, 0xe2, 0x04, + 0xe1, 0xfe, 0xda, 0xd9, 0xbe, 0x21, 0xcd, 0xaa, 0x8c, 0x2d, 0x8f, 0xad, 0x74, 0x1c, 0x65, 0xc9, + 0x99, 0x9d, 0x7f, 0x39, 0x9a, 0x40, 0xcf, 0x98, 0xa2, 0x71, 0x83, 0xee, 0x8a, 0x2f, 0x82, 0xfe, + 0x44, 0xd7, 0xa1, 0xf9, 0xda, 0x0d, 0xe7, 0x3c, 0x7a, 0x77, 0xb6, 0x57, 0x0b, 0x27, 0xa1, 0xcd, + 0x67, 0xef, 0xd5, 0x7e, 0x64, 0xe1, 0x01, 0xf4, 0x1f, 0x92, 0xec, 0x71, 0xf4, 0x32, 0x16, 0x1b, + 0xc3, 0xff, 0x5a, 0x87, 0xd5, 0x1c, 0xa4, 0x2c, 0xe4, 0x35, 0x49, 0x52, 0x1a, 0xd0, 0x84, 0x85, + 0x88, 0x21, 0x0b, 0xe2, 0x54, 0xe5, 0x52, 0xb6, 0x22, 0x40, 0xeb, 0x30, 0x9a, 0x8b, 0xcd, 0x93, + 0x80, 0x7a, 0x02, 0x75, 0x65, 0xf6, 0x5b, 0xaa, 0x9f, 0xea, 0x40, 0xda, 0xbe, 0x02, 0xe4, 0xb3, + 0x6e, 0x90, 0xa4, 0x2c, 0x4a, 0xca, 0x59, 0x0a, 0x40, 0xb7, 0x60, 0x99, 0x69, 0x3d, 0x65, 0xb1, + 0xb2, 0xb3, 0xbd, 0x2e, 0xf7, 0x77, 0xc0, 0xa0, 0x7b, 0x34, 0x9a, 0xda, 0x02, 0x05, 0x6d, 0x43, + 0x3d, 0x8c, 0xfc, 0x61, 0x8b, 0xc9, 0xfb, 0xaa, 0x26, 0x6f, 0x7d, 0x83, 0xb7, 0x27, 0x91, 0xcf, + 0xe5, 0x4c, 0x91, 0x69, 0x64, 0x77, 0xc3, 0xc0, 0x4d, 0x87, 0x2b, 0xfc, 0x50, 0x65, 0x03, 0xfd, + 0x50, 0x05, 0xe3, 0x50, 0x45, 0x77, 0x61, 0x5d, 0xa6, 0x5b, 0x2c, 0x14, 0x1c, 0xbb, 0xe9, 0x31, + 0x49, 0x87, 0x1d, 0xb6, 0xdf, 0xaa, 0x29, 0xf4, 0x31, 0xb4, 0x64, 0xc8, 0xea, 0x9a, 0x7b, 0x10, + 0xf1, 0x8a, 0xad, 0x4e, 0xe2, 0x8c, 0x1e, 0x42, 0x5b, 0xae, 0xf0, 0x1d, 0xd4, 0x3d, 0x89, 0x7c, + 0x46, 0x46, 0x53, 0xf7, 0x06, 0x33, 0x4c, 0x19, 0x70, 0xa5, 0xca, 0x7f, 0x0c, 0xeb, 0x06, 0x54, + 0x68, 0xfd, 0x5a, 0x75, 0xcc, 0x36, 0x81, 0xf8, 0x73, 0x46, 0x92, 0x3a, 0xb7, 0x66, 0x45, 0xef, + 0x10, 0x21, 0x6c, 0xc6, 0x5c, 0x7d, 0x9f, 0x1f, 0x18, 0xab, 0x09, 0x99, 0xcd, 0xf9, 0x85, 0xe5, + 0xd0, 0x8b, 0x13, 0x9e, 0xa5, 0xac, 0xd9, 0xa0, 0xc0, 0xf4, 0x28, 0x9d, 0xd2, 0xa3, 0x91, 0xbb, + 0x7c, 0xdb, 0x16, 0x23, 0x7c, 0x01, 0x36, 0x27, 0x41, 0x9a, 0x89, 0x60, 0x1d, 0xe4, 0x81, 0x0b, + 0x7f, 0x09, 0x5b, 0xc5, 0x09, 0xc1, 0xef, 0x2e, 0x80, 0x97, 0x43, 0x85, 0x7b, 0x0e, 0x8a, 0x51, + 0xdf, 0xd6, 0x70, 0xf0, 0x3f, 0x58, 0xb0, 0x46, 0x89, 0x71, 0xab, 0x93, 0x1b, 0xd7, 0xc2, 0x90, + 0x65, 0x86, 0xa1, 0x1f, 0x42, 0x33, 0x3e, 0x8d, 0x48, 0x22, 0x8e, 0x94, 0xf7, 0x73, 0x35, 0x15, + 0x69, 0xdc, 0x3e, 0xa0, 0x68, 0x36, 0xc7, 0xa6, 0xc6, 0x18, 0x06, 0x27, 0x41, 0x26, 0xd3, 0x54, + 0x36, 0xa0, 0xf2, 0x0d, 0x22, 0x2f, 0x9c, 0xfb, 0xf4, 0x7a, 0x12, 0xb8, 0xa9, 0x38, 0x41, 0xda, + 0x76, 0x11, 0x8c, 0xaf, 0x41, 0x93, 0xd1, 0x43, 0x6d, 0x68, 0xec, 0x1e, 0x3c, 0x7d, 0x34, 0x58, + 0xa2, 0xe7, 0xc8, 0xc1, 0xf3, 0xfd, 0x81, 0x45, 0x41, 0x4f, 0xc6, 0x63, 0x7b, 0x50, 0xc3, 0x7f, + 0x66, 0x01, 0xd2, 0x17, 0x22, 0xa4, 0xf2, 0x79, 0xee, 0x6a, 0x5c, 0x22, 0x1f, 0x54, 0x2d, 0x5a, + 0xf8, 0x10, 0x1f, 0x72, 0x37, 0x12, 0x5f, 0x8d, 0x1e, 0x43, 0x47, 0x03, 0x57, 0xd8, 0xee, 0x35, + 0xd3, 0x76, 0xfb, 0xa6, 0x2b, 0xeb, 0xa6, 0x8b, 0x60, 0x40, 0x99, 0xd2, 0x6b, 0x63, 0xae, 0xce, + 0x0f, 0xb9, 0x06, 0x04, 0x4c, 0xac, 0x79, 0x03, 0x9a, 0x3c, 0x70, 0x70, 0x73, 0xe5, 0x83, 0xfc, + 0x73, 0xa2, 0xe4, 0x8c, 0x3f, 0x15, 0x9f, 0x13, 0x7d, 0xcb, 0x18, 0x9a, 0x3c, 0x2a, 0xf1, 0x1d, + 0x77, 0xe5, 0x8a, 0x28, 0x96, 0xcd, 0xa7, 0xf0, 0xbf, 0x5b, 0xd0, 0x12, 0xde, 0x45, 0x6d, 0x30, + 0xcd, 0xdc, 0x6c, 0x2e, 0x0f, 0x4f, 0x31, 0x42, 0x1f, 0x41, 0x5b, 0xdc, 0x9f, 0x52, 0xb1, 0x39, + 0x65, 0x4e, 0x02, 0x6e, 0xe7, 0x18, 0xe8, 0x3a, 0x2c, 0xb3, 0xd4, 0x9d, 0x47, 0xc9, 0xce, 0x76, + 0x4f, 0xc3, 0x0d, 0x22, 0x5b, 0x4c, 0xd2, 0xec, 0x72, 0x1a, 0xc6, 0xde, 0xab, 0x63, 0x12, 0x1c, + 0x1d, 0x67, 0x22, 0x70, 0xea, 0xa0, 0x3c, 0xd8, 0x36, 0xb5, 0x60, 0xab, 0x85, 0xef, 0x65, 0x33, + 0x7c, 0xe7, 0x91, 0xae, 0xa5, 0x45, 0x3a, 0xfc, 0x25, 0xf4, 0x99, 0x3f, 0xaa, 0x3c, 0xb8, 0x18, + 0xe6, 0xad, 0x8a, 0x30, 0x9f, 0xd3, 0xaa, 0xe9, 0xb4, 0xfe, 0xc2, 0x02, 0x74, 0x30, 0x23, 0xd1, + 0xff, 0x4b, 0x0a, 0xae, 0x52, 0xe9, 0xba, 0x91, 0x4a, 0x5f, 0x85, 0xce, 0x6c, 0x9e, 0x1e, 0x3b, + 0x62, 0x92, 0x1f, 0xe8, 0x3a, 0x48, 0x26, 0xdb, 0x4d, 0x95, 0x6c, 0xdf, 0x87, 0x75, 0x63, 0x9d, + 0xc2, 0x1c, 0x3e, 0x80, 0xbe, 0x99, 0x54, 0x8b, 0x75, 0x16, 0xa0, 0xf8, 0xef, 0x6b, 0xd0, 0x64, + 0x46, 0xcb, 0xec, 0x2f, 0x09, 0xc4, 0x25, 0xd5, 0xb2, 0xf9, 0xc0, 0x48, 0x30, 0x6a, 0x66, 0x82, + 0xa1, 0xc7, 0x8c, 0xba, 0x19, 0x33, 0xfa, 0x50, 0x0b, 0x7c, 0x71, 0x89, 0xa8, 0x05, 0x3e, 0xfa, + 0xa2, 0x2c, 0xb6, 0x26, 0xb3, 0xad, 0x2d, 0x69, 0x2f, 0xa6, 0xe2, 0x2a, 0xc5, 0x19, 0xc6, 0x9e, + 0x1b, 0x52, 0x66, 0xdc, 0x18, 0xf2, 0x31, 0x7a, 0x0f, 0xc0, 0x63, 0xa9, 0xbb, 0xef, 0xb8, 0x19, + 0x33, 0x89, 0x86, 0xad, 0x41, 0xd0, 0x75, 0x71, 0xc1, 0x6e, 0xb3, 0x00, 0xb6, 0x66, 0xf8, 0xaa, + 0x76, 0xb1, 0xc6, 0xd0, 0x0d, 0x52, 0x27, 0x3e, 0x8d, 0x1c, 0x16, 0x05, 0xd8, 0x29, 0xda, 0xb6, + 0x0d, 0x18, 0x35, 0xd3, 0xe3, 0x38, 0xf4, 0xd9, 0x49, 0xda, 0xb0, 0xd9, 0x6f, 0xfc, 0xe7, 0x16, + 0x74, 0x19, 0x2d, 0x9b, 0x9c, 0xc4, 0xaf, 0xdd, 0xd0, 0x90, 0x99, 0xb5, 0x58, 0x66, 0x85, 0x74, + 0x4f, 0x4f, 0x12, 0xeb, 0x85, 0x24, 0x51, 0xdf, 0x7d, 0xa3, 0xb0, 0xfb, 0xe2, 0xb2, 0x9b, 0xe5, + 0x65, 0xe3, 0x63, 0x58, 0xe6, 0x91, 0x09, 0x7d, 0x0c, 0x30, 0x9d, 0x9f, 0x39, 0x46, 0x74, 0xec, + 0x19, 0x12, 0xb1, 0x35, 0x04, 0x74, 0x07, 0x3a, 0x29, 0x09, 0x43, 0x89, 0x5f, 0xab, 0xc2, 0xd7, + 0x31, 0xf0, 0x27, 0x32, 0x72, 0xb2, 0x74, 0x86, 0xca, 0x8b, 0x86, 0x1e, 0x91, 0x29, 0xb3, 0xdf, + 0xd4, 0x86, 0xe3, 0xd3, 0x48, 0x5c, 0xd1, 0xe9, 0x4f, 0xfc, 0x0b, 0x4b, 0x7c, 0xf5, 0x6c, 0xc6, + 0x2a, 0x5e, 0xd7, 0xa1, 0xc9, 0xf7, 0x62, 0x31, 0x23, 0x31, 0xf9, 0x3d, 0x5a, 0xb2, 0xf9, 0x2c, + 0xfa, 0x09, 0xf4, 0xb8, 0x84, 0x12, 0x2e, 0x78, 0x11, 0xaf, 0x36, 0xcc, 0xe5, 0xf1, 0xb9, 0x47, + 0x4b, 0xb6, 0x89, 0xbc, 0xdb, 0x87, 0x2e, 0x07, 0xcc, 0x19, 0x53, 0xfc, 0x6f, 0x35, 0x68, 0xd0, + 0x60, 0xb9, 0xf8, 0x5e, 0xf1, 0x56, 0x59, 0xe3, 0x17, 0xd0, 0x0d, 0x23, 0x5f, 0x0e, 0x65, 0x5c, + 0xbc, 0xac, 0x87, 0x63, 0x9a, 0xe1, 0x3c, 0x99, 0x4f, 0xbf, 0x22, 0x67, 0xe2, 0xd8, 0x31, 0xbe, + 0xa0, 0xfc, 0x83, 0x88, 0x97, 0x78, 0xf8, 0xd9, 0x28, 0x87, 0xea, 0x88, 0x68, 0x6a, 0x47, 0x04, + 0x8d, 0x1a, 0x6f, 0xe6, 0xbe, 0x63, 0x86, 0x4a, 0x1d, 0x84, 0x3e, 0x82, 0xb5, 0x94, 0x78, 0x71, + 0xe4, 0xa7, 0xfc, 0xc6, 0xe9, 0x65, 0xc4, 0x67, 0x7e, 0xd2, 0xb3, 0xcb, 0x13, 0xd5, 0x69, 0xe4, + 0xe8, 0x3e, 0xac, 0x16, 0x96, 0x5d, 0x71, 0x2c, 0x6e, 0xe8, 0xc7, 0xe2, 0x8a, 0x7e, 0x0c, 0xfe, + 0x5e, 0x0d, 0xd6, 0x9e, 0xd0, 0xcb, 0xa1, 0x50, 0x0a, 0x0f, 0xa7, 0xff, 0x97, 0x31, 0x47, 0xf7, + 0x9f, 0x46, 0xc1, 0x7f, 0x64, 0x04, 0x68, 0x9e, 0x1f, 0x01, 0x6e, 0xc2, 0x20, 0x21, 0xec, 0x0a, + 0xeb, 0xe4, 0xa4, 0xb8, 0x38, 0x4b, 0x70, 0x9a, 0x3c, 0x07, 0x27, 0x27, 0xc4, 0x0f, 0xdc, 0x8c, + 0x42, 0x1d, 0x8f, 0x5e, 0x51, 0x42, 0x26, 0xd5, 0xb6, 0x5d, 0x35, 0x45, 0x45, 0x80, 0x74, 0x11, + 0x88, 0x48, 0xfd, 0x19, 0x0c, 0x82, 0x28, 0x23, 0x49, 0xe4, 0x86, 0xce, 0x89, 0x9b, 0x79, 0xc7, + 0x64, 0x81, 0x5f, 0x96, 0xd0, 0xd0, 0x8f, 0xa1, 0xcf, 0xb2, 0xf3, 0x74, 0xee, 0x79, 0x24, 0xa5, + 0xc9, 0x14, 0x77, 0xd0, 0x3c, 0x2b, 0xa7, 0x97, 0xd0, 0x43, 0x3e, 0x69, 0x17, 0x50, 0xd1, 0xa7, + 0x34, 0x53, 0x3d, 0x71, 0x83, 0x88, 0x26, 0xf9, 0xdc, 0xdd, 0xea, 0x15, 0xee, 0x66, 0x17, 0xb1, + 0xd0, 0x67, 0xd0, 0x63, 0xa4, 0x5e, 0xba, 0x41, 0x38, 0x4f, 0x58, 0x06, 0x57, 0x62, 0xfa, 0x53, + 0x3e, 0x67, 0x9b, 0x98, 0xf8, 0xbf, 0x2c, 0x58, 0x55, 0x22, 0x18, 0xbf, 0x26, 0x11, 0x8d, 0xce, + 0x4d, 0xb6, 0x9f, 0x85, 0xce, 0xce, 0x66, 0xd1, 0x67, 0xd0, 0xd5, 0x37, 0x20, 0x7c, 0xbd, 0x6a, + 0xa7, 0x8f, 0x96, 0x6c, 0x03, 0x15, 0x7d, 0xf6, 0x76, 0x3b, 0x7d, 0xb4, 0x54, 0xb5, 0xd7, 0xae, + 0xbe, 0x03, 0x51, 0x7a, 0xaf, 0xda, 0x6a, 0xce, 0x55, 0xa0, 0xee, 0xb6, 0xa0, 0x49, 0xe8, 0x06, + 0x71, 0x0c, 0x1d, 0xed, 0x76, 0xb4, 0x30, 0xf1, 0xd2, 0xc2, 0x4e, 0xcd, 0x0c, 0x3b, 0x5a, 0x1e, + 0xd4, 0x28, 0xe5, 0x41, 0xbc, 0x8c, 0xda, 0xd4, 0xca, 0xa8, 0xf8, 0x13, 0xd8, 0x64, 0x51, 0x8f, + 0xa8, 0x27, 0x92, 0xef, 0xbe, 0xfc, 0x0f, 0x61, 0xab, 0xf8, 0x91, 0xa8, 0xa5, 0x4d, 0x00, 0xf1, + 0x19, 0xc3, 0x75, 0xcf, 0xab, 0x69, 0x9c, 0xe3, 0xc0, 0xf8, 0xaf, 0x2c, 0x58, 0x37, 0xc8, 0x09, + 0x37, 0x78, 0x0f, 0x06, 0x12, 0xc7, 0x89, 0x23, 0x87, 0x9d, 0xb2, 0x96, 0x3a, 0x65, 0xd1, 0x6d, + 0x40, 0x4a, 0x39, 0x05, 0xea, 0x15, 0x33, 0xdc, 0x97, 0x29, 0x1b, 0x5f, 0x61, 0xf3, 0x6c, 0xab, + 0x04, 0xd7, 0x83, 0x4a, 0xc3, 0x08, 0x2a, 0x4a, 0x2a, 0x3b, 0x61, 0x68, 0x5c, 0x76, 0xf0, 0x1c, + 0x2e, 0x94, 0x66, 0xc4, 0x56, 0x3e, 0x82, 0x35, 0xc9, 0x42, 0x8a, 0x44, 0x66, 0xf5, 0xe5, 0x09, + 0x8a, 0x2d, 0xf6, 0xab, 0x61, 0xf3, 0xf2, 0x61, 0x79, 0x02, 0x7f, 0x0c, 0x6b, 0x9c, 0xad, 0xfe, + 0xce, 0xb5, 0xf0, 0xf2, 0x46, 0x2f, 0xce, 0x3a, 0xba, 0xd0, 0xe8, 0xef, 0xd7, 0x28, 0x38, 0xcd, + 0xe2, 0xc4, 0xa8, 0x8f, 0xbe, 0x55, 0xb1, 0x53, 0x2f, 0xa2, 0xd6, 0xcc, 0x22, 0x2a, 0xfa, 0x0a, + 0x3a, 0xf4, 0x24, 0x9b, 0xba, 0xde, 0xab, 0xf9, 0x4c, 0x1e, 0x7d, 0x37, 0xa5, 0xb3, 0x94, 0x39, + 0xd2, 0x83, 0x70, 0x97, 0x23, 0xf3, 0x83, 0x10, 0xc2, 0x1c, 0x80, 0x7e, 0xc0, 0x1e, 0x04, 0x1d, + 0xdf, 0xcd, 0xdc, 0xa9, 0x9b, 0xf2, 0x02, 0x73, 0x97, 0x9d, 0x6b, 0x0f, 0x04, 0x48, 0x9c, 0x49, + 0x3a, 0x85, 0xef, 0x3a, 0x93, 0xba, 0xfa, 0x99, 0x44, 0xa8, 0x25, 0x6a, 0x6b, 0x52, 0x35, 0xdf, + 0x84, 0x83, 0x45, 0x2d, 0x57, 0x88, 0x41, 0x02, 0x59, 0x21, 0xf7, 0x43, 0x6a, 0x5e, 0x02, 0x49, + 0x96, 0x44, 0xf8, 0x65, 0x7e, 0x55, 0xc2, 0x65, 0x09, 0xf7, 0x01, 0xa0, 0x43, 0x92, 0x4d, 0xe2, + 0xa3, 0x09, 0x79, 0xad, 0x6e, 0x12, 0xb7, 0x61, 0x25, 0x8c, 0x8f, 0x9c, 0x90, 0xc2, 0xc4, 0xab, + 0x61, 0x7e, 0xd1, 0xca, 0x71, 0x15, 0x0a, 0xde, 0x84, 0x75, 0x83, 0x8a, 0x50, 0xe5, 0x1a, 0xac, + 0x1e, 0x1e, 0xcf, 0x33, 0x3f, 0x3e, 0x95, 0xaf, 0x33, 0xf4, 0xca, 0xa8, 0x40, 0x02, 0xed, 0xd7, + 0x60, 0xeb, 0x70, 0x3e, 0x4d, 0xbd, 0x24, 0x98, 0x12, 0xf3, 0xe2, 0x3f, 0x82, 0x36, 0x79, 0x13, + 0xa4, 0x59, 0x10, 0x1d, 0xb1, 0x65, 0xb4, 0xed, 0x7c, 0x4c, 0xad, 0x3f, 0xff, 0x8a, 0xbd, 0x43, + 0xe5, 0xd6, 0xff, 0x3e, 0x5c, 0xc9, 0x67, 0x68, 0x10, 0x4c, 0x77, 0x3c, 0x8f, 0xcc, 0x32, 0x22, + 0x5f, 0x49, 0xf0, 0x7d, 0xd8, 0x34, 0x11, 0xb4, 0x37, 0x59, 0x79, 0xd5, 0xcf, 0xdc, 0x57, 0x22, + 0xc7, 0x6b, 0xdb, 0x26, 0x10, 0xff, 0x4f, 0x0d, 0xba, 0xf4, 0x33, 0x49, 0x16, 0x5d, 0x2c, 0x85, + 0x9b, 0x16, 0x1b, 0x3f, 0x36, 0x93, 0xe3, 0x5a, 0x21, 0x39, 0x3e, 0x37, 0x5d, 0x58, 0x54, 0x39, + 0x55, 0x69, 0x49, 0x53, 0x4f, 0x4b, 0x8a, 0xf5, 0xd8, 0xe5, 0x8a, 0x7a, 0xec, 0x16, 0x2c, 0x27, + 0xac, 0x58, 0x26, 0x6e, 0xa6, 0x62, 0x44, 0xa3, 0x11, 0xbf, 0xc1, 0x39, 0x09, 0xf1, 0x48, 0xf0, + 0x9a, 0x4a, 0xbb, 0xcd, 0xa3, 0x51, 0x11, 0x4e, 0xaf, 0x6e, 0x02, 0x96, 0x8a, 0x27, 0xab, 0x15, + 0xfe, 0x5c, 0x69, 0x42, 0x69, 0x44, 0x94, 0xd1, 0x5b, 0xa3, 0xca, 0x6b, 0x7c, 0x15, 0x33, 0x74, + 0x0d, 0x39, 0x54, 0x52, 0xee, 0xf0, 0xec, 0xa6, 0x08, 0xa7, 0x51, 0xba, 0xa3, 0x1d, 0x6e, 0xdf, + 0xb3, 0x82, 0xad, 0xcb, 0xb8, 0x5e, 0x90, 0x71, 0x51, 0x9a, 0x8d, 0x0a, 0x69, 0x7e, 0x00, 0x7d, + 0x71, 0x9a, 0x3a, 0x09, 0x71, 0xd3, 0x58, 0x9e, 0x73, 0x05, 0x28, 0xfe, 0x9b, 0x3a, 0x5f, 0xad, + 0x48, 0x00, 0x7e, 0xb9, 0xc6, 0xa2, 0x54, 0xde, 0x34, 0x54, 0x7e, 0x03, 0x56, 0x0d, 0xd5, 0x12, + 0x5f, 0x68, 0xbc, 0x08, 0xa6, 0x09, 0xbc, 0x52, 0x6d, 0x26, 0xb4, 0xad, 0x83, 0x4a, 0xc2, 0x82, + 0x0a, 0x61, 0x5d, 0x85, 0x46, 0x12, 0x87, 0x84, 0xa9, 0xb4, 0xaf, 0xea, 0x3f, 0x76, 0x1c, 0x12, + 0x9b, 0xcd, 0xd0, 0x93, 0xa6, 0x60, 0x16, 0xc4, 0x67, 0x75, 0xdc, 0x15, 0xbb, 0x3c, 0x41, 0x1d, + 0x55, 0x37, 0x8b, 0x6c, 0xd8, 0xe3, 0x2f, 0x42, 0x06, 0x90, 0xde, 0xbd, 0x13, 0x67, 0x96, 0x90, + 0xe0, 0xc4, 0x3d, 0x22, 0xc3, 0x3e, 0x43, 0xd1, 0x20, 0xca, 0x95, 0x56, 0x35, 0x57, 0xc2, 0xff, + 0x5d, 0x83, 0xe6, 0xd3, 0xc4, 0xf5, 0x09, 0xbd, 0x60, 0x9e, 0x50, 0x8f, 0x77, 0x16, 0x5f, 0xf8, + 0x6c, 0x1d, 0x83, 0x7e, 0x90, 0x69, 0x1f, 0xd4, 0x2a, 0x3f, 0xd0, 0x30, 0x34, 0xfd, 0xd4, 0x0d, + 0xfd, 0x9c, 0xa7, 0x53, 0xcd, 0x12, 0x9a, 0xa6, 0x25, 0xe4, 0xfb, 0x59, 0xd6, 0x43, 0x83, 0x94, + 0x7d, 0x6b, 0xa1, 0xec, 0xaf, 0x42, 0x87, 0xf0, 0x87, 0x21, 0x56, 0xa4, 0xe0, 0x96, 0xa0, 0x83, + 0xf2, 0x3b, 0xca, 0xca, 0xf9, 0x77, 0x94, 0x7b, 0xd0, 0xf5, 0xa8, 0x61, 0x90, 0x64, 0xe6, 0x26, + 0x19, 0x37, 0x85, 0xc5, 0x75, 0x14, 0x03, 0x17, 0xdf, 0x82, 0x75, 0x26, 0xf5, 0x47, 0x01, 0x3d, + 0xa1, 0xce, 0xb4, 0x5b, 0x18, 0x2f, 0xd5, 0x5a, 0x5a, 0xa9, 0x16, 0xdf, 0x87, 0x0d, 0x13, 0x59, + 0x1c, 0x8f, 0xd7, 0x61, 0x39, 0xa3, 0xf0, 0xd2, 0x2d, 0x85, 0x61, 0xdb, 0x62, 0x12, 0xff, 0xb1, + 0x05, 0x3d, 0x0a, 0x09, 0xa2, 0xa3, 0x09, 0xa5, 0x97, 0x52, 0x81, 0x9f, 0xb8, 0x6f, 0x9c, 0x94, + 0x84, 0xa1, 0x2c, 0x8b, 0xc8, 0x31, 0xeb, 0x88, 0x71, 0xdf, 0x38, 0xd3, 0xb9, 0x4c, 0xe9, 0xe4, + 0x90, 0x9a, 0x61, 0x42, 0x52, 0x92, 0xd0, 0xa4, 0x89, 0x7d, 0xca, 0x03, 0x89, 0x09, 0xa4, 0x0e, + 0x92, 0x03, 0x28, 0x11, 0xd1, 0xfe, 0xa0, 0xc3, 0xf0, 0x36, 0xdf, 0x50, 0xbe, 0xa0, 0xb7, 0xc9, + 0x8a, 0xff, 0xda, 0x82, 0xcd, 0xc2, 0x47, 0x42, 0x0c, 0x3b, 0xb0, 0xcc, 0xe4, 0x24, 0xc5, 0xf0, + 0xa1, 0x2e, 0x86, 0x12, 0xfa, 0x6d, 0x3e, 0x14, 0x55, 0x66, 0xfe, 0xe1, 0xe8, 0x09, 0x74, 0x34, + 0x70, 0x45, 0xea, 0x72, 0xcb, 0xac, 0x32, 0x6f, 0x56, 0xb3, 0xd0, 0x32, 0x9a, 0x6f, 0xa0, 0xfb, + 0x2c, 0x9a, 0x7e, 0x8f, 0x46, 0x0d, 0x74, 0x19, 0x56, 0x12, 0x22, 0x6a, 0x00, 0x22, 0x91, 0x51, + 0x00, 0xbc, 0x0a, 0x3d, 0x41, 0x57, 0xbd, 0xaf, 0x3f, 0x8b, 0xc2, 0xd8, 0x7b, 0xf5, 0xb6, 0xef, + 0xeb, 0x3f, 0x03, 0xa4, 0x7f, 0xa0, 0x52, 0xad, 0x39, 0x83, 0x16, 0x52, 0x2d, 0x09, 0x64, 0xa9, + 0xd6, 0xfb, 0xd0, 0xd1, 0x51, 0xf8, 0x73, 0x1c, 0x28, 0x04, 0xfc, 0x87, 0x16, 0xac, 0x3e, 0x0f, + 0xb2, 0x63, 0x3f, 0x71, 0x4f, 0xdf, 0x42, 0xa9, 0xc5, 0x5e, 0x87, 0xda, 0x79, 0xbd, 0x0e, 0xf5, + 0x62, 0xaf, 0x83, 0x1b, 0x86, 0xa2, 0x2c, 0x43, 0x7f, 0xea, 0x05, 0xd9, 0x1e, 0x2f, 0xc8, 0xde, + 0x83, 0x81, 0x5a, 0xcc, 0xbb, 0x55, 0x63, 0x6f, 0xde, 0x80, 0x95, 0xdc, 0xdf, 0x51, 0x0b, 0xea, + 0xbb, 0xcf, 0x7e, 0x63, 0xb0, 0x84, 0xda, 0xd0, 0x38, 0x1c, 0x4f, 0x26, 0xfc, 0xe1, 0x83, 0xbd, + 0x85, 0xd4, 0x6e, 0xde, 0x84, 0x06, 0x8d, 0x2e, 0x68, 0x05, 0x9a, 0x4f, 0x77, 0xbe, 0x1a, 0xdb, + 0xbc, 0x5d, 0xe7, 0x6b, 0xf6, 0xd3, 0x42, 0x5d, 0x68, 0x3f, 0xde, 0x7f, 0x3a, 0xb6, 0xf7, 0x77, + 0x26, 0x83, 0xda, 0xcd, 0xe7, 0xd0, 0x96, 0x79, 0x23, 0x45, 0xda, 0x99, 0x8c, 0xed, 0xa7, 0x1c, + 0x7f, 0x6c, 0xdb, 0x07, 0x36, 0xa7, 0xfb, 0x7c, 0xc7, 0xde, 0x1f, 0xd4, 0xe8, 0xaf, 0xc7, 0xfb, + 0x3f, 0x3d, 0x18, 0xd4, 0x51, 0x07, 0x5a, 0xdf, 0x8c, 0xed, 0xdd, 0x83, 0xc3, 0xf1, 0xa0, 0x41, + 0x71, 0x1f, 0x8c, 0x77, 0x9f, 0x3d, 0x1c, 0x34, 0x19, 0x47, 0x7b, 0x67, 0x6f, 0x3c, 0x58, 0xde, + 0xfe, 0x0f, 0x0b, 0x5a, 0x2f, 0xe6, 0xfe, 0xe3, 0x28, 0xc8, 0xd0, 0x18, 0x40, 0xf5, 0x4f, 0xa0, + 0xbc, 0x8b, 0xa9, 0xd4, 0x85, 0x31, 0x1a, 0x55, 0x4d, 0x09, 0xb3, 0x5a, 0x42, 0x8f, 0xa0, 0xa3, + 0xe5, 0xe4, 0x68, 0xb4, 0xf8, 0xf2, 0x30, 0xba, 0x54, 0x39, 0x97, 0x53, 0x1a, 0x03, 0x28, 0x8b, + 0x53, 0x0b, 0x2a, 0x99, 0xad, 0x5a, 0x50, 0xd9, 0x40, 0xf1, 0xd2, 0xf6, 0x1f, 0x5d, 0x82, 0xfa, + 0x8b, 0xb9, 0x8f, 0x5e, 0x40, 0x47, 0x6b, 0x3a, 0x44, 0xa5, 0x37, 0x36, 0xb5, 0x9c, 0xaa, 0xde, + 0xc4, 0xd1, 0x2f, 0xfe, 0xe9, 0x3f, 0xff, 0xa4, 0xb6, 0x81, 0x57, 0xef, 0xbc, 0xfe, 0xd5, 0x3b, + 0xae, 0xef, 0x4b, 0x5b, 0xbc, 0x67, 0xdd, 0x44, 0x36, 0xb4, 0x44, 0x5f, 0x21, 0xda, 0xd2, 0x68, + 0x68, 0x17, 0xbc, 0xd1, 0x85, 0x12, 0x5c, 0xd0, 0xdd, 0x62, 0x74, 0x07, 0xb8, 0x23, 0xe8, 0xd2, + 0x63, 0x8a, 0xd2, 0xdc, 0x85, 0xfa, 0xae, 0x1b, 0x21, 0xa4, 0x9e, 0xd0, 0x65, 0x4c, 0x18, 0xad, + 0x1b, 0x30, 0x41, 0x07, 0x31, 0x3a, 0x5d, 0xdc, 0xa2, 0x74, 0xa6, 0x6e, 0x44, 0x69, 0x1c, 0x41, + 0xdf, 0x6c, 0x50, 0x42, 0x57, 0xf4, 0x97, 0xa0, 0x52, 0x67, 0xd4, 0xe8, 0xbd, 0x45, 0xd3, 0x85, + 0xc5, 0xf6, 0x29, 0x13, 0x8f, 0xe1, 0xd0, 0xf8, 0x80, 0x3c, 0xe8, 0xea, 0xfd, 0x42, 0x48, 0x75, + 0xad, 0x94, 0x9b, 0xa0, 0x46, 0x97, 0xab, 0x27, 0x05, 0x8b, 0x21, 0x63, 0x81, 0xf0, 0x80, 0xb1, + 0xa0, 0x18, 0xe2, 0xa9, 0x8a, 0x4a, 0x59, 0x34, 0x09, 0x29, 0x29, 0x9b, 0x3d, 0x46, 0x4a, 0xca, + 0xc5, 0x6e, 0x22, 0x43, 0xca, 0x22, 0x26, 0x52, 0x09, 0xfd, 0x1c, 0x7a, 0xcf, 0x59, 0x0b, 0xa0, + 0x68, 0x4d, 0x51, 0x94, 0xcd, 0xce, 0x16, 0x45, 0xb9, 0xd0, 0xc3, 0x82, 0x2f, 0x33, 0xca, 0x5b, + 0x78, 0x8d, 0x52, 0xe6, 0xed, 0x84, 0x3e, 0x47, 0x11, 0x96, 0xf1, 0xbd, 0x29, 0x1b, 0x6b, 0xd6, + 0x68, 0xfe, 0x36, 0xf4, 0x8c, 0xce, 0x16, 0x94, 0x0b, 0xb4, 0xaa, 0x65, 0x66, 0x74, 0x65, 0xc1, + 0x6c, 0xd5, 0xfa, 0x7d, 0x81, 0xc2, 0x7a, 0x61, 0x28, 0xaf, 0x17, 0x00, 0xaa, 0x43, 0x44, 0xb9, + 0x60, 0xa9, 0x2b, 0x45, 0xb9, 0x60, 0xb9, 0xa1, 0x04, 0xaf, 0x33, 0x16, 0x3d, 0xd4, 0xe1, 0xa6, + 0xc9, 0x69, 0x4d, 0xa0, 0x25, 0x7a, 0x21, 0x94, 0x64, 0xcc, 0x86, 0x10, 0x25, 0x99, 0x42, 0xd3, + 0x04, 0x1e, 0x30, 0x82, 0x80, 0xda, 0x94, 0x60, 0x40, 0x49, 0xfc, 0x26, 0x74, 0xb4, 0x46, 0x02, + 0xa4, 0xaf, 0xa6, 0xd0, 0x73, 0xa0, 0xbc, 0xbc, 0xa2, 0xf3, 0x00, 0x6f, 0x30, 0xca, 0x7d, 0xd4, + 0xa5, 0x94, 0x65, 0x15, 0x45, 0x50, 0x97, 0x9d, 0x02, 0x06, 0xf5, 0x42, 0xfb, 0x81, 0x41, 0xbd, + 0xd8, 0x5a, 0x60, 0x52, 0xa7, 0x32, 0x66, 0x6b, 0x7f, 0x0e, 0xa0, 0x1e, 0xb5, 0x95, 0x8c, 0x4b, + 0xaf, 0xf3, 0x4a, 0xc6, 0xe5, 0x37, 0x70, 0xe9, 0xfe, 0x08, 0x28, 0x69, 0xf1, 0xf4, 0x73, 0x04, + 0x7d, 0xb3, 0xe7, 0x40, 0xb9, 0x7f, 0x65, 0x93, 0x82, 0x72, 0xff, 0xea, 0x56, 0x05, 0x69, 0x91, + 0x88, 0xbb, 0xbf, 0x22, 0x7b, 0x08, 0x2b, 0xf9, 0x6b, 0x38, 0x1a, 0xea, 0x44, 0xf4, 0x47, 0xf3, + 0xd1, 0xc5, 0x8a, 0x19, 0x59, 0x04, 0x61, 0x94, 0x3b, 0x68, 0x85, 0x52, 0xe6, 0x8f, 0x22, 0x92, + 0x28, 0xeb, 0xcb, 0x31, 0x89, 0x6a, 0x4f, 0xe9, 0x05, 0xa2, 0xfa, 0x83, 0x7a, 0x81, 0x28, 0xa3, + 0xe3, 0x40, 0x47, 0x7b, 0x6b, 0x55, 0x9a, 0x2c, 0x3f, 0x14, 0x2b, 0x4d, 0x56, 0x3c, 0xce, 0xe2, + 0x0b, 0x8c, 0xf4, 0x1a, 0x3f, 0x0d, 0xe2, 0x19, 0x89, 0x64, 0x90, 0xfa, 0x2d, 0x00, 0x55, 0x1e, + 0x57, 0xca, 0x2c, 0x3d, 0x9c, 0x28, 0xe3, 0x2e, 0x54, 0xd3, 0xf1, 0x45, 0x46, 0x7a, 0x9d, 0xc7, + 0x58, 0xf6, 0x64, 0xc1, 0xd4, 0x79, 0xcf, 0xba, 0x79, 0xd7, 0x42, 0x2f, 0xa1, 0xaf, 0xf0, 0x0f, + 0xcf, 0x22, 0xef, 0x3c, 0x16, 0xa3, 0xaa, 0x29, 0xb1, 0x81, 0x2b, 0x8c, 0xcb, 0x05, 0x8c, 0x4c, + 0x2e, 0xe9, 0x59, 0xe4, 0x51, 0xbf, 0xff, 0x19, 0x74, 0xb4, 0x2e, 0x38, 0x25, 0xa7, 0x72, 0x6b, + 0xdc, 0xa8, 0xaa, 0x80, 0x6f, 0x9e, 0x96, 0xe2, 0x8e, 0x94, 0x9e, 0xba, 0x33, 0x4a, 0x3b, 0x82, + 0xbe, 0x59, 0xa7, 0x56, 0x66, 0x59, 0x59, 0xf4, 0x56, 0x66, 0xb9, 0xa0, 0xbc, 0x6d, 0xec, 0x85, + 0x97, 0x67, 0xf5, 0xd3, 0x79, 0x4a, 0x13, 0x92, 0xbc, 0x5c, 0xad, 0x27, 0x24, 0xc5, 0x92, 0xb8, + 0x9e, 0x90, 0x94, 0xea, 0xdb, 0xe6, 0x9e, 0x38, 0x1b, 0xa9, 0x19, 0x94, 0xc0, 0x6a, 0xa1, 0x96, + 0x8c, 0x0a, 0xab, 0x2e, 0x96, 0x9f, 0x47, 0xef, 0x2f, 0x9c, 0x17, 0xfc, 0xde, 0x63, 0xfc, 0x86, + 0x78, 0x5d, 0xf1, 0x73, 0xc3, 0x90, 0xab, 0x89, 0x9f, 0x5d, 0xa0, 0x2a, 0xc3, 0xca, 0x0e, 0x4a, + 0xc5, 0xe5, 0xd1, 0xa8, 0x6a, 0x4a, 0x30, 0x31, 0xac, 0x8d, 0x33, 0x91, 0x19, 0xc8, 0x14, 0x3a, + 0x5a, 0xbd, 0x52, 0xc9, 0xad, 0x5c, 0x0a, 0x55, 0x72, 0xab, 0x2a, 0x70, 0x1a, 0x72, 0x4b, 0x49, + 0x16, 0xc6, 0x47, 0xac, 0x20, 0x4a, 0x79, 0x7c, 0x03, 0x6d, 0x59, 0xe9, 0x44, 0xb9, 0x47, 0x14, + 0xca, 0xa1, 0xa3, 0x61, 0x79, 0xa2, 0xe0, 0x86, 0x2c, 0xa0, 0xa6, 0x62, 0x96, 0xd2, 0x75, 0x60, + 0xb5, 0x50, 0xf7, 0x54, 0xfa, 0xa8, 0x2e, 0x88, 0x8e, 0x7a, 0xc6, 0x7f, 0x7c, 0xe0, 0x4b, 0x8c, + 0xf4, 0x26, 0x62, 0xd2, 0x4f, 0xe5, 0x27, 0xec, 0x3f, 0x32, 0xd2, 0xbb, 0x16, 0x22, 0x1a, 0x83, + 0xa2, 0xc2, 0xab, 0xeb, 0xb4, 0x23, 0xb3, 0x5b, 0x90, 0x3f, 0x94, 0x2f, 0x60, 0xc3, 0x95, 0x7c, + 0xd7, 0x42, 0xb3, 0x42, 0x11, 0x56, 0x54, 0xf3, 0xb4, 0x48, 0x5e, 0x59, 0xa3, 0x1d, 0x55, 0xbd, + 0x6f, 0xe1, 0x1f, 0x30, 0x5e, 0x97, 0xd0, 0x45, 0x83, 0x17, 0x75, 0x4b, 0xf9, 0xbc, 0x77, 0xd7, + 0x42, 0x53, 0xe8, 0x9b, 0x24, 0xdf, 0x89, 0x55, 0xc1, 0xff, 0x11, 0x2a, 0xb1, 0xa2, 0x3c, 0x7e, + 0x57, 0xab, 0x4a, 0x1b, 0xb5, 0x67, 0x74, 0xbd, 0x9a, 0x57, 0xa1, 0x36, 0x3d, 0xda, 0xd0, 0x79, + 0xca, 0x49, 0x8c, 0x19, 0xd3, 0xcb, 0x68, 0x54, 0x66, 0xea, 0x0a, 0x1c, 0x16, 0x42, 0xbb, 0x7a, + 0x55, 0x44, 0xe5, 0xaa, 0x15, 0x85, 0x15, 0x95, 0xab, 0x56, 0x15, 0x52, 0xa4, 0xf2, 0x78, 0xae, + 0xca, 0xaa, 0x26, 0xc7, 0x1c, 0x83, 0x27, 0xdf, 0x85, 0xea, 0xc9, 0xe5, 0x05, 0xf5, 0x85, 0x42, + 0x9a, 0x56, 0x59, 0x7d, 0x90, 0x7e, 0x8a, 0xd6, 0x24, 0xab, 0x20, 0x3a, 0xe2, 0x45, 0x08, 0xf4, + 0x25, 0x34, 0xd9, 0xd5, 0x1e, 0x6d, 0xa8, 0x6b, 0x90, 0xaa, 0x20, 0x8c, 0x36, 0x0b, 0x50, 0x33, + 0x17, 0xc1, 0xec, 0x70, 0x9c, 0x47, 0xe2, 0xc6, 0x30, 0x85, 0x3e, 0xcf, 0x87, 0xe5, 0x05, 0x58, + 0x79, 0x65, 0xe1, 0x7e, 0xae, 0xbc, 0xb2, 0x78, 0x57, 0x36, 0xe3, 0x31, 0x4f, 0x89, 0x4f, 0x05, + 0xce, 0x3d, 0xeb, 0xe6, 0x74, 0x99, 0xfd, 0x0f, 0xd8, 0x27, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, + 0x84, 0x0b, 0x92, 0x91, 0x2e, 0x36, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. From 0f95df4a7880bfc01c300d29f7b90bc5484c1e1d Mon Sep 17 00:00:00 2001 From: rsercano Date: Sat, 12 Dec 2020 11:11:11 +0300 Subject: [PATCH 11/16] fixed typo --- lib/alerts/Alerts.ts | 12 +++++++----- lib/alerts/consts.ts | 2 -- lib/alerts/types.ts | 6 ++++-- lib/connextclient/ConnextClient.ts | 6 +++--- lib/grpc/GrpcService.ts | 6 +++--- lib/lndclient/LndClient.ts | 6 +++--- lib/service/Service.ts | 9 +++++---- lib/swaps/SwapClient.ts | 2 +- proto/xudrpc.proto | 6 +++--- test/integration/Service.spec.ts | 16 ++++++++-------- 10 files changed, 37 insertions(+), 34 deletions(-) delete mode 100644 lib/alerts/consts.ts diff --git a/lib/alerts/Alerts.ts b/lib/alerts/Alerts.ts index ba16a549c..adfac556f 100644 --- a/lib/alerts/Alerts.ts +++ b/lib/alerts/Alerts.ts @@ -1,14 +1,13 @@ import { EventEmitter } from 'events'; -import { BalanceAlert } from './types'; +import { Alert, BalanceAlert } from './types'; import SwapClientManager from '../swaps/SwapClientManager'; -import { MIN_BALANCE_ALERT_THRESHOLD_IN_MS } from './consts'; import Logger from '../Logger'; import { AlertType, ChannelSide } from '../constants/enums'; import { satsToCoinsStr } from '../cli/utils'; interface Alerts { - on(event: 'alert', listener: (alert: any) => void): this; - emit(event: 'alert', alert: any): boolean; + on(event: 'alert', listener: (alert: Alert) => void): this; + emit(event: 'alert', alert: Alert): boolean; } // TODO this class still requires a cleanup if alert is not being thrown anymore after a while @@ -17,6 +16,8 @@ interface Alerts { * and re-thrown if last thrown time was before the minimum threshold that set in consts.ts */ class Alerts extends EventEmitter { + /** The minimum time in miliseconds to be passed to rethrow a balance alert. */ + private static readonly MIN_BALANCE_ALERT_THRESHOLD_IN_MS = 10000; private alerts = new Map(); private logger: Logger; @@ -35,6 +36,7 @@ class Alerts extends EventEmitter { } private onLowTradingBalance = (balanceAlert: BalanceAlert) => { + // TODO don't use JSON.stringify instead find a way to define unique ids per alert and keep in the map to avoid memory issues const stringRepresentation = JSON.stringify(balanceAlert); this.logger.trace(`received low trading balance alert ${stringRepresentation}`); if (this.alerts.get(stringRepresentation) === undefined || this.checkAlertThreshold(stringRepresentation)) { @@ -56,7 +58,7 @@ class Alerts extends EventEmitter { private checkAlertThreshold(stringRepresentation: string) { const lastThrownTime = this.alerts.get(stringRepresentation) || 0; const passedTime = Date.now() - lastThrownTime; - return passedTime > MIN_BALANCE_ALERT_THRESHOLD_IN_MS; + return passedTime > Alerts.MIN_BALANCE_ALERT_THRESHOLD_IN_MS; } } diff --git a/lib/alerts/consts.ts b/lib/alerts/consts.ts deleted file mode 100644 index e29bb7c76..000000000 --- a/lib/alerts/consts.ts +++ /dev/null @@ -1,2 +0,0 @@ -/** The minimum time in miliseconds to be passed to rethrow a balance alert. */ -export const MIN_BALANCE_ALERT_THRESHOLD_IN_MS = 10000; diff --git a/lib/alerts/types.ts b/lib/alerts/types.ts index 0e3084eec..aa880d1bd 100644 --- a/lib/alerts/types.ts +++ b/lib/alerts/types.ts @@ -1,6 +1,8 @@ import { AlertType, ChannelSide } from '../constants/enums'; -export type BalanceAlert = Alert & { +export type Alert = BalanceAlert; + +export type BalanceAlert = BaseAlert & { /** The total balance of the channel when the alert is triggered. */ totalBalance: number; /** The side of the balance either local or remote. */ @@ -13,7 +15,7 @@ export type BalanceAlert = Alert & { currency: string; }; -export type Alert = { +type BaseAlert = { type: AlertType; message: string; date: number; diff --git a/lib/connextclient/ConnextClient.ts b/lib/connextclient/ConnextClient.ts index 9b6f99489..2a4b9f323 100644 --- a/lib/connextclient/ConnextClient.ts +++ b/lib/connextclient/ConnextClient.ts @@ -5,7 +5,7 @@ import { combineLatest, defer, from, fromEvent, interval, Observable, of, Subscr import { catchError, distinctUntilChanged, filter, mergeMap, mergeMapTo, pluck, take, timeout } from 'rxjs/operators'; import { SwapClientType, SwapRole, SwapState } from '../constants/enums'; import { CurrencyInstance } from '../db/types'; -import { BalanceAlert } from '../alerts/types'; +import { Alert } from '../alerts/types'; import Logger from '../Logger'; import swapErrors from '../swaps/errors'; import SwapClient, { @@ -51,7 +51,7 @@ interface ConnextClient { on(event: 'htlcAccepted', listener: (rHash: string, amount: number, currency: string) => void): this; on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; on(event: 'depositConfirmed', listener: (hash: string) => void): this; - on(event: 'lowTradingBalance', listener: (alert: BalanceAlert) => void): this; + on(event: 'lowTradingBalance', listener: (alert: Alert) => void): this; once(event: 'initialized', listener: () => void): this; emit(event: 'htlcAccepted', rHash: string, amount: number, currency: string): boolean; emit(event: 'connectionVerified', swapClientInfo: SwapClientInfo): boolean; @@ -59,7 +59,7 @@ interface ConnextClient { emit(event: 'preimage', preimageRequest: ProvidePreimageEvent): void; emit(event: 'transferReceived', transferReceivedRequest: TransferReceivedEvent): void; emit(event: 'depositConfirmed', hash: string): void; - emit(event: 'lowTradingBalance', alert: BalanceAlert): boolean; + emit(event: 'lowTradingBalance', alert: Alert): boolean; } const getRouterNodeIdentifier = (network: string): string => { diff --git a/lib/grpc/GrpcService.ts b/lib/grpc/GrpcService.ts index c991046be..49574c7c7 100644 --- a/lib/grpc/GrpcService.ts +++ b/lib/grpc/GrpcService.ts @@ -9,7 +9,7 @@ import Service from '../service/Service'; import { ServiceOrder, ServicePlaceOrderEvent } from '../service/types'; import { SwapAccepted, SwapFailure, SwapSuccess } from '../swaps/types'; import getGrpcError from './getGrpcError'; -import { BalanceAlert } from '../alerts/types'; +import { Alert } from '../alerts/types'; /** * Creates an xudrpc Order message from an [[Order]]. @@ -992,13 +992,13 @@ class GrpcService { } const cancelled$ = getCancelled$(call); - this.service.subscribeAlerts((serviceAlert: any) => { + this.service.subscribeAlerts((serviceAlert: Alert) => { const alert = new xudrpc.Alert(); alert.setType(serviceAlert.type as number); alert.setMessage(serviceAlert.message); alert.setDate(serviceAlert.date); if (serviceAlert.type === AlertType.LowTradingBalance) { - const balanceServiceAlert = serviceAlert as BalanceAlert; + const balanceServiceAlert = serviceAlert as Alert; const balanceAlert = new xudrpc.BalanceAlert(); balanceAlert.setBound(balanceServiceAlert.bound); balanceAlert.setSide(balanceServiceAlert.side as number); diff --git a/lib/lndclient/LndClient.ts b/lib/lndclient/LndClient.ts index c17001145..4b1e003a9 100644 --- a/lib/lndclient/LndClient.ts +++ b/lib/lndclient/LndClient.ts @@ -27,7 +27,7 @@ import { deriveChild } from '../utils/seedutil'; import { base64ToHex, hexToUint8Array } from '../utils/utils'; import errors from './errors'; import { Chain, ChannelCount, ClientMethods, LndClientConfig, LndInfo } from './types'; -import { BalanceAlert } from '../alerts/types'; +import { Alert } from '../alerts/types'; interface LndClient { on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; @@ -35,7 +35,7 @@ interface LndClient { on(event: 'channelBackup', listener: (channelBackup: Uint8Array) => void): this; on(event: 'channelBackupEnd', listener: () => void): this; on(event: 'locked', listener: () => void): this; - on(event: 'lowTradingBalance', listener: (alert: BalanceAlert) => void): this; + on(event: 'lowTradingBalance', listener: (alert: Alert) => void): this; once(event: 'initialized', listener: () => void): this; @@ -45,7 +45,7 @@ interface LndClient { emit(event: 'channelBackupEnd'): boolean; emit(event: 'locked'): boolean; emit(event: 'initialized'): boolean; - emit(event: 'lowTradingBalance', alert: BalanceAlert): boolean; + emit(event: 'lowTradingBalance', alert: Alert): boolean; } const GRPC_CLIENT_OPTIONS = { diff --git a/lib/service/Service.ts b/lib/service/Service.ts index 60162d847..1f75b0dcd 100644 --- a/lib/service/Service.ts +++ b/lib/service/Service.ts @@ -39,6 +39,7 @@ import { ServiceTrade, XudInfo, } from './types'; +import { Alert } from '../alerts/types'; /** Functions to check argument validity and throw [[INVALID_ARGUMENT]] when invalid. */ const argChecks = { @@ -818,9 +819,9 @@ class Service extends EventEmitter { /* * Subscribe to alerts. */ - public subscribeAlerts = (callback: (payload: any) => void, cancelled$: Observable) => { - const observables: Observable[] = []; - observables.push(fromEvent(this.alerts, 'alert')); + public subscribeAlerts = (callback: (payload: Alert) => void, cancelled$: Observable) => { + const observables: Observable[] = []; + observables.push(fromEvent(this.alerts, 'alert')); const mergedObservable$ = this.getMergedObservable$(observables, cancelled$); @@ -832,7 +833,7 @@ class Service extends EventEmitter { }); }; - private getMergedObservable$(observables: Observable[], cancelled$: Observable) { + private getMergedObservable$(observables: Observable[], cancelled$: Observable) { return merge(...observables).pipe(takeUntil(cancelled$)); } diff --git a/lib/swaps/SwapClient.ts b/lib/swaps/SwapClient.ts index 0fda8a1ad..5f8d14b36 100644 --- a/lib/swaps/SwapClient.ts +++ b/lib/swaps/SwapClient.ts @@ -236,7 +236,7 @@ abstract class SwapClient extends EventEmitter { currency: string, emit: Function, ) => { - if (localBalance < 490000001) { + if (localBalance < alertThreshold) { emit('lowTradingBalance', { totalBalance, currency, diff --git a/proto/xudrpc.proto b/proto/xudrpc.proto index 9ec3a5230..d5f7adb2f 100644 --- a/proto/xudrpc.proto +++ b/proto/xudrpc.proto @@ -448,11 +448,11 @@ message BalanceAlert { LOCAL = 1; } Side side = 2 [json_name = "side"]; - // The bound of the low balance in percentage. - uint32 bound = 3 [json_name = "bound"]; + // The percent of the total trading balance. + uint32 percent = 3 [json_name = "percent"]; // The current side balance. uint64 side_balance = 4 [json_name = "side_balance"]; - // The currency of the alert. + // The currency of the channel this alert is for. string currency = 5 [json_name = "currency"]; } diff --git a/test/integration/Service.spec.ts b/test/integration/Service.spec.ts index c221f1b8f..7bd418921 100644 --- a/test/integration/Service.spec.ts +++ b/test/integration/Service.spec.ts @@ -7,7 +7,7 @@ import Xud from '../../lib/Xud'; import { getTempDir } from '../utils'; import { TestScheduler } from 'rxjs/testing'; import { Observable } from 'rxjs'; -import { BalanceAlert } from '../../lib/alerts/types'; +import { Alert } from '../../lib/alerts/types'; chai.use(chaiAsPromised); @@ -225,23 +225,23 @@ describe('API Service', () => { it('should continue without cancelled$', async () => { testScheduler.run(({ cold, expectObservable }) => { - const firstLowBalanceEvent = cold('-a--b---c---') as Observable; - const secondLowBalanceEvent = cold('--a-b|') as Observable; + const firstLowBalanceEvent = cold('-a--b---c---') as Observable; + const secondLowBalanceEvent = cold('--a-b|') as Observable; const cancelled = cold('-') as Observable; - const lowBalanceObservables: Observable[] = [firstLowBalanceEvent, secondLowBalanceEvent]; + const lowBalanceObservables: Observable[] = [firstLowBalanceEvent, secondLowBalanceEvent]; const finalObservable = service['getMergedObservable$'](lowBalanceObservables, cancelled); expectObservable(finalObservable).toBe('-aa-(bb)c---'); }); }); - it('should cancelled with cancelled$', async () => { + it('should cancel with cancelled$', async () => { testScheduler.run(({ cold, expectObservable }) => { - const firstLowBalanceEvent = cold('-a--b---c---') as Observable; - const secondLowBalanceEvent = cold('--a-b|') as Observable; + const firstLowBalanceEvent = cold('-a--b---c---') as Observable; + const secondLowBalanceEvent = cold('--a-b|') as Observable; const cancelled = cold('---a') as Observable; - const lowBalanceObservables: Observable[] = [firstLowBalanceEvent, secondLowBalanceEvent]; + const lowBalanceObservables: Observable[] = [firstLowBalanceEvent, secondLowBalanceEvent]; const finalObservable = service['getMergedObservable$'](lowBalanceObservables, cancelled); expectObservable(finalObservable).toBe('-aa|'); }); From 3469df20bfa7efae345962db186eea1352d80a60 Mon Sep 17 00:00:00 2001 From: Daniel McNally Date: Tue, 22 Dec 2020 02:10:47 -0500 Subject: [PATCH 12/16] refactor: type checking for BalanceAlert event --- lib/alerts/Alerts.ts | 31 +++++++++++++++++------------- lib/alerts/types.ts | 15 ++++++++------- lib/connextclient/ConnextClient.ts | 8 ++++---- lib/lndclient/LndClient.ts | 7 +++---- lib/swaps/SwapClient.ts | 8 +++++--- 5 files changed, 38 insertions(+), 31 deletions(-) diff --git a/lib/alerts/Alerts.ts b/lib/alerts/Alerts.ts index adfac556f..9ade5b5cb 100644 --- a/lib/alerts/Alerts.ts +++ b/lib/alerts/Alerts.ts @@ -1,9 +1,9 @@ import { EventEmitter } from 'events'; -import { Alert, BalanceAlert } from './types'; -import SwapClientManager from '../swaps/SwapClientManager'; -import Logger from '../Logger'; -import { AlertType, ChannelSide } from '../constants/enums'; import { satsToCoinsStr } from '../cli/utils'; +import { AlertType, ChannelSide } from '../constants/enums'; +import Logger from '../Logger'; +import SwapClientManager from '../swaps/SwapClientManager'; +import { Alert, BalanceAlertEvent } from './types'; interface Alerts { on(event: 'alert', listener: (alert: Alert) => void): this; @@ -35,20 +35,25 @@ class Alerts extends EventEmitter { swapClientManager.connextClient?.on('lowTradingBalance', this.onLowTradingBalance); } - private onLowTradingBalance = (balanceAlert: BalanceAlert) => { + private onLowTradingBalance = (balanceAlertEvent: BalanceAlertEvent) => { // TODO don't use JSON.stringify instead find a way to define unique ids per alert and keep in the map to avoid memory issues - const stringRepresentation = JSON.stringify(balanceAlert); + const stringRepresentation = JSON.stringify(balanceAlertEvent); this.logger.trace(`received low trading balance alert ${stringRepresentation}`); if (this.alerts.get(stringRepresentation) === undefined || this.checkAlertThreshold(stringRepresentation)) { this.logger.trace(`triggering low balance alert ${stringRepresentation}`); - balanceAlert.message = `${ChannelSide[balanceAlert.side || 0]} trading balance (${satsToCoinsStr( - balanceAlert.sideBalance || 0, - )} ${balanceAlert.currency}) is lower than 10% of trading capacity (${satsToCoinsStr( - balanceAlert.totalBalance || 0, - )} ${balanceAlert.currency})`; - balanceAlert.type = AlertType.LowTradingBalance; - balanceAlert.date = Date.now(); + const message = `${ChannelSide[balanceAlertEvent.side || 0]} trading balance (${satsToCoinsStr( + balanceAlertEvent.sideBalance || 0, + )} ${balanceAlertEvent.currency}) is lower than 10% of trading capacity (${satsToCoinsStr( + balanceAlertEvent.totalBalance || 0, + )} ${balanceAlertEvent.currency})`; + + const balanceAlert = { + ...balanceAlertEvent, + message, + type: AlertType.LowTradingBalance, + date: Date.now(), + }; this.alerts.set(stringRepresentation, balanceAlert.date); this.emit('alert', balanceAlert); diff --git a/lib/alerts/types.ts b/lib/alerts/types.ts index aa880d1bd..fadbc9a80 100644 --- a/lib/alerts/types.ts +++ b/lib/alerts/types.ts @@ -1,8 +1,12 @@ import { AlertType, ChannelSide } from '../constants/enums'; -export type Alert = BalanceAlert; +type BaseAlert = { + type: AlertType; + message: string; + date: number; +}; -export type BalanceAlert = BaseAlert & { +export type BalanceAlertEvent = { /** The total balance of the channel when the alert is triggered. */ totalBalance: number; /** The side of the balance either local or remote. */ @@ -14,9 +18,6 @@ export type BalanceAlert = BaseAlert & { /** The currency of the channel. */ currency: string; }; +export type BalanceAlert = BaseAlert & BalanceAlertEvent; -type BaseAlert = { - type: AlertType; - message: string; - date: number; -}; +export type Alert = BalanceAlert; diff --git a/lib/connextclient/ConnextClient.ts b/lib/connextclient/ConnextClient.ts index 2a4b9f323..4e6844e71 100644 --- a/lib/connextclient/ConnextClient.ts +++ b/lib/connextclient/ConnextClient.ts @@ -3,9 +3,9 @@ import assert from 'assert'; import http from 'http'; import { combineLatest, defer, from, fromEvent, interval, Observable, of, Subscription, throwError, timer } from 'rxjs'; import { catchError, distinctUntilChanged, filter, mergeMap, mergeMapTo, pluck, take, timeout } from 'rxjs/operators'; +import { BalanceAlertEvent } from '../alerts/types'; import { SwapClientType, SwapRole, SwapState } from '../constants/enums'; import { CurrencyInstance } from '../db/types'; -import { Alert } from '../alerts/types'; import Logger from '../Logger'; import swapErrors from '../swaps/errors'; import SwapClient, { @@ -51,7 +51,7 @@ interface ConnextClient { on(event: 'htlcAccepted', listener: (rHash: string, amount: number, currency: string) => void): this; on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; on(event: 'depositConfirmed', listener: (hash: string) => void): this; - on(event: 'lowTradingBalance', listener: (alert: Alert) => void): this; + on(event: 'lowTradingBalance', listener: (alert: BalanceAlertEvent) => void): this; once(event: 'initialized', listener: () => void): this; emit(event: 'htlcAccepted', rHash: string, amount: number, currency: string): boolean; emit(event: 'connectionVerified', swapClientInfo: SwapClientInfo): boolean; @@ -59,7 +59,7 @@ interface ConnextClient { emit(event: 'preimage', preimageRequest: ProvidePreimageEvent): void; emit(event: 'transferReceived', transferReceivedRequest: TransferReceivedEvent): void; emit(event: 'depositConfirmed', hash: string): void; - emit(event: 'lowTradingBalance', alert: Alert): boolean; + emit(event: 'lowTradingBalance', alert: BalanceAlertEvent): boolean; } const getRouterNodeIdentifier = (network: string): string => { @@ -343,7 +343,7 @@ class ConnextClient extends SwapClient { const totalBalance = remoteBalance + localBalance; const alertThreshold = totalBalance * 0.1; - this.checkLowBalance(remoteBalance, localBalance, totalBalance, alertThreshold, currency, this.emit.bind(this)); + this.checkLowBalance(remoteBalance, localBalance, totalBalance, alertThreshold, currency); } } catch (e) { this.logger.error('failed to update total outbound capacity', e); diff --git a/lib/lndclient/LndClient.ts b/lib/lndclient/LndClient.ts index 4b1e003a9..f6df35dcf 100644 --- a/lib/lndclient/LndClient.ts +++ b/lib/lndclient/LndClient.ts @@ -2,6 +2,7 @@ import assert from 'assert'; import crypto from 'crypto'; import { promises as fs, watch } from 'fs'; import grpc, { ChannelCredentials, ClientReadableStream } from 'grpc'; +import { BalanceAlertEvent } from 'lib/alerts/types'; import path from 'path'; import { SwapClientType, SwapRole, SwapState } from '../constants/enums'; import Logger from '../Logger'; @@ -27,7 +28,6 @@ import { deriveChild } from '../utils/seedutil'; import { base64ToHex, hexToUint8Array } from '../utils/utils'; import errors from './errors'; import { Chain, ChannelCount, ClientMethods, LndClientConfig, LndInfo } from './types'; -import { Alert } from '../alerts/types'; interface LndClient { on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; @@ -35,7 +35,7 @@ interface LndClient { on(event: 'channelBackup', listener: (channelBackup: Uint8Array) => void): this; on(event: 'channelBackupEnd', listener: () => void): this; on(event: 'locked', listener: () => void): this; - on(event: 'lowTradingBalance', listener: (alert: Alert) => void): this; + on(event: 'lowTradingBalance', listener: (alert: BalanceAlertEvent) => void): this; once(event: 'initialized', listener: () => void): this; @@ -45,7 +45,7 @@ interface LndClient { emit(event: 'channelBackupEnd'): boolean; emit(event: 'locked'): boolean; emit(event: 'initialized'): boolean; - emit(event: 'lowTradingBalance', alert: Alert): boolean; + emit(event: 'lowTradingBalance', alert: BalanceAlertEvent): boolean; } const GRPC_CLIENT_OPTIONS = { @@ -257,7 +257,6 @@ class LndClient extends SwapClient { totalBalance, alertThreshold, this.currency, - this.emit.bind(this), ); }) .catch(async (err) => { diff --git a/lib/swaps/SwapClient.ts b/lib/swaps/SwapClient.ts index 5f8d14b36..fe02fcf16 100644 --- a/lib/swaps/SwapClient.ts +++ b/lib/swaps/SwapClient.ts @@ -1,4 +1,5 @@ import { EventEmitter } from 'events'; +import { BalanceAlertEvent } from 'lib/alerts/types'; import { ChannelSide, SwapClientType } from '../constants/enums'; import Logger from '../Logger'; import { setTimeoutPromise } from '../utils/utils'; @@ -71,8 +72,10 @@ export type WithdrawArguments = { interface SwapClient { on(event: 'connectionVerified', listener: (swapClientInfo: SwapClientInfo) => void): this; + on(event: 'lowTradingBalance', listener: (alert: BalanceAlertEvent) => void): this; once(event: 'initialized', listener: () => void): this; emit(event: 'connectionVerified', swapClientInfo: SwapClientInfo): boolean; + emit(event: 'lowTradingBalance', alert: BalanceAlertEvent): boolean; emit(event: 'initialized'): boolean; } @@ -234,10 +237,9 @@ abstract class SwapClient extends EventEmitter { totalBalance: number, alertThreshold: number, currency: string, - emit: Function, ) => { if (localBalance < alertThreshold) { - emit('lowTradingBalance', { + this.emit('lowTradingBalance', { totalBalance, currency, side: ChannelSide.Local, @@ -247,7 +249,7 @@ abstract class SwapClient extends EventEmitter { } if (remoteBalance < alertThreshold) { - emit('lowTradingBalance', { + this.emit('lowTradingBalance', { totalBalance, currency, side: ChannelSide.Remote, From 510ebd4b568ba530ae9e10a8c3260b148c8205a5 Mon Sep 17 00:00:00 2001 From: rsercano Date: Sun, 3 Jan 2021 08:56:32 +0300 Subject: [PATCH 13/16] fixing tests --- test/jest/LndClient.spec.ts | 48 ++++++++++++++++++------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/test/jest/LndClient.spec.ts b/test/jest/LndClient.spec.ts index cdb912d9c..8d3794d9b 100644 --- a/test/jest/LndClient.spec.ts +++ b/test/jest/LndClient.spec.ts @@ -282,17 +282,17 @@ describe('LndClient', () => { describe('checkLowBalance', () => { test('emits lowTradingBalance on local balance is less than alert threshold of total balance ', async () => { - const emit = jest.fn().mockImplementation(); + lnd['emit'] = jest.fn().mockImplementation(); const totalBalance = 120; const localBalance = 10; const alertThreshold = totalBalance * 0.1; const remoteBalance = 110; const currency = 'BTC'; - lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency); - expect(emit).toHaveBeenCalledTimes(1); - expect(emit).toHaveBeenCalledWith('lowTradingBalance', { + expect(lnd['emit']).toHaveBeenCalledTimes(1); + expect(lnd['emit']).toHaveBeenCalledWith('lowTradingBalance', { totalBalance, currency, side: ChannelSide.Local, @@ -301,17 +301,17 @@ describe('LndClient', () => { }); }); test('emits lowBalance on local balance is less than alert threshold of total balance ', async () => { - const emit = jest.fn().mockImplementation(); + lnd['emit'] = jest.fn().mockImplementation(); const totalBalance = 120; const localBalance = 10; const alertThreshold = totalBalance * 0.1; const remoteBalance = 110; const currency = 'BTC'; - lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency); - expect(emit).toHaveBeenCalledTimes(1); - expect(emit).toHaveBeenCalledWith('lowTradingBalance', { + expect(lnd['emit']).toHaveBeenCalledTimes(1); + expect(lnd['emit']).toHaveBeenCalledWith('lowTradingBalance', { totalBalance, currency, side: ChannelSide.Local, @@ -320,41 +320,41 @@ describe('LndClient', () => { }); }); test('dont emit on local balance equals alert threshold of total balance ', async () => { - const emit = jest.fn().mockImplementation(); + lnd['emit'] = jest.fn().mockImplementation(); const totalBalance = 120; const localBalance = 12; const alertThreshold = totalBalance * 0.1; const remoteBalance = 110; const currency = 'BTC'; - lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency); - expect(emit).toHaveBeenCalledTimes(0); + expect(lnd['emit']).toHaveBeenCalledTimes(0); }); test('dont emit on local balance is higher than alert threshold of total balance ', async () => { - const emit = jest.fn().mockImplementation(); + lnd['emit'] = jest.fn().mockImplementation(); const totalBalance = 120; const localBalance = 12.5; const alertThreshold = totalBalance * 0.1; const remoteBalance = 110; const currency = 'BTC'; - lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency); - expect(emit).toHaveBeenCalledTimes(0); + expect(lnd['emit']).toHaveBeenCalledTimes(0); }); test('emits on remote balance is less than alert threshold of total balance ', async () => { - const emit = jest.fn().mockImplementation(); + lnd['emit'] = jest.fn().mockImplementation(); const totalBalance = 120; const localBalance = 110; const alertThreshold = totalBalance * 0.1; const remoteBalance = 10; const currency = 'BTC'; - lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency); - expect(emit).toHaveBeenCalledTimes(1); - expect(emit).toHaveBeenCalledWith('lowTradingBalance', { + expect(lnd['emit']).toHaveBeenCalledTimes(1); + expect(lnd['emit']).toHaveBeenCalledWith('lowTradingBalance', { totalBalance, currency, side: ChannelSide.Remote, @@ -363,28 +363,28 @@ describe('LndClient', () => { }); }); test('dont emit on remote balance equals alert threshold of total balance ', async () => { - const emit = jest.fn().mockImplementation(); + lnd['emit'] = jest.fn().mockImplementation(); const totalBalance = 120; const localBalance = 110; const alertThreshold = totalBalance * 0.1; const remoteBalance = 12; const currency = 'BTC'; - lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency); - expect(emit).toHaveBeenCalledTimes(0); + expect(lnd['emit']).toHaveBeenCalledTimes(0); }); test('dont emit on remote balance is higher than alert threshold of total balance ', async () => { - const emit = jest.fn().mockImplementation(); + lnd['emit'] = jest.fn().mockImplementation(); const totalBalance = 120; const localBalance = 110; const alertThreshold = totalBalance * 0.1; const remoteBalance = 12.5; const currency = 'BTC'; - lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency, emit); + lnd['checkLowBalance'](remoteBalance, localBalance, totalBalance, alertThreshold, currency); - expect(emit).toHaveBeenCalledTimes(0); + expect(lnd['emit']).toHaveBeenCalledTimes(0); }); }); }); From 9705f1a56304a94f7c14fbe8abdd41be6171c351 Mon Sep 17 00:00:00 2001 From: rsercano Date: Tue, 5 Jan 2021 18:33:00 +0300 Subject: [PATCH 14/16] fixed proto --- docs/api.md | 1 + lib/proto/xudrpc.swagger.json | 5 + lib/proto/xudrpc_pb.d.ts | 4 + lib/proto/xudrpc_pb.js | 64 +++- proto/xudrpc.proto | 8 +- test/simulation/xudrpc/xudrpc.pb.go | 574 ++++++++++++++-------------- 6 files changed, 354 insertions(+), 302 deletions(-) diff --git a/docs/api.md b/docs/api.md index 97070cddb..73bebe4fc 100644 --- a/docs/api.md +++ b/docs/api.md @@ -205,6 +205,7 @@ | ----- | ---- | ----- | ----------- | | total_balance | [uint64](#uint64) | | The total balance. | | side | [BalanceAlert.Side](#xudrpc.BalanceAlert.Side) | | | +| bound | [uint32](#uint32) | | The bound of the low balance in percentage. | | percent | [uint32](#uint32) | | The percent of the total trading balance. | | side_balance | [uint64](#uint64) | | The current side balance. | | currency | [string](#string) | | The currency of the channel this alert is for. | diff --git a/lib/proto/xudrpc.swagger.json b/lib/proto/xudrpc.swagger.json index 6963496a1..2f4c73b50 100644 --- a/lib/proto/xudrpc.swagger.json +++ b/lib/proto/xudrpc.swagger.json @@ -1085,6 +1085,11 @@ "side": { "$ref": "#/definitions/BalanceAlertSide" }, + "bound": { + "type": "integer", + "format": "int64", + "description": "The bound of the low balance in percentage." + }, "percent": { "type": "integer", "format": "int64", diff --git a/lib/proto/xudrpc_pb.d.ts b/lib/proto/xudrpc_pb.d.ts index 913969518..6892c270e 100644 --- a/lib/proto/xudrpc_pb.d.ts +++ b/lib/proto/xudrpc_pb.d.ts @@ -165,6 +165,9 @@ export class BalanceAlert extends jspb.Message { getSide(): BalanceAlert.Side; setSide(value: BalanceAlert.Side): BalanceAlert; + getBound(): number; + setBound(value: number): BalanceAlert; + getPercent(): number; setPercent(value: number): BalanceAlert; @@ -189,6 +192,7 @@ export namespace BalanceAlert { export type AsObject = { totalBalance: number, side: BalanceAlert.Side, + bound: number, percent: number, sideBalance: number, currency: string, diff --git a/lib/proto/xudrpc_pb.js b/lib/proto/xudrpc_pb.js index cb7240242..2c2e48149 100644 --- a/lib/proto/xudrpc_pb.js +++ b/lib/proto/xudrpc_pb.js @@ -2911,9 +2911,10 @@ proto.xudrpc.BalanceAlert.toObject = function(includeInstance, msg) { var f, obj = { totalBalance: jspb.Message.getFieldWithDefault(msg, 1, 0), side: jspb.Message.getFieldWithDefault(msg, 2, 0), - percent: jspb.Message.getFieldWithDefault(msg, 3, 0), - sideBalance: jspb.Message.getFieldWithDefault(msg, 4, 0), - currency: jspb.Message.getFieldWithDefault(msg, 5, "") + bound: jspb.Message.getFieldWithDefault(msg, 3, 0), + percent: jspb.Message.getFieldWithDefault(msg, 4, 0), + sideBalance: jspb.Message.getFieldWithDefault(msg, 5, 0), + currency: jspb.Message.getFieldWithDefault(msg, 6, "") }; if (includeInstance) { @@ -2960,13 +2961,17 @@ proto.xudrpc.BalanceAlert.deserializeBinaryFromReader = function(msg, reader) { break; case 3: var value = /** @type {number} */ (reader.readUint32()); - msg.setPercent(value); + msg.setBound(value); break; case 4: + var value = /** @type {number} */ (reader.readUint32()); + msg.setPercent(value); + break; + case 5: var value = /** @type {number} */ (reader.readUint64()); msg.setSideBalance(value); break; - case 5: + case 6: var value = /** @type {string} */ (reader.readString()); msg.setCurrency(value); break; @@ -3013,24 +3018,31 @@ proto.xudrpc.BalanceAlert.serializeBinaryToWriter = function(message, writer) { f ); } - f = message.getPercent(); + f = message.getBound(); if (f !== 0) { writer.writeUint32( 3, f ); } + f = message.getPercent(); + if (f !== 0) { + writer.writeUint32( + 4, + f + ); + } f = message.getSideBalance(); if (f !== 0) { writer.writeUint64( - 4, + 5, f ); } f = message.getCurrency(); if (f.length > 0) { writer.writeString( - 5, + 6, f ); } @@ -3082,10 +3094,10 @@ proto.xudrpc.BalanceAlert.prototype.setSide = function(value) { /** - * optional uint32 percent = 3; + * optional uint32 bound = 3; * @return {number} */ -proto.xudrpc.BalanceAlert.prototype.getPercent = function() { +proto.xudrpc.BalanceAlert.prototype.getBound = function() { return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); }; @@ -3094,16 +3106,16 @@ proto.xudrpc.BalanceAlert.prototype.getPercent = function() { * @param {number} value * @return {!proto.xudrpc.BalanceAlert} returns this */ -proto.xudrpc.BalanceAlert.prototype.setPercent = function(value) { +proto.xudrpc.BalanceAlert.prototype.setBound = function(value) { return jspb.Message.setProto3IntField(this, 3, value); }; /** - * optional uint64 side_balance = 4; + * optional uint32 percent = 4; * @return {number} */ -proto.xudrpc.BalanceAlert.prototype.getSideBalance = function() { +proto.xudrpc.BalanceAlert.prototype.getPercent = function() { return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); }; @@ -3112,17 +3124,35 @@ proto.xudrpc.BalanceAlert.prototype.getSideBalance = function() { * @param {number} value * @return {!proto.xudrpc.BalanceAlert} returns this */ -proto.xudrpc.BalanceAlert.prototype.setSideBalance = function(value) { +proto.xudrpc.BalanceAlert.prototype.setPercent = function(value) { return jspb.Message.setProto3IntField(this, 4, value); }; /** - * optional string currency = 5; + * optional uint64 side_balance = 5; + * @return {number} + */ +proto.xudrpc.BalanceAlert.prototype.getSideBalance = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; + + +/** + * @param {number} value + * @return {!proto.xudrpc.BalanceAlert} returns this + */ +proto.xudrpc.BalanceAlert.prototype.setSideBalance = function(value) { + return jspb.Message.setProto3IntField(this, 5, value); +}; + + +/** + * optional string currency = 6; * @return {string} */ proto.xudrpc.BalanceAlert.prototype.getCurrency = function() { - return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "")); + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, "")); }; @@ -3131,7 +3161,7 @@ proto.xudrpc.BalanceAlert.prototype.getCurrency = function() { * @return {!proto.xudrpc.BalanceAlert} returns this */ proto.xudrpc.BalanceAlert.prototype.setCurrency = function(value) { - return jspb.Message.setProto3StringField(this, 5, value); + return jspb.Message.setProto3StringField(this, 6, value); }; diff --git a/proto/xudrpc.proto b/proto/xudrpc.proto index d636b9da5..eb17dc7f2 100644 --- a/proto/xudrpc.proto +++ b/proto/xudrpc.proto @@ -448,12 +448,14 @@ message BalanceAlert { LOCAL = 1; } Side side = 2 [json_name = "side"]; + // The bound of the low balance in percentage. + uint32 bound = 3 [json_name = "bound"]; // The percent of the total trading balance. - uint32 percent = 3 [json_name = "percent"]; + uint32 percent = 4 [json_name = "percent"]; // The current side balance. - uint64 side_balance = 4 [json_name = "side_balance"]; + uint64 side_balance = 5 [json_name = "side_balance"]; // The currency of the channel this alert is for. - string currency = 5 [json_name = "currency"]; + string currency = 6 [json_name = "currency"]; } message BanRequest { diff --git a/test/simulation/xudrpc/xudrpc.pb.go b/test/simulation/xudrpc/xudrpc.pb.go index 32f088f08..1d6807b5a 100644 --- a/test/simulation/xudrpc/xudrpc.pb.go +++ b/test/simulation/xudrpc/xudrpc.pb.go @@ -514,12 +514,14 @@ type BalanceAlert struct { // The total balance. TotalBalance uint64 `protobuf:"varint,1,opt,name=total_balance,proto3" json:"total_balance,omitempty"` Side BalanceAlert_Side `protobuf:"varint,2,opt,name=side,proto3,enum=xudrpc.BalanceAlert_Side" json:"side,omitempty"` + // The bound of the low balance in percentage. + Bound uint32 `protobuf:"varint,3,opt,name=bound,proto3" json:"bound,omitempty"` // The percent of the total trading balance. - Percent uint32 `protobuf:"varint,3,opt,name=percent,proto3" json:"percent,omitempty"` + Percent uint32 `protobuf:"varint,4,opt,name=percent,proto3" json:"percent,omitempty"` // The current side balance. - SideBalance uint64 `protobuf:"varint,4,opt,name=side_balance,proto3" json:"side_balance,omitempty"` + SideBalance uint64 `protobuf:"varint,5,opt,name=side_balance,proto3" json:"side_balance,omitempty"` // The currency of the channel this alert is for. - Currency string `protobuf:"bytes,5,opt,name=currency,proto3" json:"currency,omitempty"` + Currency string `protobuf:"bytes,6,opt,name=currency,proto3" json:"currency,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -564,6 +566,13 @@ func (m *BalanceAlert) GetSide() BalanceAlert_Side { return BalanceAlert_REMOTE } +func (m *BalanceAlert) GetBound() uint32 { + if m != nil { + return m.Bound + } + return 0 +} + func (m *BalanceAlert) GetPercent() uint32 { if m != nil { return m.Percent @@ -5124,285 +5133,286 @@ func init() { func init() { proto.RegisterFile("xudrpc.proto", fileDescriptor_6960a02cc0a63cf6) } var fileDescriptor_6960a02cc0a63cf6 = []byte{ - // 4444 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x4d, 0x8f, 0x1c, 0x49, - 0x56, 0x9d, 0xf5, 0xd1, 0x55, 0xfd, 0xea, 0xa3, 0xab, 0xa3, 0x3f, 0x5c, 0x2e, 0x7f, 0x8c, 0x37, - 0xb0, 0x47, 0x1e, 0x7b, 0xc6, 0x36, 0x3d, 0x2c, 0xb3, 0xe3, 0x5d, 0x8f, 0xa6, 0xbb, 0x5d, 0x6b, - 0x7b, 0xa6, 0xa6, 0xdb, 0xca, 0xb6, 0xc7, 0x66, 0x05, 0x9b, 0xca, 0xca, 0x0c, 0x77, 0x27, 0xce, - 0xce, 0xac, 0xc9, 0xcc, 0x72, 0xbb, 0xe1, 0x82, 0x56, 0x9c, 0x40, 0x88, 0x03, 0xe2, 0x0c, 0x27, - 0x84, 0x04, 0xe2, 0xca, 0x09, 0x89, 0x33, 0x37, 0xc4, 0x01, 0x09, 0x71, 0x41, 0xe2, 0x17, 0x20, - 0xc4, 0x0d, 0x09, 0xc5, 0x57, 0x46, 0x44, 0x66, 0x56, 0xaf, 0x3d, 0x02, 0x2e, 0xad, 0x8a, 0x17, - 0x2f, 0xdf, 0x8b, 0x78, 0x5f, 0xf1, 0xde, 0x8b, 0x68, 0xe8, 0xbe, 0x9d, 0xfb, 0xc9, 0xcc, 0xbb, - 0x33, 0x4b, 0xe2, 0x2c, 0x46, 0xcb, 0x7c, 0x34, 0x5a, 0x73, 0xa3, 0x28, 0xce, 0xdc, 0x2c, 0x88, - 0xa3, 0x94, 0x4f, 0xe1, 0x4d, 0x58, 0xdf, 0xf1, 0xfd, 0xbd, 0x79, 0x92, 0x90, 0xc8, 0x3b, 0xb3, - 0x49, 0x3a, 0x8b, 0xa3, 0x94, 0xe0, 0x9f, 0x43, 0x7f, 0xc7, 0xf7, 0x9f, 0xba, 0x41, 0x62, 0x93, - 0xef, 0xe6, 0x24, 0xcd, 0xd0, 0x75, 0xe8, 0x4d, 0xdd, 0x94, 0x38, 0x9e, 0x40, 0x1d, 0x5a, 0xd7, - 0xac, 0x9b, 0x2b, 0xb6, 0x09, 0x44, 0x1f, 0x42, 0xff, 0xbb, 0x79, 0x9c, 0x69, 0x68, 0x35, 0x86, - 0x56, 0x80, 0xe2, 0x35, 0x58, 0xcd, 0xe9, 0x0b, 0x96, 0xff, 0x68, 0x41, 0x73, 0x27, 0x24, 0x49, - 0x86, 0x6e, 0x43, 0x23, 0x3b, 0x9b, 0x11, 0xc6, 0xa1, 0xbf, 0x7d, 0xe1, 0x8e, 0xd8, 0x0b, 0x9b, - 0xe4, 0x7f, 0x9f, 0x9d, 0xcd, 0x88, 0xcd, 0x90, 0xd0, 0x10, 0x5a, 0x27, 0x24, 0x4d, 0xdd, 0x23, - 0x22, 0x58, 0xc9, 0x21, 0x42, 0xd0, 0xf0, 0xdd, 0x8c, 0x0c, 0xeb, 0xd7, 0xac, 0x9b, 0x75, 0x9b, - 0xfd, 0x46, 0x3f, 0xa1, 0xbb, 0x08, 0xdd, 0xc8, 0x23, 0x8e, 0x4b, 0x09, 0x0d, 0x1b, 0xd7, 0xac, - 0x9b, 0x9d, 0xed, 0x0d, 0xc9, 0x63, 0x97, 0x4f, 0x32, 0x26, 0x8f, 0x97, 0x6c, 0x13, 0x19, 0x5f, - 0x87, 0x95, 0x9c, 0x3d, 0xba, 0x00, 0xeb, 0x93, 0x83, 0x17, 0xce, 0x33, 0x7b, 0xe7, 0xe1, 0x93, - 0xfd, 0x47, 0xce, 0xee, 0xce, 0x64, 0x67, 0x7f, 0x6f, 0x3c, 0x58, 0xda, 0x5d, 0x81, 0xd6, 0xcc, - 0x3d, 0x0b, 0x63, 0xd7, 0xc7, 0x7f, 0x5b, 0x83, 0x96, 0x20, 0x49, 0x05, 0x98, 0xc5, 0x99, 0x1b, - 0x3a, 0x82, 0x26, 0xdb, 0x5e, 0xc3, 0x36, 0x81, 0xe8, 0x26, 0xac, 0x7a, 0xc7, 0x6e, 0x14, 0x11, - 0x85, 0x57, 0x63, 0x78, 0x45, 0x30, 0xfa, 0x11, 0x5c, 0x98, 0x91, 0xc8, 0x0f, 0xa2, 0x23, 0xa7, - 0xf8, 0x45, 0x9d, 0x7d, 0xb1, 0x68, 0x1a, 0xdd, 0x87, 0x61, 0x10, 0xb9, 0x5e, 0x16, 0xbc, 0x21, - 0xa5, 0x4f, 0x1b, 0xec, 0xd3, 0x85, 0xf3, 0x54, 0xc1, 0xa7, 0x6e, 0x18, 0x92, 0x2c, 0xff, 0xa2, - 0xc9, 0xbe, 0x28, 0x40, 0xd1, 0x17, 0x30, 0x9a, 0x47, 0x5e, 0x1c, 0xbd, 0x0a, 0x92, 0x13, 0xe2, - 0x3b, 0x85, 0x6f, 0x96, 0xd9, 0x37, 0xe7, 0x60, 0xe0, 0x7f, 0xb5, 0xa0, 0xab, 0x2b, 0xe3, 0x1d, - 0xc5, 0xf7, 0x09, 0x34, 0xd2, 0xc0, 0xe7, 0x32, 0xeb, 0x6f, 0x5f, 0xac, 0x52, 0xeb, 0x9d, 0xc3, - 0xc0, 0x27, 0x36, 0x43, 0xa3, 0xc6, 0x33, 0x23, 0x89, 0x47, 0xa2, 0x8c, 0xc9, 0xac, 0x67, 0xcb, - 0x21, 0xc2, 0xd0, 0xa5, 0x18, 0x05, 0xb9, 0x18, 0x30, 0x34, 0x82, 0x76, 0x6e, 0xe6, 0x4d, 0x66, - 0x7b, 0xf9, 0x18, 0x5f, 0x81, 0x06, 0xe5, 0x83, 0x00, 0x96, 0xed, 0xf1, 0x37, 0x07, 0xcf, 0xc6, - 0x83, 0x25, 0xb4, 0x02, 0xcd, 0xc9, 0xc1, 0xde, 0xce, 0x64, 0x60, 0xe1, 0x5f, 0x07, 0xd8, 0x75, - 0x23, 0xe9, 0x5b, 0x37, 0x61, 0x35, 0x8a, 0x7d, 0xe2, 0x04, 0x3e, 0x89, 0xb2, 0xe0, 0x55, 0x40, - 0x12, 0xe1, 0x5d, 0x45, 0x30, 0xee, 0x41, 0x87, 0x7d, 0x27, 0x7c, 0xe6, 0x33, 0x68, 0xee, 0x1d, - 0xbb, 0x41, 0x84, 0x36, 0xa0, 0xe9, 0xd1, 0x1f, 0xe2, 0x3b, 0x3e, 0xa0, 0xdb, 0x8b, 0x48, 0x76, - 0x1a, 0x27, 0xaf, 0xa5, 0x6f, 0x88, 0x21, 0x9e, 0x41, 0x7b, 0x8f, 0x6b, 0x36, 0x45, 0x5b, 0xb0, - 0xcc, 0x95, 0xcd, 0x3e, 0xee, 0xd9, 0x62, 0x44, 0xb7, 0x27, 0xcd, 0x80, 0x7d, 0xde, 0xb3, 0xf3, - 0x31, 0x17, 0x1c, 0xb3, 0x2e, 0x25, 0x38, 0x36, 0xa4, 0xd4, 0xbc, 0x30, 0x4e, 0x89, 0xcf, 0x44, - 0xd6, 0xb3, 0xc5, 0x08, 0x3b, 0xb0, 0x49, 0x39, 0x1e, 0x91, 0xa7, 0x6e, 0x9a, 0x9e, 0xc6, 0x89, - 0x2f, 0x37, 0x8f, 0xa1, 0x1b, 0x91, 0x53, 0x67, 0x26, 0xc0, 0x62, 0x07, 0x06, 0x8c, 0xe2, 0xc4, - 0xa1, 0xaf, 0x70, 0xf8, 0x6e, 0x0c, 0x18, 0x1e, 0xc2, 0x56, 0x91, 0x81, 0x90, 0xd2, 0xdf, 0x59, - 0xb0, 0xbe, 0x47, 0x57, 0x21, 0xb6, 0xfc, 0xde, 0x62, 0x37, 0x34, 0x5d, 0x33, 0x35, 0x4d, 0x45, - 0xff, 0x2a, 0x4e, 0x84, 0xd7, 0xb5, 0x6d, 0x3e, 0x40, 0xd7, 0xa0, 0xe3, 0x93, 0x34, 0x0b, 0x22, - 0x16, 0x6d, 0x99, 0x2c, 0x56, 0x6c, 0x1d, 0xc4, 0xc4, 0x7e, 0x12, 0xcf, 0xa3, 0x4c, 0x78, 0x90, - 0x18, 0xa1, 0x01, 0xd4, 0x5f, 0x11, 0xe9, 0x22, 0xf4, 0x27, 0xfe, 0x12, 0x36, 0xcc, 0xe5, 0xf3, - 0x7d, 0xd1, 0xf5, 0x67, 0x89, 0x1b, 0xa5, 0x54, 0x27, 0x71, 0xe4, 0x04, 0x7e, 0x3a, 0xb4, 0xae, - 0xd5, 0xe9, 0xfa, 0x0b, 0x60, 0xfc, 0x31, 0xf4, 0xf7, 0xe2, 0x28, 0x22, 0x5e, 0x26, 0xf7, 0x3e, - 0x82, 0x36, 0xdb, 0xe4, 0x3c, 0x09, 0xc4, 0xa6, 0xf3, 0x31, 0x0d, 0xce, 0x39, 0xb6, 0x10, 0xe1, - 0x5d, 0x58, 0xdb, 0x4b, 0x88, 0x9b, 0x91, 0xfd, 0xd8, 0x27, 0x1a, 0x8d, 0x82, 0xd6, 0xf2, 0x31, - 0xfe, 0x53, 0x0b, 0x90, 0xfe, 0x85, 0x58, 0xf2, 0xaf, 0x40, 0x2f, 0x25, 0xc4, 0x77, 0x4e, 0x22, - 0x72, 0x12, 0x47, 0x81, 0x27, 0x16, 0xdc, 0xa5, 0xc0, 0x6f, 0x04, 0x0c, 0x7d, 0x04, 0x83, 0x20, - 0x0a, 0xb2, 0xc0, 0x0d, 0x83, 0xdf, 0x21, 0xbe, 0x13, 0x46, 0x7e, 0x3a, 0xac, 0xf1, 0x8d, 0x69, - 0xf0, 0x49, 0xe4, 0xa7, 0xe8, 0x2e, 0xac, 0xeb, 0xa8, 0x1e, 0x5d, 0xf6, 0xdb, 0x4c, 0xa8, 0x02, - 0x69, 0x53, 0x7b, 0x7c, 0x06, 0xff, 0xb3, 0x05, 0x6d, 0x79, 0xda, 0x19, 0x6a, 0xb5, 0x0a, 0x6a, - 0x7d, 0x00, 0x9d, 0xf4, 0xd4, 0x9d, 0x39, 0x5e, 0x18, 0xd0, 0xf0, 0xc0, 0x03, 0xca, 0x25, 0x19, - 0x50, 0x24, 0x89, 0x3b, 0x87, 0xa7, 0xee, 0x6c, 0x8f, 0xa1, 0xd8, 0x3a, 0x3e, 0x0f, 0x57, 0xaf, - 0x49, 0xe4, 0xb8, 0xbe, 0x9f, 0x90, 0x34, 0x65, 0x4b, 0x5a, 0xb1, 0x4d, 0x20, 0x8d, 0xa6, 0x3e, - 0xf1, 0x82, 0x13, 0x37, 0x74, 0x66, 0xa1, 0xeb, 0x91, 0x54, 0x38, 0x4d, 0x01, 0x8a, 0x31, 0x80, - 0x62, 0x84, 0x5a, 0x50, 0x9f, 0xec, 0x3f, 0x1c, 0x2c, 0xa1, 0x0e, 0xb4, 0xf6, 0x0e, 0xf6, 0xf7, - 0xc7, 0x2f, 0x9f, 0x0d, 0x6a, 0x54, 0xc7, 0x0f, 0xc9, 0x2c, 0x4e, 0x03, 0x5d, 0xc7, 0x8b, 0xb6, - 0x87, 0x6f, 0xc3, 0x6a, 0x8e, 0x2d, 0x74, 0x33, 0x84, 0x96, 0x5c, 0x2c, 0xc7, 0x96, 0x43, 0x6a, - 0x80, 0x0f, 0x83, 0xd4, 0x8b, 0xdf, 0x90, 0x84, 0x6a, 0x33, 0x7d, 0xff, 0xb8, 0xf5, 0x43, 0xd8, - 0x2c, 0x50, 0x10, 0x4c, 0x2f, 0xc3, 0x4a, 0x34, 0x3f, 0x71, 0x28, 0x7e, 0x2a, 0xe2, 0x8f, 0x02, - 0xe0, 0x3f, 0xb0, 0x00, 0x8d, 0xdf, 0x12, 0x6f, 0x9e, 0x11, 0xba, 0x7f, 0x6d, 0x63, 0x71, 0xe2, - 0x93, 0xc4, 0x09, 0x72, 0xc3, 0x93, 0x63, 0x16, 0x99, 0xdc, 0x80, 0x4d, 0x89, 0x98, 0x27, 0x86, - 0x34, 0x88, 0xcc, 0x08, 0x49, 0x9c, 0xd9, 0x7c, 0xea, 0xbc, 0x26, 0x67, 0x42, 0x23, 0x06, 0x8c, - 0x52, 0xfe, 0x6e, 0xee, 0x46, 0x59, 0x90, 0x9d, 0x89, 0x90, 0x9f, 0x8f, 0xa9, 0x0f, 0x3c, 0x22, - 0x99, 0x38, 0x4a, 0xde, 0x45, 0xc6, 0x7f, 0x69, 0x01, 0xd2, 0xbf, 0x10, 0x5b, 0x7e, 0x08, 0x6d, - 0x71, 0x82, 0x70, 0x7f, 0xed, 0x6c, 0xdf, 0x94, 0x66, 0x55, 0xc6, 0x96, 0x47, 0x57, 0x3a, 0x8e, - 0xb2, 0xe4, 0xcc, 0xce, 0xbf, 0x1c, 0x4d, 0xa0, 0x67, 0x4c, 0xd1, 0xb8, 0x41, 0x77, 0xc5, 0x17, - 0x41, 0x7f, 0xa2, 0x1b, 0xd0, 0x7c, 0xe3, 0x86, 0x73, 0x1e, 0xbd, 0x3b, 0xdb, 0xab, 0x85, 0xd3, - 0xd0, 0xe6, 0xb3, 0xf7, 0x6b, 0x3f, 0xb2, 0xf0, 0x00, 0xfa, 0x8f, 0x48, 0xf6, 0x24, 0x7a, 0x15, - 0x8b, 0x8d, 0xe1, 0x7f, 0xa9, 0xc3, 0x6a, 0x0e, 0x52, 0x16, 0xf2, 0x86, 0x24, 0x29, 0x0d, 0x68, - 0xc2, 0x42, 0xc4, 0x90, 0x05, 0x71, 0xaa, 0x72, 0x29, 0x5b, 0x11, 0xa0, 0x75, 0x18, 0xcd, 0xc7, - 0xe6, 0x49, 0x40, 0x3d, 0x81, 0xba, 0x32, 0xfb, 0x2d, 0xd5, 0x4f, 0x75, 0x20, 0x6d, 0x5f, 0x01, - 0xf2, 0x59, 0x37, 0x48, 0x52, 0x16, 0x25, 0xe5, 0x2c, 0x05, 0xa0, 0xdb, 0xb0, 0xcc, 0xb4, 0x9e, - 0xb2, 0x58, 0xd9, 0xd9, 0x5e, 0x97, 0xfb, 0x3b, 0x60, 0xd0, 0x3d, 0x1a, 0x4d, 0x6d, 0x81, 0x82, - 0xb6, 0xa1, 0x1e, 0x46, 0xfe, 0xb0, 0xc5, 0xe4, 0x7d, 0x4d, 0x93, 0xb7, 0xbe, 0xc1, 0x3b, 0x93, - 0xc8, 0xe7, 0x72, 0xa6, 0xc8, 0x34, 0xb2, 0xbb, 0x61, 0xe0, 0xa6, 0xc3, 0x15, 0x7e, 0xa8, 0xb2, - 0x81, 0x7e, 0xa8, 0x82, 0x71, 0xa8, 0xa2, 0x7b, 0xb0, 0x2e, 0x53, 0x2e, 0x16, 0x0a, 0x8e, 0xdd, - 0xf4, 0x98, 0xa4, 0xc3, 0x0e, 0xdb, 0x6f, 0xd5, 0x14, 0xfa, 0x04, 0x5a, 0x32, 0x64, 0x75, 0xcd, - 0x3d, 0x88, 0x78, 0xc5, 0x56, 0x27, 0x71, 0x46, 0x8f, 0xa0, 0x2d, 0x57, 0xf8, 0x1e, 0xea, 0x9e, - 0x44, 0x3e, 0x23, 0xa3, 0xa9, 0x7b, 0x83, 0x19, 0xa6, 0x0c, 0xb8, 0x52, 0xe5, 0x3f, 0x86, 0x75, - 0x03, 0x2a, 0xb4, 0x7e, 0xbd, 0x3a, 0x66, 0x9b, 0x40, 0xfc, 0x05, 0x23, 0x49, 0x9d, 0x5b, 0xb3, - 0xa2, 0xf7, 0x88, 0x10, 0x36, 0x63, 0xae, 0xbe, 0xcf, 0x0f, 0x8c, 0xd5, 0x84, 0xcc, 0xe6, 0xbc, - 0x68, 0x39, 0xf4, 0xe2, 0x84, 0x67, 0x29, 0x6b, 0x36, 0x28, 0x30, 0x3d, 0x4a, 0xa7, 0xf4, 0x68, - 0xe4, 0x2e, 0xdf, 0xb6, 0xc5, 0x08, 0x5f, 0x80, 0xcd, 0x49, 0x90, 0x66, 0x22, 0x58, 0x07, 0x79, - 0xe0, 0xc2, 0x5f, 0xc1, 0x56, 0x71, 0x42, 0xf0, 0xbb, 0x07, 0xe0, 0xe5, 0x50, 0xe1, 0x9e, 0x83, - 0x62, 0xd4, 0xb7, 0x35, 0x1c, 0xfc, 0x0f, 0x16, 0xac, 0x51, 0x62, 0xdc, 0xea, 0xe4, 0xc6, 0xb5, - 0x30, 0x64, 0x99, 0x61, 0xe8, 0x87, 0xd0, 0x8c, 0x4f, 0x23, 0x92, 0x88, 0x23, 0xe5, 0x83, 0x5c, - 0x4d, 0x45, 0x1a, 0x77, 0x0e, 0x28, 0x9a, 0xcd, 0xb1, 0xa9, 0x31, 0x86, 0xc1, 0x49, 0x20, 0x13, - 0x55, 0x3e, 0xa0, 0xf2, 0x0d, 0x22, 0x2f, 0x9c, 0xfb, 0xb4, 0x44, 0x09, 0xdc, 0x54, 0x9c, 0x20, - 0x6d, 0xbb, 0x08, 0xc6, 0xd7, 0xa1, 0xc9, 0xe8, 0xa1, 0x36, 0x34, 0x76, 0x0f, 0x9e, 0x3d, 0x1e, - 0x2c, 0xd1, 0x73, 0xe4, 0xe0, 0xc5, 0xfe, 0xc0, 0xa2, 0xa0, 0xa7, 0xe3, 0xb1, 0x3d, 0xa8, 0xe1, - 0x3f, 0xb3, 0x00, 0xe9, 0x0b, 0x11, 0x52, 0xf9, 0x22, 0x77, 0x35, 0x2e, 0x91, 0x0f, 0xab, 0x16, - 0x2d, 0x7c, 0x88, 0x0f, 0xb9, 0x1b, 0x89, 0xaf, 0x46, 0x4f, 0xa0, 0xa3, 0x81, 0x2b, 0x6c, 0xf7, - 0xba, 0x69, 0xbb, 0x7d, 0xd3, 0x95, 0x75, 0xd3, 0x45, 0x30, 0xa0, 0x4c, 0x69, 0xe9, 0x98, 0xab, - 0xf3, 0x23, 0xae, 0x01, 0x01, 0x13, 0x6b, 0xde, 0x80, 0x26, 0x0f, 0x1c, 0xdc, 0x5c, 0xf9, 0x20, - 0xff, 0x9c, 0x28, 0x39, 0xe3, 0xcf, 0xc4, 0xe7, 0x44, 0xdf, 0x32, 0x86, 0x26, 0x8f, 0x4a, 0x7c, - 0xc7, 0x5d, 0xb9, 0x22, 0x8a, 0x65, 0xf3, 0x29, 0x5a, 0xa4, 0xb4, 0x84, 0x77, 0x51, 0x1b, 0x4c, - 0x33, 0x37, 0x9b, 0xcb, 0xc3, 0x53, 0x8c, 0xd0, 0xc7, 0xd0, 0x16, 0x35, 0x54, 0x2a, 0x36, 0xa7, - 0xcc, 0x49, 0xc0, 0xed, 0x1c, 0x03, 0xdd, 0x80, 0x65, 0x96, 0xba, 0xf3, 0x28, 0xd9, 0xd9, 0xee, - 0x69, 0xb8, 0x41, 0x64, 0x8b, 0x49, 0x9a, 0x5d, 0x4e, 0xc3, 0xd8, 0x7b, 0x7d, 0x4c, 0x82, 0xa3, - 0xe3, 0x4c, 0x04, 0x4e, 0x1d, 0x94, 0x07, 0xdb, 0xa6, 0x16, 0x6c, 0xb5, 0xf0, 0xbd, 0x6c, 0x86, - 0xef, 0x3c, 0xd2, 0xb5, 0xb4, 0x48, 0x87, 0xbf, 0x82, 0x3e, 0xf3, 0x47, 0x95, 0x07, 0x17, 0xc3, - 0xbc, 0x55, 0x11, 0xe6, 0x73, 0x5a, 0x35, 0x9d, 0xd6, 0x5f, 0x58, 0x80, 0x0e, 0x66, 0x24, 0xfa, - 0x3f, 0x49, 0xc1, 0x55, 0x2a, 0x5d, 0x37, 0x52, 0xe9, 0x6b, 0xd0, 0x99, 0xcd, 0xd3, 0x63, 0x47, - 0x4c, 0xf2, 0x03, 0x5d, 0x07, 0xc9, 0x64, 0xbb, 0xa9, 0x92, 0xed, 0x07, 0xb0, 0x6e, 0xac, 0x53, - 0x98, 0xc3, 0x87, 0xd0, 0x37, 0x93, 0x6a, 0xb1, 0xce, 0x02, 0x14, 0xff, 0x7d, 0x0d, 0x9a, 0xcc, - 0x68, 0x99, 0xfd, 0x25, 0x81, 0x28, 0x54, 0x2d, 0x9b, 0x0f, 0x8c, 0x04, 0xa3, 0x66, 0x26, 0x18, - 0x7a, 0xcc, 0xa8, 0x9b, 0x31, 0xa3, 0x0f, 0xb5, 0xc0, 0x17, 0x45, 0x44, 0x2d, 0xf0, 0xd1, 0x97, - 0x65, 0xb1, 0x35, 0x99, 0x6d, 0x6d, 0x49, 0x7b, 0x31, 0x15, 0x57, 0x29, 0xce, 0x30, 0xf6, 0xdc, - 0x90, 0x32, 0xe3, 0xc6, 0x90, 0x8f, 0xd1, 0x55, 0x00, 0x8f, 0xa5, 0xee, 0xbe, 0xe3, 0x66, 0xcc, - 0x24, 0x1a, 0xb6, 0x06, 0x41, 0x37, 0x44, 0x91, 0xdd, 0x66, 0x01, 0x6c, 0xcd, 0xf0, 0x55, 0xad, - 0xb8, 0xc6, 0xd0, 0x0d, 0x52, 0x27, 0x3e, 0x8d, 0x1c, 0x16, 0x05, 0xd8, 0x29, 0xda, 0xb6, 0x0d, - 0x18, 0x35, 0xd3, 0xe3, 0x38, 0xf4, 0xd9, 0x49, 0xda, 0xb0, 0xd9, 0x6f, 0xfc, 0xe7, 0x16, 0x74, - 0x19, 0x2d, 0x9b, 0x9c, 0xc4, 0x6f, 0xdc, 0xd0, 0x90, 0x99, 0xb5, 0x58, 0x66, 0x85, 0x74, 0x4f, - 0x4f, 0x12, 0xeb, 0x85, 0x24, 0x51, 0xdf, 0x7d, 0xa3, 0xb0, 0xfb, 0xe2, 0xb2, 0x9b, 0xe5, 0x65, - 0xe3, 0x63, 0x58, 0xe6, 0x91, 0x09, 0x7d, 0x02, 0x30, 0x9d, 0x9f, 0x39, 0x46, 0x74, 0xec, 0x19, - 0x12, 0xb1, 0x35, 0x04, 0x74, 0x17, 0x3a, 0x29, 0x09, 0x43, 0x89, 0x5f, 0xab, 0xc2, 0xd7, 0x31, - 0xf0, 0xa7, 0x32, 0x72, 0xb2, 0x74, 0x86, 0xca, 0x8b, 0x86, 0x1e, 0x91, 0x29, 0xb3, 0xdf, 0xd4, - 0x86, 0xe3, 0xd3, 0x48, 0x94, 0xe8, 0xf4, 0x27, 0xfe, 0x85, 0x25, 0xbe, 0x7a, 0x3e, 0x63, 0x5d, - 0xaf, 0x1b, 0xd0, 0xe4, 0x7b, 0xb1, 0x98, 0x91, 0x98, 0xfc, 0x1e, 0x2f, 0xd9, 0x7c, 0x16, 0xfd, - 0x04, 0x7a, 0x5c, 0x42, 0x09, 0x17, 0xbc, 0x88, 0x57, 0x1b, 0xe6, 0xf2, 0xf8, 0xdc, 0xe3, 0x25, - 0xdb, 0x44, 0xde, 0xed, 0x43, 0x97, 0x03, 0xe6, 0x8c, 0x29, 0xfe, 0xaf, 0x3a, 0x34, 0x68, 0xb0, - 0x5c, 0x5c, 0x57, 0xbc, 0x53, 0xd6, 0xf8, 0x25, 0x74, 0xc3, 0xc8, 0x97, 0x43, 0x19, 0x17, 0x2f, - 0xeb, 0xe1, 0x98, 0x66, 0x38, 0x4f, 0xe7, 0xd3, 0xaf, 0xc9, 0x99, 0x38, 0x76, 0x8c, 0x2f, 0x28, - 0xff, 0x20, 0x9a, 0xc6, 0xf3, 0xc8, 0x17, 0x67, 0xa3, 0x1c, 0xaa, 0x23, 0xa2, 0xa9, 0x1d, 0x11, - 0x34, 0x6a, 0xbc, 0x9d, 0xfb, 0x8e, 0x19, 0x2a, 0x75, 0x10, 0xfa, 0x18, 0xd6, 0x52, 0xe2, 0xc5, - 0x91, 0x9f, 0xf2, 0x8a, 0xd3, 0xcb, 0x88, 0xcf, 0xfc, 0xa4, 0x67, 0x97, 0x27, 0x16, 0xa4, 0x91, - 0xf7, 0xa0, 0x4d, 0x57, 0xc9, 0x82, 0x34, 0xb0, 0x3d, 0x6d, 0x14, 0xf7, 0xf4, 0x3c, 0x09, 0x52, - 0x3b, 0xc7, 0x42, 0x77, 0x00, 0x89, 0x44, 0x50, 0xf7, 0xfb, 0x0e, 0x23, 0x5a, 0x31, 0x33, 0x7a, - 0x00, 0xab, 0x05, 0xc1, 0x54, 0x1c, 0xbc, 0x1b, 0xfa, 0xc1, 0xbb, 0xa2, 0x1d, 0xb4, 0xa3, 0xcf, - 0xd8, 0xd9, 0x46, 0xd7, 0x70, 0x6e, 0x9d, 0x3c, 0x80, 0xfa, 0x3c, 0x09, 0x44, 0x7d, 0x4e, 0x7f, - 0xe2, 0xdf, 0xab, 0xc1, 0xda, 0x53, 0x5a, 0xb7, 0x0a, 0x7b, 0xe1, 0x91, 0xfe, 0x7f, 0x33, 0x1c, - 0xea, 0xae, 0xdd, 0x28, 0xb8, 0xb6, 0x0c, 0x4e, 0xcd, 0xf3, 0x83, 0xd3, 0x2d, 0x18, 0x24, 0x84, - 0x55, 0xd7, 0x4e, 0x4e, 0x8a, 0x6b, 0xba, 0x04, 0xa7, 0x79, 0x7d, 0x70, 0x72, 0x42, 0xfc, 0xc0, - 0xcd, 0x28, 0xd4, 0xf1, 0x68, 0xf5, 0x14, 0x32, 0x85, 0xb7, 0xed, 0xaa, 0x29, 0x2a, 0x02, 0xa4, - 0x8b, 0x40, 0x1c, 0x22, 0x9f, 0xc3, 0x20, 0x88, 0x32, 0x92, 0x44, 0x6e, 0xe8, 0x9c, 0xb8, 0x99, - 0x77, 0x4c, 0x16, 0x84, 0x8c, 0x12, 0x1a, 0xfa, 0x31, 0xf4, 0x59, 0xe1, 0x90, 0xce, 0x3d, 0x8f, - 0xa4, 0x34, 0xcf, 0xe3, 0xb1, 0x23, 0x2f, 0x18, 0x68, 0x7d, 0x7c, 0xc8, 0x27, 0xed, 0x02, 0x2a, - 0xfa, 0x8c, 0x26, 0xd1, 0x27, 0x6e, 0x10, 0xd1, 0xfa, 0x83, 0x47, 0x82, 0x7a, 0x45, 0x24, 0xb0, - 0x8b, 0x58, 0xe8, 0x73, 0xe8, 0x31, 0x52, 0xaf, 0xdc, 0x20, 0x9c, 0x27, 0x2c, 0xb9, 0x2c, 0x31, - 0xfd, 0x29, 0x9f, 0xb3, 0x4d, 0x4c, 0xfc, 0x1f, 0x16, 0xac, 0x2a, 0x11, 0x8c, 0xdf, 0x90, 0x88, - 0x1e, 0x1c, 0x4d, 0xb6, 0x9f, 0x85, 0x71, 0x88, 0xcd, 0xa2, 0xcf, 0xa1, 0xab, 0x6f, 0x40, 0x84, - 0xa1, 0xaa, 0x9d, 0x3e, 0x5e, 0xb2, 0x0d, 0x54, 0xf4, 0xf9, 0xbb, 0xed, 0xf4, 0xf1, 0x52, 0xd5, - 0x5e, 0xbb, 0xfa, 0x0e, 0xc4, 0xcd, 0x40, 0xd5, 0x56, 0x73, 0xae, 0x02, 0x75, 0xb7, 0x05, 0x4d, - 0x42, 0x37, 0x88, 0x63, 0xe8, 0x68, 0x85, 0xdb, 0xc2, 0x9c, 0x50, 0x8b, 0x88, 0x35, 0x33, 0x22, - 0x6a, 0x29, 0x5a, 0xa3, 0x94, 0xa2, 0xf1, 0x0e, 0x6f, 0x53, 0xeb, 0xf0, 0xe2, 0x4f, 0x61, 0x93, - 0x05, 0x64, 0xa2, 0x6e, 0x70, 0x7e, 0x79, 0x5f, 0x62, 0x08, 0x5b, 0xc5, 0x8f, 0x44, 0x9b, 0x6f, - 0x02, 0x88, 0xcf, 0x18, 0xae, 0x7b, 0x5e, 0xbb, 0xe5, 0x1c, 0x07, 0xc6, 0x7f, 0x65, 0xc1, 0xba, - 0x41, 0x4e, 0xb8, 0xc1, 0x55, 0x18, 0x48, 0x1c, 0x27, 0x8e, 0x1c, 0x96, 0x00, 0x58, 0x2a, 0x01, - 0xa0, 0x81, 0x4e, 0x29, 0xa7, 0x40, 0xbd, 0x62, 0x86, 0xfb, 0x32, 0x65, 0xe3, 0x2b, 0x6c, 0x9e, - 0x08, 0x96, 0xe0, 0x7a, 0x50, 0x69, 0x18, 0x41, 0x45, 0x49, 0x65, 0x27, 0x0c, 0x8d, 0x3a, 0x0c, - 0xcf, 0xe1, 0x42, 0x69, 0x46, 0x6c, 0xe5, 0x63, 0x58, 0x93, 0x2c, 0xa4, 0x48, 0x64, 0xc1, 0x51, - 0x9e, 0xa0, 0xd8, 0x62, 0xbf, 0x1a, 0x36, 0x8f, 0x9c, 0xe5, 0x09, 0xfc, 0x09, 0xac, 0x71, 0xb6, - 0xfa, 0x35, 0xdc, 0xc2, 0xba, 0x92, 0xd6, 0xf4, 0x3a, 0xba, 0xd0, 0xe8, 0xef, 0xd7, 0x28, 0x38, - 0xcd, 0xe2, 0xc4, 0x68, 0xdd, 0xbe, 0x53, 0x1f, 0x56, 0xef, 0xef, 0xd6, 0xcc, 0xfe, 0x2e, 0xfa, - 0x1a, 0x3a, 0xf4, 0x60, 0x9a, 0xba, 0xde, 0xeb, 0xf9, 0x4c, 0x9e, 0xca, 0xb7, 0xa4, 0xb3, 0x94, - 0x39, 0xd2, 0xf3, 0x6c, 0x97, 0x23, 0xf3, 0x33, 0x1a, 0xc2, 0x1c, 0x80, 0x7e, 0xc0, 0xee, 0x2b, - 0x1d, 0xdf, 0xcd, 0xdc, 0xa9, 0x9b, 0xf2, 0xde, 0x77, 0x97, 0x1d, 0xb9, 0x0f, 0x05, 0x48, 0x1c, - 0x66, 0x3a, 0x85, 0x5f, 0x76, 0x98, 0x75, 0xf5, 0xaa, 0x91, 0x50, 0x4b, 0xd4, 0xd6, 0xa4, 0xda, - 0xd1, 0x09, 0x07, 0x8b, 0x36, 0xb3, 0x10, 0x83, 0x04, 0xb2, 0x1e, 0xf3, 0x47, 0xd4, 0xbc, 0x04, - 0x92, 0xec, 0xd6, 0xf0, 0x3e, 0xc3, 0xaa, 0x84, 0xcb, 0xee, 0xf2, 0x43, 0x40, 0x87, 0x24, 0x9b, - 0xc4, 0x47, 0x13, 0xf2, 0x46, 0x15, 0x39, 0x77, 0x60, 0x25, 0x8c, 0x8f, 0x9c, 0x90, 0xc2, 0xc4, - 0xa5, 0x66, 0x5e, 0x03, 0xe6, 0xb8, 0x0a, 0x05, 0x6f, 0xc2, 0xba, 0x41, 0x45, 0xa8, 0x72, 0x0d, - 0x56, 0x0f, 0x8f, 0xe7, 0x99, 0x1f, 0x9f, 0xca, 0x8b, 0x23, 0x5a, 0xcd, 0x2a, 0x90, 0x40, 0xfb, - 0x35, 0xd8, 0x3a, 0x9c, 0x4f, 0x53, 0x2f, 0x09, 0xa6, 0xc4, 0xec, 0x49, 0x8c, 0xa0, 0x4d, 0xde, - 0x06, 0x69, 0x16, 0x44, 0x47, 0x6c, 0x19, 0x6d, 0x3b, 0x1f, 0x53, 0xeb, 0xcf, 0xbf, 0x62, 0xd7, - 0x64, 0xb9, 0xf5, 0x7f, 0x00, 0x57, 0xf2, 0x19, 0x1a, 0x04, 0xd3, 0x1d, 0xcf, 0x23, 0xb3, 0x8c, - 0xc8, 0x0b, 0x1c, 0xfc, 0x00, 0x36, 0x4d, 0x04, 0xed, 0xca, 0x58, 0x76, 0x21, 0x32, 0xf7, 0xb5, - 0x48, 0x3f, 0xdb, 0xb6, 0x09, 0xc4, 0xff, 0x5d, 0x83, 0x2e, 0xfd, 0x4c, 0x92, 0x45, 0x17, 0x4b, - 0xe1, 0xa6, 0xc5, 0xc6, 0x4f, 0xcc, 0xbc, 0xbd, 0x56, 0xc8, 0xdb, 0xcf, 0x4d, 0x17, 0x16, 0x35, - 0x75, 0x55, 0x5a, 0xd2, 0xd4, 0xd3, 0x92, 0x62, 0xab, 0x78, 0xb9, 0xa2, 0x55, 0xbc, 0x05, 0xcb, - 0x09, 0xeb, 0xe3, 0x89, 0xa2, 0x59, 0x8c, 0x68, 0x34, 0xe2, 0xc5, 0xa5, 0x93, 0x10, 0x8f, 0x04, - 0x6f, 0xa8, 0xb4, 0xdb, 0x3c, 0x1a, 0x15, 0xe1, 0xb4, 0xaa, 0x14, 0xb0, 0x54, 0xdc, 0xa6, 0xad, - 0xf0, 0xdb, 0x54, 0x13, 0xca, 0x52, 0x3f, 0x11, 0xab, 0x35, 0xaa, 0x20, 0x52, 0xbf, 0xd2, 0x0c, - 0x5d, 0x43, 0x0e, 0x95, 0x94, 0x79, 0xa2, 0x58, 0x82, 0xd3, 0x28, 0xdd, 0xd1, 0x0e, 0xb7, 0xef, - 0xd9, 0x5c, 0xd7, 0x65, 0x5c, 0x2f, 0xc8, 0xb8, 0x28, 0xcd, 0x46, 0x85, 0x34, 0x3f, 0x84, 0xbe, - 0x38, 0x4d, 0x9d, 0x84, 0xb8, 0x69, 0x2c, 0xcf, 0xb9, 0x02, 0x14, 0xff, 0x4d, 0x9d, 0xaf, 0x56, - 0x24, 0x00, 0xff, 0xbf, 0xc6, 0xa2, 0x54, 0xde, 0x34, 0x54, 0x7e, 0x13, 0x56, 0x0d, 0xd5, 0x12, - 0x5f, 0x68, 0xbc, 0x08, 0xa6, 0xb5, 0x85, 0x52, 0x6d, 0x26, 0xb4, 0xad, 0x83, 0x4a, 0xc2, 0x82, - 0x0a, 0x61, 0x5d, 0x83, 0x46, 0x12, 0x87, 0x84, 0xa9, 0xb4, 0xaf, 0x5a, 0x53, 0x76, 0x1c, 0x12, - 0x9b, 0xcd, 0xd0, 0x93, 0xa6, 0x60, 0x16, 0xc4, 0x67, 0x2d, 0xe6, 0x15, 0xbb, 0x3c, 0x41, 0x1d, - 0x55, 0x37, 0x8b, 0x6c, 0xd8, 0xe3, 0x97, 0x55, 0x06, 0x10, 0x5d, 0x05, 0x48, 0x9c, 0x59, 0x42, - 0x82, 0x13, 0xf7, 0x88, 0x0c, 0xfb, 0x0c, 0x45, 0x83, 0x28, 0x57, 0x5a, 0xd5, 0x5c, 0x09, 0xff, - 0x67, 0x0d, 0x9a, 0xcf, 0x12, 0xd7, 0x27, 0xb4, 0xf6, 0x3d, 0xa1, 0x1e, 0xef, 0x2c, 0xae, 0x45, - 0x6d, 0x1d, 0x83, 0x7e, 0x90, 0x69, 0x1f, 0xd4, 0x2a, 0x3f, 0xd0, 0x30, 0x34, 0xfd, 0xd4, 0x0d, - 0xfd, 0x9c, 0xa7, 0x53, 0xcd, 0x12, 0x9a, 0xa6, 0x25, 0xe4, 0xfb, 0x59, 0xd6, 0x43, 0x83, 0x94, - 0x7d, 0x6b, 0xa1, 0xec, 0xaf, 0x41, 0x87, 0xf0, 0x3b, 0x2b, 0xd6, 0x3f, 0xe1, 0x96, 0xa0, 0x83, - 0xf2, 0x1a, 0x65, 0xe5, 0xfc, 0x1a, 0xe5, 0x3e, 0x74, 0x3d, 0x6a, 0x18, 0x24, 0x99, 0xb9, 0x49, - 0xc6, 0x4d, 0x61, 0x71, 0x8b, 0xc7, 0xc0, 0xc5, 0xb7, 0x61, 0x9d, 0x49, 0xfd, 0x71, 0x40, 0x4f, - 0xa8, 0x33, 0xad, 0x0a, 0xe3, 0x5d, 0x64, 0x4b, 0xeb, 0x22, 0xe3, 0x07, 0xb0, 0x61, 0x22, 0x8b, - 0xe3, 0xf1, 0x06, 0x2c, 0x67, 0x14, 0x5e, 0xaa, 0x52, 0x18, 0xb6, 0x2d, 0x26, 0xf1, 0x1f, 0x5b, - 0xd0, 0xa3, 0x90, 0x20, 0x3a, 0x9a, 0x50, 0x7a, 0xac, 0x60, 0x3c, 0x71, 0xdf, 0x3a, 0x29, 0x09, - 0x43, 0xd9, 0xb1, 0x91, 0x63, 0xf6, 0x60, 0xc7, 0x7d, 0xeb, 0x4c, 0xe7, 0x32, 0xa5, 0x93, 0x43, - 0x6a, 0x86, 0x09, 0x49, 0x49, 0x42, 0x93, 0x26, 0xf6, 0x29, 0x0f, 0x24, 0x26, 0x90, 0x3a, 0x48, - 0x0e, 0xa0, 0x44, 0xc4, 0xcb, 0x0c, 0x1d, 0x86, 0xb7, 0xf9, 0x86, 0xf2, 0x05, 0xbd, 0x4b, 0x56, - 0xfc, 0xd7, 0x16, 0x6c, 0x16, 0x3e, 0x12, 0x62, 0xd8, 0x81, 0x65, 0x26, 0x27, 0x29, 0x86, 0x8f, - 0x74, 0x31, 0x94, 0xd0, 0xef, 0xf0, 0xa1, 0x68, 0x80, 0xf3, 0x0f, 0x47, 0x4f, 0xa1, 0xa3, 0x81, - 0x2b, 0x52, 0x97, 0xdb, 0x66, 0x03, 0x7c, 0xb3, 0x9a, 0x85, 0x96, 0xd1, 0x7c, 0x0b, 0xdd, 0xe7, - 0xd1, 0xf4, 0x7b, 0xbc, 0x21, 0x41, 0x97, 0x61, 0x25, 0x21, 0xa2, 0x3d, 0x21, 0x12, 0x19, 0x05, - 0xc0, 0xab, 0xd0, 0x13, 0x74, 0xd5, 0xd5, 0xff, 0xf3, 0x28, 0x8c, 0xbd, 0xd7, 0xef, 0x7a, 0xf5, - 0xff, 0x33, 0x40, 0xfa, 0x07, 0x2a, 0xd5, 0x9a, 0x33, 0x68, 0x21, 0xd5, 0x92, 0x40, 0x96, 0x6a, - 0x7d, 0x00, 0x1d, 0x1d, 0x85, 0xdf, 0x14, 0x82, 0x42, 0xc0, 0x7f, 0x68, 0xc1, 0xea, 0x8b, 0x20, - 0x3b, 0xf6, 0x13, 0xf7, 0xf4, 0x1d, 0x94, 0x5a, 0x7c, 0x86, 0x51, 0x3b, 0xef, 0x19, 0x46, 0xbd, - 0xf8, 0x0c, 0xc3, 0x0d, 0x43, 0xd1, 0x31, 0xa2, 0x3f, 0xf5, 0x5e, 0x71, 0x8f, 0xf7, 0x8a, 0xef, - 0xc3, 0x40, 0x2d, 0xe6, 0xfd, 0x1a, 0xc5, 0xb7, 0x6e, 0xc2, 0x4a, 0xee, 0xef, 0xa8, 0x05, 0xf5, - 0xdd, 0xe7, 0xbf, 0x31, 0x58, 0x42, 0x6d, 0x68, 0x1c, 0x8e, 0x27, 0x13, 0x7e, 0x27, 0xc3, 0xae, - 0x69, 0x6a, 0xb7, 0x6e, 0x41, 0x83, 0x46, 0x17, 0xb4, 0x02, 0xcd, 0x67, 0x3b, 0x5f, 0x8f, 0x6d, - 0xfe, 0x92, 0xe8, 0x1b, 0xf6, 0xd3, 0x42, 0x5d, 0x68, 0x3f, 0xd9, 0x7f, 0x36, 0xb6, 0xf7, 0x77, - 0x26, 0x83, 0xda, 0xad, 0x17, 0xd0, 0x96, 0x79, 0x23, 0x45, 0xda, 0x99, 0x8c, 0xed, 0x67, 0x1c, - 0x7f, 0x6c, 0xdb, 0x07, 0x36, 0xa7, 0xfb, 0x62, 0xc7, 0xde, 0x1f, 0xd4, 0xe8, 0xaf, 0x27, 0xfb, - 0x3f, 0x3d, 0x18, 0xd4, 0x51, 0x07, 0x5a, 0xdf, 0x8e, 0xed, 0xdd, 0x83, 0xc3, 0xf1, 0xa0, 0x41, - 0x71, 0x1f, 0x8e, 0x77, 0x9f, 0x3f, 0x1a, 0x34, 0x19, 0x47, 0x7b, 0x67, 0x6f, 0x3c, 0x58, 0xde, - 0xfe, 0x37, 0x0b, 0x5a, 0x2f, 0xe7, 0xfe, 0x93, 0x28, 0xc8, 0xd0, 0x18, 0x40, 0x3d, 0xed, 0x40, - 0xf9, 0x23, 0xab, 0xd2, 0x03, 0x91, 0xd1, 0xa8, 0x6a, 0x4a, 0x98, 0xd5, 0x12, 0x7a, 0x0c, 0x1d, - 0x2d, 0x27, 0x47, 0xa3, 0xc5, 0xc5, 0xc3, 0xe8, 0x52, 0xe5, 0x5c, 0x4e, 0x69, 0x0c, 0xa0, 0x2c, - 0x4e, 0x2d, 0xa8, 0x64, 0xb6, 0x6a, 0x41, 0x65, 0x03, 0xc5, 0x4b, 0xdb, 0x7f, 0x74, 0x09, 0xea, - 0x2f, 0xe7, 0x3e, 0x7a, 0x09, 0x1d, 0xed, 0x4d, 0x24, 0x2a, 0x5d, 0xff, 0xa9, 0xe5, 0x54, 0x3d, - 0x9d, 0x1c, 0xfd, 0xe2, 0x9f, 0xfe, 0xfd, 0x4f, 0x6a, 0x1b, 0x78, 0xf5, 0xee, 0x9b, 0x5f, 0xbd, - 0xeb, 0xfa, 0xbe, 0xb4, 0xc5, 0xfb, 0xd6, 0x2d, 0x64, 0x43, 0x4b, 0x3c, 0x7b, 0x44, 0x5b, 0x1a, - 0x0d, 0xad, 0xc0, 0x1b, 0x5d, 0x28, 0xc1, 0x05, 0xdd, 0x2d, 0x46, 0x77, 0x80, 0x3b, 0x82, 0x2e, - 0x3d, 0xa6, 0x28, 0xcd, 0x5d, 0xa8, 0xef, 0xba, 0x11, 0x42, 0xea, 0x76, 0x5f, 0xc6, 0x84, 0xd1, - 0xba, 0x01, 0x13, 0x74, 0x10, 0xa3, 0xd3, 0xc5, 0x2d, 0x4a, 0x67, 0xea, 0x46, 0x94, 0xc6, 0x11, - 0xf4, 0xcd, 0xb7, 0x53, 0xe8, 0x8a, 0x7e, 0x49, 0x55, 0x7a, 0xb4, 0x35, 0xba, 0xba, 0x68, 0xba, - 0xb0, 0xd8, 0x3e, 0x65, 0xe2, 0x31, 0x1c, 0x1a, 0x1f, 0x90, 0x07, 0x5d, 0xfd, 0x29, 0x13, 0x52, - 0x0f, 0x6a, 0xca, 0xef, 0xb3, 0x46, 0x97, 0xab, 0x27, 0x05, 0x8b, 0x21, 0x63, 0x81, 0xf0, 0x80, - 0xb1, 0xa0, 0x18, 0xe2, 0x16, 0x8d, 0x4a, 0x59, 0xbc, 0x5f, 0x52, 0x52, 0x36, 0x9f, 0x3f, 0x29, - 0x29, 0x17, 0x1f, 0x3a, 0x19, 0x52, 0x16, 0x31, 0x91, 0x4a, 0xe8, 0xe7, 0xd0, 0x7b, 0xc1, 0x5e, - 0x28, 0x8a, 0x57, 0x33, 0x8a, 0xb2, 0xf9, 0xe8, 0x46, 0x51, 0x2e, 0x3c, 0xaf, 0xc1, 0x97, 0x19, - 0xe5, 0x2d, 0xbc, 0x46, 0x29, 0xf3, 0xd7, 0x8e, 0x3e, 0x47, 0x11, 0x96, 0xf1, 0xbd, 0x29, 0x1b, - 0x6b, 0xd6, 0x68, 0xfe, 0x36, 0xf4, 0x8c, 0x47, 0x37, 0x28, 0x17, 0x68, 0xd5, 0x6b, 0x9e, 0xd1, - 0x95, 0x05, 0xb3, 0x55, 0xeb, 0xf7, 0x05, 0x0a, 0x7b, 0xa6, 0x43, 0x79, 0xbd, 0x04, 0x50, 0x8f, - 0x57, 0x94, 0x0b, 0x96, 0x1e, 0xcc, 0x28, 0x17, 0x2c, 0xbf, 0x75, 0xc1, 0xeb, 0x8c, 0x45, 0x0f, - 0x75, 0xb8, 0x69, 0x72, 0x5a, 0x13, 0x68, 0x89, 0x67, 0x1a, 0x4a, 0x32, 0xe6, 0x5b, 0x15, 0x25, - 0x99, 0xc2, 0x7b, 0x0e, 0x3c, 0x60, 0x04, 0x01, 0xb5, 0x29, 0xc1, 0x80, 0x92, 0xf8, 0x4d, 0xe8, - 0x68, 0x6f, 0x1c, 0x90, 0xbe, 0x9a, 0xc2, 0x73, 0x08, 0xe5, 0xe5, 0x15, 0x8f, 0x22, 0xf0, 0x06, - 0xa3, 0xdc, 0x47, 0x5d, 0x4a, 0x59, 0x76, 0x51, 0x04, 0x75, 0xf9, 0x88, 0xc1, 0xa0, 0x5e, 0x78, - 0x19, 0x61, 0x50, 0x2f, 0xbe, 0x7a, 0x30, 0xa9, 0x53, 0x19, 0xb3, 0xb5, 0xbf, 0x00, 0x50, 0xf7, - 0xed, 0x4a, 0xc6, 0xa5, 0x87, 0x03, 0x4a, 0xc6, 0xe5, 0xeb, 0x79, 0xe9, 0xfe, 0x08, 0x28, 0x69, - 0x71, 0x2b, 0x75, 0x04, 0x7d, 0xf3, 0x39, 0x84, 0x72, 0xff, 0xca, 0xf7, 0x13, 0xca, 0xfd, 0xab, - 0x5f, 0x51, 0x48, 0x8b, 0x44, 0xdc, 0xfd, 0x15, 0xd9, 0x43, 0x58, 0xc9, 0x2f, 0xea, 0xd1, 0x50, - 0x27, 0xa2, 0xdf, 0xe7, 0x8f, 0x2e, 0x56, 0xcc, 0xc8, 0x26, 0x08, 0xa3, 0xdc, 0x41, 0x2b, 0x94, - 0x32, 0xbf, 0xaf, 0x91, 0x44, 0xd9, 0x93, 0x21, 0x93, 0xa8, 0x76, 0xcb, 0x5f, 0x20, 0xaa, 0xdf, - 0xf5, 0x17, 0x88, 0x32, 0x3a, 0x0e, 0x74, 0xb4, 0x6b, 0x60, 0xa5, 0xc9, 0xf2, 0x1d, 0xb6, 0xd2, - 0x64, 0xc5, 0xbd, 0x31, 0xbe, 0xc0, 0x48, 0xaf, 0xf1, 0xd3, 0x20, 0x9e, 0x91, 0x48, 0x06, 0xa9, - 0xdf, 0x02, 0x50, 0xed, 0x71, 0xa5, 0xcc, 0xd2, 0xc5, 0x89, 0x32, 0xee, 0x42, 0x37, 0x1d, 0x5f, - 0x64, 0xa4, 0xd7, 0x79, 0x8c, 0x65, 0x57, 0x16, 0x4c, 0x9d, 0xf7, 0xad, 0x5b, 0xf7, 0x2c, 0xf4, - 0x0a, 0xfa, 0x0a, 0xff, 0xf0, 0x2c, 0xf2, 0xce, 0x63, 0x31, 0xaa, 0x9a, 0x12, 0x1b, 0xb8, 0xc2, - 0xb8, 0x5c, 0xc0, 0xc8, 0xe4, 0x92, 0x9e, 0x45, 0x1e, 0xf5, 0xfb, 0x9f, 0x41, 0x47, 0x7b, 0xa0, - 0xa7, 0xe4, 0x54, 0x7e, 0xb5, 0x37, 0xaa, 0x6a, 0xe0, 0x9b, 0xa7, 0xa5, 0xa8, 0x91, 0xd2, 0x53, - 0x77, 0x46, 0x69, 0x47, 0xd0, 0x37, 0xfb, 0xd4, 0xca, 0x2c, 0x2b, 0x9b, 0xde, 0xca, 0x2c, 0x17, - 0xb4, 0xb7, 0x8d, 0xbd, 0xf0, 0xf6, 0xac, 0x7e, 0x3a, 0x4f, 0x69, 0x42, 0x92, 0xb7, 0xab, 0xf5, - 0x84, 0xa4, 0xd8, 0x12, 0xd7, 0x13, 0x92, 0x52, 0x7f, 0xdb, 0xdc, 0x13, 0x67, 0x23, 0x35, 0x83, - 0x12, 0x58, 0x2d, 0xf4, 0x92, 0x51, 0x61, 0xd5, 0xc5, 0xf6, 0xf3, 0xe8, 0x83, 0x85, 0xf3, 0x82, - 0xdf, 0x55, 0xc6, 0x6f, 0x88, 0xd7, 0x15, 0x3f, 0x37, 0x0c, 0xb9, 0x9a, 0xf8, 0xd9, 0x05, 0xaa, - 0x33, 0xac, 0xec, 0xa0, 0xd4, 0x5c, 0x1e, 0x8d, 0xaa, 0xa6, 0x04, 0x13, 0xc3, 0xda, 0x38, 0x13, - 0x99, 0x81, 0x4c, 0xa1, 0xa3, 0xf5, 0x2b, 0x95, 0xdc, 0xca, 0xad, 0x50, 0x25, 0xb7, 0xaa, 0x06, - 0xa7, 0x21, 0xb7, 0x94, 0x64, 0x61, 0x7c, 0xc4, 0x1a, 0xa2, 0x94, 0xc7, 0xb7, 0xd0, 0x96, 0x9d, - 0x4e, 0x94, 0x7b, 0x44, 0xa1, 0x1d, 0x3a, 0x1a, 0x96, 0x27, 0x0a, 0x6e, 0xc8, 0x02, 0x6a, 0x2a, - 0x66, 0x29, 0x5d, 0x07, 0x56, 0x0b, 0x7d, 0x4f, 0xa5, 0x8f, 0xea, 0x86, 0xe8, 0xa8, 0x67, 0xfc, - 0x43, 0x0a, 0xbe, 0xc4, 0x48, 0x6f, 0x22, 0x26, 0xfd, 0x54, 0x7e, 0xc2, 0xfe, 0x61, 0x24, 0xbd, - 0x67, 0x21, 0xa2, 0x31, 0x28, 0x2a, 0xbc, 0xba, 0x4f, 0x3b, 0x32, 0x1f, 0x32, 0xf2, 0x3b, 0xfc, - 0x05, 0x6c, 0xb8, 0x92, 0xef, 0x59, 0x68, 0x56, 0x68, 0xc2, 0x8a, 0x6e, 0x9e, 0x16, 0xc9, 0x2b, - 0x7b, 0xb4, 0xa3, 0xaa, 0xfb, 0x2d, 0xfc, 0x03, 0xc6, 0xeb, 0x12, 0xba, 0x68, 0xf0, 0xa2, 0x6e, - 0x29, 0xaf, 0xf7, 0xee, 0x59, 0x68, 0x0a, 0x7d, 0x93, 0xe4, 0x7b, 0xb1, 0x2a, 0xf8, 0x3f, 0x42, - 0x25, 0x56, 0x94, 0xc7, 0xef, 0x6a, 0x5d, 0x69, 0xa3, 0xf7, 0x8c, 0x6e, 0x54, 0xf3, 0x2a, 0xf4, - 0xa6, 0x47, 0x1b, 0x3a, 0x4f, 0x39, 0x89, 0x31, 0x63, 0x7a, 0x19, 0x8d, 0xca, 0x4c, 0x5d, 0x81, - 0xc3, 0x42, 0x68, 0x57, 0xef, 0x8a, 0xa8, 0x5c, 0xb5, 0xa2, 0xb1, 0xa2, 0x72, 0xd5, 0xaa, 0x46, - 0x8a, 0x54, 0x1e, 0xcf, 0x55, 0x59, 0xd7, 0xe4, 0x98, 0x63, 0xf0, 0xe4, 0xbb, 0xd0, 0x3d, 0xb9, - 0xbc, 0xa0, 0xbf, 0x50, 0x48, 0xd3, 0x2a, 0xbb, 0x0f, 0xd2, 0x4f, 0xd1, 0x9a, 0x64, 0x15, 0x44, - 0x47, 0xbc, 0x09, 0x81, 0xbe, 0x82, 0x26, 0x2b, 0xed, 0xd1, 0x86, 0x2a, 0x83, 0x54, 0x07, 0x61, - 0xb4, 0x59, 0x80, 0x9a, 0xb9, 0x08, 0x66, 0x87, 0xe3, 0x3c, 0x12, 0x15, 0xc3, 0x14, 0xfa, 0x3c, - 0x1f, 0x96, 0x05, 0xb0, 0xf2, 0xca, 0x42, 0x7d, 0xae, 0xbc, 0xb2, 0x58, 0x2b, 0x9b, 0xf1, 0x98, - 0xa7, 0xc4, 0xa7, 0x02, 0xe7, 0xbe, 0x75, 0x6b, 0xba, 0xcc, 0xfe, 0x45, 0xed, 0xd3, 0xff, 0x09, - 0x00, 0x00, 0xff, 0xff, 0xe1, 0x30, 0x5e, 0x70, 0xcd, 0x36, 0x00, 0x00, + // 4455 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7b, 0xcd, 0x8f, 0x1c, 0x49, + 0x56, 0x78, 0x67, 0x7d, 0x74, 0x55, 0xbf, 0xfa, 0xe8, 0xea, 0xe8, 0x0f, 0x97, 0xcb, 0x1f, 0xe3, + 0x8d, 0x9f, 0x3d, 0xf2, 0xd8, 0x33, 0xb6, 0x7f, 0x3d, 0x2c, 0xb3, 0xe3, 0x5d, 0x8f, 0xa6, 0xbb, + 0x5d, 0x6b, 0x7b, 0xa6, 0xa6, 0xdb, 0xca, 0xb6, 0xc7, 0x66, 0x05, 0x9b, 0xca, 0xca, 0x0c, 0x77, + 0x27, 0xce, 0xce, 0xac, 0xc9, 0xcc, 0x72, 0xbb, 0xe1, 0x82, 0x56, 0x9c, 0x40, 0x88, 0x03, 0xe2, + 0x0c, 0x27, 0x84, 0x04, 0xe2, 0xca, 0x09, 0x89, 0x33, 0x37, 0xc4, 0x01, 0x09, 0x71, 0x41, 0xe2, + 0x2f, 0x58, 0x21, 0x6e, 0x48, 0x28, 0xbe, 0x32, 0x22, 0x32, 0xb3, 0x7a, 0xed, 0x11, 0x70, 0x69, + 0x55, 0xbc, 0x78, 0xf9, 0x5e, 0xc4, 0xfb, 0x8a, 0xf7, 0x5e, 0x44, 0x43, 0xf7, 0xed, 0xdc, 0x4f, + 0x66, 0xde, 0x9d, 0x59, 0x12, 0x67, 0x31, 0x5a, 0xe6, 0xa3, 0xd1, 0x9a, 0x1b, 0x45, 0x71, 0xe6, + 0x66, 0x41, 0x1c, 0xa5, 0x7c, 0x0a, 0x6f, 0xc2, 0xfa, 0x8e, 0xef, 0xef, 0xcd, 0x93, 0x84, 0x44, + 0xde, 0x99, 0x4d, 0xd2, 0x59, 0x1c, 0xa5, 0x04, 0xff, 0x1c, 0xfa, 0x3b, 0xbe, 0xff, 0xd4, 0x0d, + 0x12, 0x9b, 0x7c, 0x37, 0x27, 0x69, 0x86, 0xae, 0x43, 0x6f, 0xea, 0xa6, 0xc4, 0xf1, 0x04, 0xea, + 0xd0, 0xba, 0x66, 0xdd, 0x5c, 0xb1, 0x4d, 0x20, 0xfa, 0x10, 0xfa, 0xdf, 0xcd, 0xe3, 0x4c, 0x43, + 0xab, 0x31, 0xb4, 0x02, 0x14, 0xaf, 0xc1, 0x6a, 0x4e, 0x5f, 0xb0, 0xfc, 0x47, 0x0b, 0x9a, 0x3b, + 0x21, 0x49, 0x32, 0x74, 0x1b, 0x1a, 0xd9, 0xd9, 0x8c, 0x30, 0x0e, 0xfd, 0xed, 0x0b, 0x77, 0xc4, + 0x5e, 0xd8, 0x24, 0xff, 0xfb, 0xec, 0x6c, 0x46, 0x6c, 0x86, 0x84, 0x86, 0xd0, 0x3a, 0x21, 0x69, + 0xea, 0x1e, 0x11, 0xc1, 0x4a, 0x0e, 0x11, 0x82, 0x86, 0xef, 0x66, 0x64, 0x58, 0xbf, 0x66, 0xdd, + 0xac, 0xdb, 0xec, 0x37, 0xfa, 0x09, 0xdd, 0x45, 0xe8, 0x46, 0x1e, 0x71, 0x5c, 0x4a, 0x68, 0xd8, + 0xb8, 0x66, 0xdd, 0xec, 0x6c, 0x6f, 0x48, 0x1e, 0xbb, 0x7c, 0x92, 0x31, 0x79, 0xbc, 0x64, 0x9b, + 0xc8, 0xf8, 0x3a, 0xac, 0xe4, 0xec, 0xd1, 0x05, 0x58, 0x9f, 0x1c, 0xbc, 0x70, 0x9e, 0xd9, 0x3b, + 0x0f, 0x9f, 0xec, 0x3f, 0x72, 0x76, 0x77, 0x26, 0x3b, 0xfb, 0x7b, 0xe3, 0xc1, 0xd2, 0xee, 0x0a, + 0xb4, 0x66, 0xee, 0x59, 0x18, 0xbb, 0x3e, 0xfe, 0xdb, 0x1a, 0xb4, 0x04, 0x49, 0x2a, 0xc0, 0x2c, + 0xce, 0xdc, 0xd0, 0x11, 0x34, 0xd9, 0xf6, 0x1a, 0xb6, 0x09, 0x44, 0x37, 0x61, 0xd5, 0x3b, 0x76, + 0xa3, 0x88, 0x28, 0xbc, 0x1a, 0xc3, 0x2b, 0x82, 0xd1, 0x8f, 0xe0, 0xc2, 0x8c, 0x44, 0x7e, 0x10, + 0x1d, 0x39, 0xc5, 0x2f, 0xea, 0xec, 0x8b, 0x45, 0xd3, 0xe8, 0x3e, 0x0c, 0x83, 0xc8, 0xf5, 0xb2, + 0xe0, 0x0d, 0x29, 0x7d, 0xda, 0x60, 0x9f, 0x2e, 0x9c, 0xa7, 0x0a, 0x3e, 0x75, 0xc3, 0x90, 0x64, + 0xf9, 0x17, 0x4d, 0xf6, 0x45, 0x01, 0x8a, 0xbe, 0x80, 0xd1, 0x3c, 0xf2, 0xe2, 0xe8, 0x55, 0x90, + 0x9c, 0x10, 0xdf, 0x29, 0x7c, 0xb3, 0xcc, 0xbe, 0x39, 0x07, 0x03, 0xff, 0xd2, 0x82, 0xae, 0xae, + 0x8c, 0x77, 0x14, 0xdf, 0x27, 0xd0, 0x48, 0x03, 0x9f, 0xcb, 0xac, 0xbf, 0x7d, 0xb1, 0x4a, 0xad, + 0x77, 0x0e, 0x03, 0x9f, 0xd8, 0x0c, 0x0d, 0x6d, 0x40, 0x73, 0x1a, 0xcf, 0x23, 0x9f, 0x49, 0xac, + 0x67, 0xf3, 0x01, 0x35, 0xa9, 0x19, 0x49, 0x3c, 0x12, 0x71, 0xf3, 0xe8, 0xd9, 0x72, 0x88, 0x30, + 0x74, 0xe9, 0x77, 0x85, 0xbd, 0x1b, 0x30, 0x34, 0x82, 0x76, 0x6e, 0xfc, 0xcb, 0xcc, 0x22, 0xf3, + 0x31, 0xbe, 0x02, 0x0d, 0xca, 0x1d, 0x01, 0x2c, 0xdb, 0xe3, 0x6f, 0x0e, 0x9e, 0x8d, 0x07, 0x4b, + 0x68, 0x05, 0x9a, 0x93, 0x83, 0xbd, 0x9d, 0xc9, 0xc0, 0xc2, 0xbf, 0x0e, 0xb0, 0xeb, 0x46, 0xd2, + 0xe3, 0x6e, 0xc2, 0x6a, 0x14, 0xfb, 0xc4, 0x09, 0x7c, 0x12, 0x65, 0xc1, 0xab, 0x80, 0x24, 0xc2, + 0xe7, 0x8a, 0x60, 0xdc, 0x83, 0x0e, 0xfb, 0x4e, 0x78, 0xd2, 0x67, 0xd0, 0xdc, 0x3b, 0x76, 0x83, + 0x88, 0x6e, 0xcf, 0xa3, 0x3f, 0xc4, 0x77, 0x7c, 0x40, 0xb7, 0x17, 0x91, 0xec, 0x34, 0x4e, 0x5e, + 0x4b, 0x8f, 0x11, 0x43, 0x3c, 0x83, 0xf6, 0x1e, 0xd7, 0x77, 0x8a, 0xb6, 0x60, 0x99, 0x9b, 0x00, + 0xfb, 0xb8, 0x67, 0x8b, 0x11, 0xdd, 0x9e, 0x34, 0x0e, 0xf6, 0x79, 0xcf, 0xce, 0xc7, 0x5c, 0x70, + 0xcc, 0xe6, 0x84, 0x40, 0xe5, 0x90, 0x52, 0xf3, 0xc2, 0x38, 0x25, 0xbe, 0x90, 0xa8, 0x18, 0x61, + 0x07, 0x36, 0x29, 0xc7, 0x23, 0xf2, 0xd4, 0x4d, 0xd3, 0xd3, 0x38, 0xf1, 0xe5, 0xe6, 0x31, 0x74, + 0x23, 0x72, 0xea, 0xcc, 0x04, 0x58, 0xec, 0xc0, 0x80, 0x51, 0x9c, 0x38, 0xf4, 0x15, 0x0e, 0xdf, + 0x8d, 0x01, 0xc3, 0x43, 0xd8, 0x2a, 0x32, 0x10, 0x52, 0xfa, 0x3b, 0x0b, 0xd6, 0xf7, 0xe8, 0x2a, + 0xc4, 0x96, 0xdf, 0x5b, 0xec, 0x86, 0xa6, 0x6b, 0xa6, 0xa6, 0xa9, 0xe8, 0x5f, 0xc5, 0x89, 0xf0, + 0xc5, 0xb6, 0xcd, 0x07, 0xe8, 0x1a, 0x74, 0x7c, 0x92, 0x66, 0x41, 0xc4, 0x62, 0x30, 0x93, 0xc5, + 0x8a, 0xad, 0x83, 0x98, 0xd8, 0x4f, 0xe2, 0x79, 0x94, 0x09, 0xdb, 0x12, 0x23, 0x34, 0x80, 0xfa, + 0x2b, 0x22, 0x1d, 0x87, 0xfe, 0xc4, 0x5f, 0xc2, 0x86, 0xb9, 0x7c, 0xbe, 0x2f, 0xba, 0xfe, 0x2c, + 0x71, 0xa3, 0x94, 0xea, 0x24, 0x8e, 0x9c, 0xc0, 0x4f, 0x87, 0xd6, 0xb5, 0x3a, 0x5d, 0x7f, 0x01, + 0x8c, 0x3f, 0x86, 0xfe, 0x5e, 0x1c, 0x45, 0xc4, 0xcb, 0xe4, 0xde, 0x47, 0xd0, 0x66, 0x9b, 0x9c, + 0x27, 0x81, 0xd8, 0x74, 0x3e, 0xa6, 0x21, 0x3b, 0xc7, 0x16, 0x22, 0xbc, 0x0b, 0x6b, 0x7b, 0x09, + 0x71, 0x33, 0xb2, 0x1f, 0xfb, 0x44, 0xa3, 0x51, 0xd0, 0x5a, 0x3e, 0xc6, 0x7f, 0x6a, 0x01, 0xd2, + 0xbf, 0x10, 0x4b, 0xfe, 0x7f, 0xd0, 0x4b, 0x09, 0xf1, 0x9d, 0x93, 0x88, 0x9c, 0xc4, 0x51, 0xe0, + 0x89, 0x05, 0x77, 0x29, 0xf0, 0x1b, 0x01, 0x43, 0x1f, 0xc1, 0x20, 0x88, 0x82, 0x2c, 0x70, 0xc3, + 0xe0, 0x77, 0x88, 0xef, 0x84, 0x91, 0x9f, 0x0e, 0x6b, 0x7c, 0x63, 0x1a, 0x7c, 0x12, 0xf9, 0x29, + 0xba, 0x0b, 0xeb, 0x3a, 0xaa, 0x47, 0x97, 0xfd, 0x36, 0x13, 0xaa, 0x40, 0xda, 0xd4, 0x1e, 0x9f, + 0xc1, 0xff, 0x6c, 0x41, 0x5b, 0x9e, 0x81, 0x86, 0x5a, 0xad, 0x82, 0x5a, 0x1f, 0x40, 0x27, 0x3d, + 0x75, 0x67, 0x8e, 0x17, 0x06, 0x34, 0x3c, 0xf0, 0x30, 0x73, 0x49, 0x86, 0x19, 0x49, 0xe2, 0xce, + 0xe1, 0xa9, 0x3b, 0xdb, 0x63, 0x28, 0xb6, 0x8e, 0xcf, 0x83, 0xd8, 0x6b, 0x12, 0x39, 0xae, 0xef, + 0x27, 0x24, 0x4d, 0xd9, 0x92, 0x56, 0x6c, 0x13, 0x48, 0x63, 0xac, 0x4f, 0xbc, 0xe0, 0xc4, 0x0d, + 0x9d, 0x59, 0xe8, 0x7a, 0x24, 0x15, 0x4e, 0x53, 0x80, 0x62, 0x0c, 0xa0, 0x18, 0xa1, 0x16, 0xd4, + 0x27, 0xfb, 0x0f, 0x07, 0x4b, 0xa8, 0x03, 0xad, 0xbd, 0x83, 0xfd, 0xfd, 0xf1, 0xcb, 0x67, 0x83, + 0x1a, 0xd5, 0xf1, 0x43, 0x32, 0x8b, 0xd3, 0x40, 0xd7, 0xf1, 0xa2, 0xed, 0xe1, 0xdb, 0xb0, 0x9a, + 0x63, 0x0b, 0xdd, 0x0c, 0xa1, 0x25, 0x17, 0xcb, 0xb1, 0xe5, 0x90, 0x1a, 0xe0, 0xc3, 0x20, 0xf5, + 0xe2, 0x37, 0x24, 0xa1, 0xda, 0x4c, 0xdf, 0x3f, 0x6e, 0xfd, 0x10, 0x36, 0x0b, 0x14, 0x04, 0xd3, + 0xcb, 0xb0, 0x12, 0xcd, 0x4f, 0x1c, 0x8a, 0x9f, 0x8a, 0xf8, 0xa3, 0x00, 0xf8, 0x0f, 0x2c, 0x40, + 0xe3, 0xb7, 0xc4, 0x9b, 0x67, 0x84, 0xee, 0x5f, 0xdb, 0x58, 0x9c, 0xf8, 0x24, 0x71, 0x82, 0xdc, + 0xf0, 0xe4, 0x98, 0x45, 0x26, 0x37, 0x60, 0x53, 0x22, 0xe6, 0x89, 0x21, 0x0d, 0x22, 0x33, 0x42, + 0x12, 0x67, 0x36, 0x9f, 0x3a, 0xaf, 0xc9, 0x99, 0xd0, 0x88, 0x01, 0xa3, 0x94, 0xbf, 0x9b, 0xbb, + 0x51, 0x16, 0x64, 0x67, 0xe2, 0x80, 0xcc, 0xc7, 0xd4, 0x07, 0x1e, 0x91, 0x4c, 0x1c, 0x30, 0xef, + 0x22, 0xe3, 0xbf, 0xb4, 0x00, 0xe9, 0x5f, 0x88, 0x2d, 0x3f, 0x84, 0xb6, 0x38, 0x41, 0xb8, 0xbf, + 0x76, 0xb6, 0x6f, 0x4a, 0xb3, 0x2a, 0x63, 0xcb, 0x03, 0x2d, 0x1d, 0x47, 0x59, 0x72, 0x66, 0xe7, + 0x5f, 0x8e, 0x26, 0xd0, 0x33, 0xa6, 0x68, 0xdc, 0xa0, 0xbb, 0xe2, 0x8b, 0xa0, 0x3f, 0xd1, 0x0d, + 0x68, 0xbe, 0x71, 0xc3, 0x39, 0x8f, 0xde, 0x9d, 0xed, 0xd5, 0xc2, 0x19, 0x69, 0xf3, 0xd9, 0xfb, + 0xb5, 0x1f, 0x59, 0x78, 0x00, 0xfd, 0x47, 0x24, 0x7b, 0x12, 0xbd, 0x8a, 0xc5, 0xc6, 0xf0, 0xbf, + 0xd4, 0x61, 0x35, 0x07, 0x29, 0x0b, 0x79, 0x43, 0x92, 0x94, 0x06, 0x34, 0x61, 0x21, 0x62, 0xc8, + 0x82, 0x38, 0x55, 0xb9, 0x94, 0xad, 0x08, 0xd0, 0x3a, 0x8c, 0x66, 0x69, 0xf3, 0x24, 0xa0, 0x9e, + 0x40, 0x5d, 0x99, 0xfd, 0x96, 0xea, 0xa7, 0x3a, 0x90, 0xb6, 0xaf, 0x00, 0xf9, 0xac, 0x1b, 0x24, + 0x29, 0x8b, 0x92, 0x72, 0x96, 0x02, 0xd0, 0x6d, 0x58, 0x66, 0x5a, 0x4f, 0x59, 0xac, 0xec, 0x6c, + 0xaf, 0xcb, 0xfd, 0x1d, 0x30, 0xe8, 0x1e, 0x8d, 0xa6, 0xb6, 0x40, 0x41, 0xdb, 0x50, 0x0f, 0x23, + 0x7f, 0xd8, 0x62, 0xf2, 0xbe, 0xa6, 0xc9, 0x5b, 0xdf, 0xe0, 0x9d, 0x49, 0xe4, 0x73, 0x39, 0x53, + 0x64, 0x1a, 0xd9, 0xdd, 0x30, 0x70, 0xd3, 0xe1, 0x0a, 0x3f, 0x54, 0xd9, 0x40, 0x3f, 0x54, 0xc1, + 0x38, 0x54, 0xd1, 0x3d, 0x58, 0x97, 0x89, 0x18, 0x0b, 0x05, 0xc7, 0x6e, 0x7a, 0x4c, 0xd2, 0x61, + 0x87, 0xed, 0xb7, 0x6a, 0x0a, 0x7d, 0x02, 0x2d, 0x19, 0xb2, 0xba, 0xe6, 0x1e, 0x44, 0xbc, 0x62, + 0xab, 0x93, 0x38, 0xa3, 0x47, 0xd0, 0x96, 0x2b, 0x7c, 0x0f, 0x75, 0x4f, 0x22, 0x9f, 0x91, 0xd1, + 0xd4, 0xbd, 0xc1, 0x0c, 0x53, 0x06, 0x5c, 0xa9, 0xf2, 0x1f, 0xc3, 0xba, 0x01, 0x15, 0x5a, 0xbf, + 0x5e, 0x1d, 0xb3, 0x4d, 0x20, 0xfe, 0x82, 0x91, 0xa4, 0xce, 0xad, 0x59, 0xd1, 0x7b, 0x44, 0x08, + 0x9b, 0x31, 0x57, 0xdf, 0xe7, 0x07, 0xc6, 0x6a, 0x42, 0x66, 0x73, 0x5e, 0xca, 0x1c, 0x7a, 0x71, + 0xc2, 0xb3, 0x94, 0x35, 0x1b, 0x14, 0x98, 0x1e, 0xa5, 0x53, 0x7a, 0x34, 0x72, 0x97, 0x6f, 0xdb, + 0x62, 0x84, 0x2f, 0xc0, 0xe6, 0x24, 0x48, 0x33, 0x11, 0xac, 0x83, 0x3c, 0x70, 0xe1, 0xaf, 0x60, + 0xab, 0x38, 0x21, 0xf8, 0xdd, 0x03, 0xf0, 0x72, 0xa8, 0x70, 0xcf, 0x41, 0x31, 0xea, 0xdb, 0x1a, + 0x0e, 0xfe, 0x07, 0x0b, 0xd6, 0x28, 0x31, 0x6e, 0x75, 0x72, 0xe3, 0x5a, 0x18, 0xb2, 0xcc, 0x30, + 0xf4, 0x43, 0x68, 0xc6, 0xa7, 0x11, 0x49, 0xc4, 0x91, 0xf2, 0x41, 0xae, 0xa6, 0x22, 0x8d, 0x3b, + 0x07, 0x14, 0xcd, 0xe6, 0xd8, 0xd4, 0x18, 0xc3, 0xe0, 0x24, 0xc8, 0x64, 0x02, 0xcb, 0x06, 0x54, + 0xbe, 0x41, 0xe4, 0x85, 0x73, 0x9f, 0x16, 0x2e, 0x81, 0x9b, 0x8a, 0x13, 0xa4, 0x6d, 0x17, 0xc1, + 0xf8, 0x3a, 0x34, 0x19, 0x3d, 0xd4, 0x86, 0xc6, 0xee, 0xc1, 0xb3, 0xc7, 0x83, 0x25, 0x7a, 0x8e, + 0x1c, 0xbc, 0xd8, 0x1f, 0x58, 0x14, 0xf4, 0x74, 0x3c, 0xb6, 0x07, 0x35, 0xfc, 0x67, 0x16, 0x20, + 0x7d, 0x21, 0x42, 0x2a, 0x5f, 0xe4, 0xae, 0xc6, 0x25, 0xf2, 0x61, 0xd5, 0xa2, 0x85, 0x0f, 0xf1, + 0x21, 0x77, 0x23, 0xf1, 0xd5, 0xe8, 0x09, 0x74, 0x34, 0x70, 0x85, 0xed, 0x5e, 0x37, 0x6d, 0xb7, + 0x6f, 0xba, 0xb2, 0x6e, 0xba, 0x08, 0x06, 0x94, 0x29, 0x2d, 0x28, 0x73, 0x75, 0x7e, 0xc4, 0x35, + 0x20, 0x60, 0x62, 0xcd, 0x1b, 0xd0, 0xe4, 0x81, 0x83, 0x9b, 0x2b, 0x1f, 0xe4, 0x9f, 0x13, 0x25, + 0x67, 0xfc, 0x99, 0xf8, 0x9c, 0xe8, 0x5b, 0xc6, 0xd0, 0xe4, 0x51, 0x89, 0xef, 0xb8, 0x2b, 0x57, + 0x44, 0xb1, 0x6c, 0x3e, 0x85, 0xff, 0xd5, 0x82, 0x96, 0xf0, 0x2e, 0x6a, 0x83, 0x69, 0xe6, 0x66, + 0x73, 0x79, 0x78, 0x8a, 0x11, 0xfa, 0x18, 0xda, 0xa2, 0xb2, 0x4a, 0xc5, 0xe6, 0x94, 0x39, 0x09, + 0xb8, 0x9d, 0x63, 0xa0, 0x1b, 0xb0, 0xcc, 0x52, 0x77, 0x1e, 0x25, 0x3b, 0xdb, 0x3d, 0x0d, 0x37, + 0x88, 0x6c, 0x31, 0x49, 0xb3, 0xcb, 0x69, 0x18, 0x7b, 0xaf, 0x8f, 0x49, 0x70, 0x74, 0x2c, 0x6b, + 0x17, 0x1d, 0x94, 0x07, 0xdb, 0xa6, 0x16, 0x6c, 0xb5, 0xf0, 0xbd, 0x6c, 0x86, 0xef, 0x3c, 0xd2, + 0xb5, 0xb4, 0x48, 0x87, 0xbf, 0x82, 0x3e, 0xf3, 0x47, 0x95, 0x07, 0x17, 0xc3, 0xbc, 0x55, 0x11, + 0xe6, 0x73, 0x5a, 0x35, 0x9d, 0xd6, 0x5f, 0x58, 0x80, 0x0e, 0x66, 0x24, 0xfa, 0x5f, 0x49, 0xc1, + 0x55, 0x2a, 0x5d, 0x37, 0x52, 0xe9, 0x6b, 0xd0, 0x99, 0xcd, 0xd3, 0x63, 0x47, 0x4c, 0xf2, 0x03, + 0x5d, 0x07, 0xc9, 0x64, 0xbb, 0xa9, 0x92, 0xed, 0x07, 0xb0, 0x6e, 0xac, 0x53, 0x98, 0xc3, 0x87, + 0xd0, 0x37, 0x93, 0x6a, 0xb1, 0xce, 0x02, 0x14, 0xff, 0x7d, 0x0d, 0x9a, 0xcc, 0x68, 0x99, 0xfd, + 0x25, 0x81, 0x28, 0x5f, 0x2d, 0x9b, 0x0f, 0x8c, 0x04, 0xa3, 0x66, 0x26, 0x18, 0x7a, 0xcc, 0xa8, + 0x9b, 0x31, 0xa3, 0x0f, 0xb5, 0xc0, 0x17, 0x45, 0x44, 0x2d, 0xf0, 0xd1, 0x97, 0x65, 0xb1, 0x35, + 0x99, 0x6d, 0x6d, 0x49, 0x7b, 0x31, 0x15, 0x57, 0x29, 0xce, 0x30, 0xf6, 0xdc, 0x90, 0x32, 0x13, + 0xb5, 0xab, 0x1c, 0xa3, 0xab, 0x00, 0x1e, 0x4b, 0xdd, 0x7d, 0xc7, 0xcd, 0x98, 0x49, 0x34, 0x6c, + 0x0d, 0x82, 0x6e, 0x88, 0xd2, 0xbb, 0xcd, 0x02, 0xd8, 0x9a, 0xe1, 0xab, 0x5a, 0xc9, 0x8d, 0xa1, + 0x1b, 0xa4, 0x4e, 0x7c, 0x1a, 0x39, 0x2c, 0x0a, 0xb0, 0x53, 0xb4, 0x6d, 0x1b, 0x30, 0x6a, 0xa6, + 0xc7, 0x71, 0xe8, 0xb3, 0x93, 0xb4, 0x61, 0xb3, 0xdf, 0xf8, 0xcf, 0x2d, 0xe8, 0x32, 0x5a, 0x36, + 0x39, 0x89, 0xdf, 0xb8, 0xa1, 0x21, 0x33, 0x6b, 0xb1, 0xcc, 0x0a, 0xe9, 0x9e, 0x9e, 0x24, 0xd6, + 0x0b, 0x49, 0xa2, 0xbe, 0xfb, 0x46, 0x61, 0xf7, 0xc5, 0x65, 0x37, 0xcb, 0xcb, 0xc6, 0xc7, 0xb0, + 0xcc, 0x23, 0x13, 0xfa, 0x04, 0x60, 0x3a, 0x3f, 0x73, 0x8c, 0xe8, 0xd8, 0x33, 0x24, 0x62, 0x6b, + 0x08, 0xe8, 0x2e, 0x74, 0x52, 0x12, 0x86, 0x12, 0xbf, 0x56, 0x85, 0xaf, 0x63, 0xe0, 0x4f, 0x65, + 0xe4, 0x64, 0xe9, 0x0c, 0x95, 0x17, 0x0d, 0x3d, 0x22, 0x53, 0x66, 0xbf, 0xa9, 0x0d, 0xc7, 0xa7, + 0x91, 0x28, 0xd1, 0xe9, 0x4f, 0xfc, 0x0b, 0x4b, 0x7c, 0xf5, 0x7c, 0xc6, 0x7a, 0x61, 0x37, 0xa0, + 0xc9, 0xf7, 0x62, 0x31, 0x23, 0x31, 0xf9, 0x3d, 0x5e, 0xb2, 0xf9, 0x2c, 0xfa, 0x09, 0xf4, 0xb8, + 0x84, 0x12, 0x2e, 0x78, 0x11, 0xaf, 0x36, 0xcc, 0xe5, 0xf1, 0xb9, 0xc7, 0x4b, 0xb6, 0x89, 0xbc, + 0xdb, 0x87, 0x2e, 0x07, 0xcc, 0x19, 0x53, 0xfc, 0x9f, 0x75, 0x68, 0xd0, 0x60, 0xb9, 0xb8, 0xae, + 0x78, 0xa7, 0xac, 0xf1, 0x4b, 0xe8, 0x86, 0x91, 0x2f, 0x87, 0x32, 0x2e, 0x5e, 0xd6, 0xc3, 0x31, + 0xcd, 0x70, 0x9e, 0xce, 0xa7, 0x5f, 0x93, 0x33, 0x71, 0xec, 0x18, 0x5f, 0x50, 0xfe, 0x41, 0xc4, + 0x9b, 0x3f, 0xfc, 0x6c, 0x94, 0x43, 0x75, 0x44, 0x34, 0xb5, 0x23, 0x82, 0x46, 0x8d, 0xb7, 0x73, + 0xdf, 0x31, 0x43, 0xa5, 0x0e, 0x42, 0x1f, 0xc3, 0x5a, 0x4a, 0xbc, 0x38, 0xf2, 0x53, 0x5e, 0x71, + 0x7a, 0x19, 0xf1, 0x99, 0x9f, 0xf4, 0xec, 0xf2, 0xc4, 0x82, 0x34, 0xf2, 0x1e, 0xb4, 0xe9, 0x2a, + 0x59, 0x90, 0x06, 0xb6, 0xa7, 0x8d, 0xe2, 0x9e, 0x9e, 0x27, 0x41, 0x6a, 0xe7, 0x58, 0xe8, 0x0e, + 0x20, 0x91, 0x08, 0xea, 0x7e, 0xdf, 0x61, 0x44, 0x2b, 0x66, 0x46, 0x0f, 0x60, 0xb5, 0x20, 0x98, + 0x8a, 0x83, 0x77, 0x43, 0x3f, 0x78, 0x57, 0xb4, 0x83, 0x76, 0xf4, 0x19, 0x3b, 0xdb, 0xe8, 0x1a, + 0xce, 0xad, 0x93, 0x07, 0x50, 0x9f, 0x27, 0x81, 0xa8, 0xcf, 0xe9, 0x4f, 0xfc, 0x7b, 0x35, 0x58, + 0x7b, 0x4a, 0xeb, 0x56, 0x61, 0x2f, 0x3c, 0xd2, 0xff, 0x4f, 0x86, 0x43, 0xdd, 0xb5, 0x1b, 0x05, + 0xd7, 0x96, 0xc1, 0xa9, 0x79, 0x7e, 0x70, 0xba, 0x05, 0x83, 0x84, 0xb0, 0xea, 0xda, 0xc9, 0x49, + 0x71, 0x4d, 0x97, 0xe0, 0x34, 0xaf, 0x0f, 0x4e, 0x4e, 0x88, 0x1f, 0xb8, 0x19, 0x85, 0x3a, 0x1e, + 0xad, 0x9e, 0x42, 0xa6, 0xf0, 0xb6, 0x5d, 0x35, 0x45, 0x45, 0x80, 0x74, 0x11, 0x88, 0x43, 0xe4, + 0x73, 0x18, 0x04, 0x51, 0x46, 0x92, 0xc8, 0x0d, 0x9d, 0x13, 0x37, 0xf3, 0x8e, 0xc9, 0x82, 0x90, + 0x51, 0x42, 0x43, 0x3f, 0x86, 0x3e, 0x2b, 0x1c, 0xd2, 0xb9, 0xe7, 0x91, 0x94, 0xe6, 0x79, 0x3c, + 0x76, 0xe4, 0x05, 0x03, 0xad, 0x8f, 0x0f, 0xf9, 0xa4, 0x5d, 0x40, 0x45, 0x9f, 0xd1, 0x24, 0xfa, + 0xc4, 0x0d, 0x22, 0x5a, 0x7f, 0xf0, 0x48, 0x50, 0xaf, 0x88, 0x04, 0x76, 0x11, 0x0b, 0x7d, 0x0e, + 0x3d, 0x46, 0xea, 0x95, 0x1b, 0x84, 0xf3, 0x84, 0x25, 0x97, 0x25, 0xa6, 0x3f, 0xe5, 0x73, 0xb6, + 0x89, 0x89, 0x7f, 0x69, 0xc1, 0xaa, 0x12, 0xc1, 0xf8, 0x0d, 0x89, 0xe8, 0xc1, 0xd1, 0x64, 0xfb, + 0x59, 0x18, 0x87, 0xd8, 0x2c, 0xfa, 0x1c, 0xba, 0xfa, 0x06, 0x44, 0x18, 0xaa, 0xda, 0xe9, 0xe3, + 0x25, 0xdb, 0x40, 0x45, 0x9f, 0xbf, 0xdb, 0x4e, 0x1f, 0x2f, 0x55, 0xed, 0xb5, 0xab, 0xef, 0x40, + 0xdc, 0x17, 0x54, 0x6d, 0x35, 0xe7, 0x2a, 0x50, 0x77, 0x5b, 0xd0, 0x24, 0x74, 0x83, 0x38, 0x86, + 0x8e, 0x56, 0xb8, 0x2d, 0xcc, 0x09, 0xb5, 0x88, 0x58, 0x33, 0x23, 0xa2, 0x96, 0xa2, 0x35, 0x4a, + 0x29, 0x1a, 0xef, 0xf0, 0x36, 0xb5, 0x0e, 0x2f, 0xfe, 0x14, 0x36, 0x59, 0x40, 0x26, 0xea, 0x5e, + 0xe7, 0x57, 0xf7, 0x25, 0x86, 0xb0, 0x55, 0xfc, 0x48, 0xb4, 0xf9, 0x26, 0x80, 0xf8, 0x8c, 0xe1, + 0xba, 0xe7, 0xb5, 0x5b, 0xce, 0x71, 0x60, 0xfc, 0x57, 0x16, 0xac, 0x1b, 0xe4, 0x84, 0x1b, 0x5c, + 0x85, 0x81, 0xc4, 0x71, 0xe2, 0xc8, 0x61, 0x09, 0x80, 0xa5, 0x12, 0x00, 0x1a, 0xe8, 0x94, 0x72, + 0x0a, 0xd4, 0x2b, 0x66, 0xb8, 0x2f, 0x53, 0x36, 0xbe, 0xc2, 0xe6, 0x89, 0x60, 0x09, 0xae, 0x07, + 0x95, 0x86, 0x11, 0x54, 0x94, 0x54, 0x76, 0xc2, 0xd0, 0xa8, 0xc3, 0xf0, 0x1c, 0x2e, 0x94, 0x66, + 0xc4, 0x56, 0x3e, 0x86, 0x35, 0xc9, 0x42, 0x8a, 0x44, 0x16, 0x1c, 0xe5, 0x09, 0x8a, 0x2d, 0xf6, + 0xab, 0x61, 0xf3, 0xc8, 0x59, 0x9e, 0xc0, 0x9f, 0xc0, 0x1a, 0x67, 0xab, 0x5f, 0xce, 0x2d, 0xac, + 0x2b, 0x69, 0x4d, 0xaf, 0xa3, 0x0b, 0x8d, 0xfe, 0x7e, 0x8d, 0x82, 0xd3, 0x2c, 0x4e, 0x8c, 0xd6, + 0xed, 0x3b, 0xf5, 0x61, 0xf5, 0xfe, 0x6e, 0xcd, 0xec, 0xef, 0xa2, 0xaf, 0xa1, 0x43, 0x0f, 0xa6, + 0xa9, 0xeb, 0xbd, 0x9e, 0xcf, 0xe4, 0xa9, 0x7c, 0x4b, 0x3a, 0x4b, 0x99, 0x23, 0x3d, 0xcf, 0x76, + 0x39, 0x32, 0x3f, 0xa3, 0x21, 0xcc, 0x01, 0xe8, 0x07, 0xec, 0x16, 0xd3, 0xf1, 0xdd, 0xcc, 0x9d, + 0xba, 0x29, 0xef, 0x7d, 0x77, 0xd9, 0x91, 0xfb, 0x50, 0x80, 0xc4, 0x61, 0xa6, 0x53, 0xf8, 0x55, + 0x87, 0x59, 0x57, 0xaf, 0x1a, 0x09, 0xb5, 0x44, 0x6d, 0x4d, 0xaa, 0x1d, 0x9d, 0x70, 0xb0, 0x68, + 0x33, 0x0b, 0x31, 0x48, 0x20, 0xeb, 0x31, 0x7f, 0x44, 0xcd, 0x4b, 0x20, 0xc9, 0x6e, 0x0d, 0xef, + 0x33, 0xac, 0x4a, 0xb8, 0xec, 0x2e, 0x3f, 0x04, 0x74, 0x48, 0xb2, 0x49, 0x7c, 0x34, 0x21, 0x6f, + 0x54, 0x91, 0x73, 0x07, 0x56, 0xc2, 0xf8, 0xc8, 0x09, 0x29, 0x4c, 0x5c, 0x75, 0xe6, 0x35, 0x60, + 0x8e, 0xab, 0x50, 0xf0, 0x26, 0xac, 0x1b, 0x54, 0x84, 0x2a, 0xd7, 0x60, 0xf5, 0xf0, 0x78, 0x9e, + 0xf9, 0xf1, 0xa9, 0xbc, 0x38, 0xa2, 0xd5, 0xac, 0x02, 0x09, 0xb4, 0x5f, 0x83, 0xad, 0xc3, 0xf9, + 0x34, 0xf5, 0x92, 0x60, 0x4a, 0xcc, 0x9e, 0xc4, 0x08, 0xda, 0xe4, 0x6d, 0x90, 0x66, 0x41, 0x74, + 0xc4, 0x96, 0xd1, 0xb6, 0xf3, 0x31, 0xb5, 0xfe, 0xfc, 0x2b, 0x76, 0x79, 0x96, 0x5b, 0xff, 0x07, + 0x70, 0x25, 0x9f, 0xa1, 0x41, 0x30, 0xdd, 0xf1, 0x3c, 0x32, 0xcb, 0x88, 0xbc, 0xc0, 0xc1, 0x0f, + 0x60, 0xd3, 0x44, 0xd0, 0x2e, 0x92, 0x65, 0x17, 0x22, 0x73, 0x5f, 0x8b, 0xf4, 0xb3, 0x6d, 0x9b, + 0x40, 0xfc, 0x5f, 0x35, 0xe8, 0xd2, 0xcf, 0x24, 0x59, 0x74, 0xb1, 0x14, 0x6e, 0x5a, 0x6c, 0xfc, + 0xc4, 0xcc, 0xdb, 0x6b, 0x85, 0xbc, 0xfd, 0xdc, 0x74, 0x61, 0x51, 0x53, 0x57, 0xa5, 0x25, 0x4d, + 0x3d, 0x2d, 0x29, 0xb6, 0x8a, 0x97, 0x2b, 0x5a, 0xc5, 0x5b, 0xb0, 0x9c, 0xb0, 0x3e, 0x9e, 0x28, + 0x9a, 0xc5, 0x88, 0x46, 0x23, 0x5e, 0x5c, 0x3a, 0x09, 0xf1, 0x48, 0xf0, 0x86, 0x4a, 0xbb, 0xcd, + 0xa3, 0x51, 0x11, 0x4e, 0xab, 0x4a, 0x01, 0x4b, 0xc5, 0x6d, 0xda, 0x0a, 0xbf, 0x63, 0x35, 0xa1, + 0x2c, 0xf5, 0x13, 0xb1, 0x5a, 0xa3, 0x0a, 0x22, 0xf5, 0x2b, 0xcd, 0xd0, 0x35, 0xe4, 0x50, 0x49, + 0x99, 0x27, 0x8a, 0x25, 0x38, 0x8d, 0xd2, 0x1d, 0xed, 0x70, 0xfb, 0x9e, 0xcd, 0x75, 0x5d, 0xc6, + 0xf5, 0x82, 0x8c, 0x8b, 0xd2, 0x6c, 0x54, 0x48, 0xf3, 0x43, 0xe8, 0x8b, 0xd3, 0xd4, 0x49, 0x88, + 0x9b, 0xc6, 0xf2, 0x9c, 0x2b, 0x40, 0xf1, 0xdf, 0xd4, 0xf9, 0x6a, 0x45, 0x02, 0xf0, 0x7f, 0x6b, + 0x2c, 0x4a, 0xe5, 0x4d, 0x43, 0xe5, 0x37, 0x61, 0xd5, 0x50, 0x2d, 0xf1, 0x85, 0xc6, 0x8b, 0x60, + 0x5a, 0x5b, 0x28, 0xd5, 0x66, 0x42, 0xdb, 0x3a, 0xa8, 0x24, 0x2c, 0xa8, 0x10, 0xd6, 0x35, 0x68, + 0x24, 0x71, 0x48, 0x98, 0x4a, 0xfb, 0xaa, 0x35, 0x65, 0xc7, 0x21, 0xb1, 0xd9, 0x0c, 0x3d, 0x69, + 0x0a, 0x66, 0x41, 0x7c, 0xd6, 0x62, 0x5e, 0xb1, 0xcb, 0x13, 0xd4, 0x51, 0x75, 0xb3, 0xc8, 0x86, + 0x3d, 0x7e, 0x59, 0x65, 0x00, 0xd1, 0x55, 0x80, 0xc4, 0x99, 0x25, 0x24, 0x38, 0x71, 0x8f, 0xc8, + 0xb0, 0xcf, 0x50, 0x34, 0x88, 0x72, 0xa5, 0x55, 0xcd, 0x95, 0xf0, 0x7f, 0xd4, 0xa0, 0xf9, 0x2c, + 0x71, 0x7d, 0x42, 0x6b, 0xdf, 0x13, 0xea, 0xf1, 0xce, 0xe2, 0x5a, 0xd4, 0xd6, 0x31, 0xe8, 0x07, + 0x99, 0xf6, 0x41, 0xad, 0xf2, 0x03, 0x0d, 0x43, 0xd3, 0x4f, 0xdd, 0xd0, 0xcf, 0x79, 0x3a, 0xd5, + 0x2c, 0xa1, 0x69, 0x5a, 0x42, 0xbe, 0x9f, 0x65, 0x3d, 0x34, 0x48, 0xd9, 0xb7, 0x16, 0xca, 0xfe, + 0x1a, 0x74, 0x08, 0xbf, 0xb3, 0x62, 0xfd, 0x13, 0x6e, 0x09, 0x3a, 0x28, 0xaf, 0x51, 0x56, 0xce, + 0xaf, 0x51, 0xee, 0x43, 0xd7, 0xa3, 0x86, 0x41, 0x92, 0x99, 0x9b, 0x64, 0xdc, 0x14, 0x16, 0xb7, + 0x78, 0x0c, 0x5c, 0x7c, 0x1b, 0xd6, 0x99, 0xd4, 0x1f, 0x07, 0xf4, 0x84, 0x3a, 0xd3, 0xaa, 0x30, + 0xde, 0x45, 0xb6, 0xb4, 0x2e, 0x32, 0x7e, 0x00, 0x1b, 0x26, 0xb2, 0x38, 0x1e, 0x6f, 0xc0, 0x72, + 0x46, 0xe1, 0xa5, 0x2a, 0x85, 0x61, 0xdb, 0x62, 0x12, 0xff, 0xb1, 0x05, 0x3d, 0x0a, 0x09, 0xa2, + 0xa3, 0x09, 0xa5, 0xc7, 0x0a, 0xc6, 0x13, 0xf7, 0xad, 0x93, 0x92, 0x30, 0x94, 0x1d, 0x1b, 0x39, + 0x66, 0xcf, 0x78, 0xdc, 0xb7, 0xce, 0x74, 0x2e, 0x53, 0x3a, 0x39, 0xa4, 0x66, 0x98, 0x90, 0x94, + 0x24, 0x34, 0x69, 0x62, 0x9f, 0xf2, 0x40, 0x62, 0x02, 0xa9, 0x83, 0xe4, 0x00, 0x4a, 0x84, 0x2b, + 0xd4, 0x80, 0xe1, 0x6d, 0xbe, 0xa1, 0x7c, 0x41, 0xef, 0x92, 0x15, 0xff, 0xb5, 0x05, 0x9b, 0x85, + 0x8f, 0x84, 0x18, 0x76, 0x60, 0x99, 0xc9, 0x49, 0x8a, 0xe1, 0x23, 0x5d, 0x0c, 0x25, 0xf4, 0x3b, + 0x7c, 0x28, 0x1a, 0xe0, 0xfc, 0xc3, 0xd1, 0x53, 0xe8, 0x68, 0xe0, 0x8a, 0xd4, 0xe5, 0xb6, 0xd9, + 0x00, 0xdf, 0xac, 0x66, 0xa1, 0x65, 0x34, 0xdf, 0x42, 0xf7, 0x79, 0x34, 0xfd, 0x1e, 0x6f, 0x48, + 0xd0, 0x65, 0x58, 0x49, 0x88, 0x68, 0x4f, 0x88, 0x44, 0x46, 0x01, 0xf0, 0x2a, 0xf4, 0x04, 0x5d, + 0x75, 0xf5, 0xff, 0x3c, 0x0a, 0x63, 0xef, 0xf5, 0xbb, 0x5e, 0xfd, 0xff, 0x0c, 0x90, 0xfe, 0x81, + 0x4a, 0xb5, 0xe6, 0x0c, 0x5a, 0x48, 0xb5, 0x24, 0x90, 0xa5, 0x5a, 0x1f, 0x40, 0x47, 0x47, 0xe1, + 0x37, 0x85, 0xa0, 0x10, 0xf0, 0x1f, 0x5a, 0xb0, 0xfa, 0x22, 0xc8, 0x8e, 0xfd, 0xc4, 0x3d, 0x7d, + 0x07, 0xa5, 0x16, 0x9f, 0x61, 0xd4, 0xce, 0x7b, 0x86, 0x51, 0x2f, 0x3e, 0xc3, 0x70, 0xc3, 0x50, + 0x74, 0x8c, 0xe8, 0x4f, 0xbd, 0x57, 0xdc, 0xe3, 0xbd, 0xe2, 0xfb, 0x30, 0x50, 0x8b, 0x79, 0xbf, + 0x46, 0xf1, 0xad, 0x9b, 0xb0, 0x92, 0xfb, 0x3b, 0x6a, 0x41, 0x7d, 0xf7, 0xf9, 0x6f, 0x0c, 0x96, + 0x50, 0x1b, 0x1a, 0x87, 0xe3, 0xc9, 0x84, 0xdf, 0xc9, 0xb0, 0x6b, 0x9a, 0xda, 0xad, 0x5b, 0xd0, + 0xa0, 0xd1, 0x05, 0xad, 0x40, 0xf3, 0xd9, 0xce, 0xd7, 0x63, 0x9b, 0xbf, 0x24, 0xfa, 0x86, 0xfd, + 0xb4, 0x50, 0x17, 0xda, 0x4f, 0xf6, 0x9f, 0x8d, 0xed, 0xfd, 0x9d, 0xc9, 0xa0, 0x76, 0xeb, 0x05, + 0xb4, 0x65, 0xde, 0x48, 0x91, 0x76, 0x26, 0x63, 0xfb, 0x19, 0xc7, 0x1f, 0xdb, 0xf6, 0x81, 0xcd, + 0xe9, 0xbe, 0xd8, 0xb1, 0xf7, 0x07, 0x35, 0xfa, 0xeb, 0xc9, 0xfe, 0x4f, 0x0f, 0x06, 0x75, 0xd4, + 0x81, 0xd6, 0xb7, 0x63, 0x7b, 0xf7, 0xe0, 0x70, 0x3c, 0x68, 0x50, 0xdc, 0x87, 0xe3, 0xdd, 0xe7, + 0x8f, 0x06, 0x4d, 0xc6, 0xd1, 0xde, 0xd9, 0x1b, 0x0f, 0x96, 0xb7, 0xff, 0xcd, 0x82, 0xd6, 0xcb, + 0xb9, 0xff, 0x24, 0x0a, 0x32, 0x34, 0x06, 0x50, 0x4f, 0x3b, 0x50, 0xfe, 0xf4, 0xaa, 0xf4, 0x40, + 0x64, 0x34, 0xaa, 0x9a, 0x12, 0x66, 0xb5, 0x84, 0x1e, 0x43, 0x47, 0xcb, 0xc9, 0xd1, 0x68, 0x71, + 0xf1, 0x30, 0xba, 0x54, 0x39, 0x97, 0x53, 0x1a, 0x03, 0x28, 0x8b, 0x53, 0x0b, 0x2a, 0x99, 0xad, + 0x5a, 0x50, 0xd9, 0x40, 0xf1, 0xd2, 0xf6, 0x1f, 0x5d, 0x82, 0xfa, 0xcb, 0xb9, 0x8f, 0x5e, 0x42, + 0x47, 0x7b, 0x29, 0x89, 0x4a, 0xd7, 0x7f, 0x6a, 0x39, 0x55, 0x0f, 0x2a, 0x47, 0xbf, 0xf8, 0xa7, + 0x7f, 0xff, 0x93, 0xda, 0x06, 0x5e, 0xbd, 0xfb, 0xe6, 0xff, 0xdf, 0x75, 0x7d, 0x5f, 0xda, 0xe2, + 0x7d, 0xeb, 0x16, 0xb2, 0xa1, 0x25, 0x1e, 0x43, 0xa2, 0x2d, 0x8d, 0x86, 0x56, 0xe0, 0x8d, 0x2e, + 0x94, 0xe0, 0x82, 0xee, 0x16, 0xa3, 0x3b, 0xc0, 0x1d, 0x41, 0x97, 0x1e, 0x53, 0x94, 0xe6, 0x2e, + 0xd4, 0x77, 0xdd, 0x08, 0x21, 0x75, 0xbb, 0x2f, 0x63, 0xc2, 0x68, 0xdd, 0x80, 0x09, 0x3a, 0x88, + 0xd1, 0xe9, 0xe2, 0x16, 0xa5, 0x33, 0x75, 0x23, 0x4a, 0xe3, 0x08, 0xfa, 0xe6, 0xdb, 0x29, 0x74, + 0x45, 0xbf, 0xa4, 0x2a, 0x3d, 0xda, 0x1a, 0x5d, 0x5d, 0x34, 0x5d, 0x58, 0x6c, 0x9f, 0x32, 0xf1, + 0x18, 0x0e, 0x8d, 0x0f, 0xc8, 0x83, 0xae, 0xfe, 0x94, 0x09, 0xa9, 0x07, 0x35, 0xe5, 0xf7, 0x59, + 0xa3, 0xcb, 0xd5, 0x93, 0x82, 0xc5, 0x90, 0xb1, 0x40, 0x78, 0xc0, 0x58, 0x50, 0x0c, 0x71, 0x8b, + 0x46, 0xa5, 0x2c, 0xde, 0x2f, 0x29, 0x29, 0x9b, 0xcf, 0x9f, 0x94, 0x94, 0x8b, 0x0f, 0x9d, 0x0c, + 0x29, 0x8b, 0x98, 0x48, 0x25, 0xf4, 0x73, 0xe8, 0xbd, 0x60, 0xef, 0x16, 0xc5, 0xab, 0x19, 0x45, + 0xd9, 0x7c, 0x74, 0xa3, 0x28, 0x17, 0x9e, 0xd7, 0xe0, 0xcb, 0x8c, 0xf2, 0x16, 0x5e, 0xa3, 0x94, + 0xf9, 0x1b, 0x48, 0x9f, 0xa3, 0x08, 0xcb, 0xf8, 0xde, 0x94, 0x8d, 0x35, 0x6b, 0x34, 0x7f, 0x1b, + 0x7a, 0xc6, 0xa3, 0x1b, 0x94, 0x0b, 0xb4, 0xea, 0x35, 0xcf, 0xe8, 0xca, 0x82, 0xd9, 0xaa, 0xf5, + 0xfb, 0x02, 0x85, 0x3d, 0xd3, 0xa1, 0xbc, 0x5e, 0x02, 0xa8, 0xc7, 0x2b, 0xca, 0x05, 0x4b, 0x0f, + 0x66, 0x94, 0x0b, 0x96, 0xdf, 0xba, 0xe0, 0x75, 0xc6, 0xa2, 0x87, 0x3a, 0xdc, 0x34, 0x39, 0xad, + 0x09, 0xb4, 0xc4, 0x33, 0x0d, 0x25, 0x19, 0xf3, 0xad, 0x8a, 0x92, 0x4c, 0xe1, 0x3d, 0x07, 0x1e, + 0x30, 0x82, 0x80, 0xda, 0x94, 0x60, 0x40, 0x49, 0xfc, 0x26, 0x74, 0xb4, 0x37, 0x0e, 0x48, 0x5f, + 0x4d, 0xe1, 0x39, 0x84, 0xf2, 0xf2, 0x8a, 0x47, 0x11, 0x78, 0x83, 0x51, 0xee, 0xa3, 0x2e, 0xa5, + 0x2c, 0xbb, 0x28, 0x82, 0xba, 0x7c, 0xc4, 0x60, 0x50, 0x2f, 0xbc, 0x8c, 0x30, 0xa8, 0x17, 0x5f, + 0x3d, 0x98, 0xd4, 0xa9, 0x8c, 0xd9, 0xda, 0x5f, 0x00, 0xa8, 0xfb, 0x76, 0x25, 0xe3, 0xd2, 0xc3, + 0x01, 0x25, 0xe3, 0xf2, 0xf5, 0xbc, 0x74, 0x7f, 0x04, 0x94, 0xb4, 0xb8, 0x95, 0x3a, 0x82, 0xbe, + 0xf9, 0x1c, 0x42, 0xb9, 0x7f, 0xe5, 0xfb, 0x09, 0xe5, 0xfe, 0xd5, 0xaf, 0x28, 0xa4, 0x45, 0x22, + 0xee, 0xfe, 0x8a, 0xec, 0x21, 0xac, 0xe4, 0x17, 0xf5, 0x68, 0xa8, 0x13, 0xd1, 0xef, 0xf3, 0x47, + 0x17, 0x2b, 0x66, 0x64, 0x13, 0x84, 0x51, 0xee, 0xa0, 0x15, 0x4a, 0x99, 0xdf, 0xd7, 0x48, 0xa2, + 0xec, 0xc9, 0x90, 0x49, 0x54, 0xbb, 0xe5, 0x2f, 0x10, 0xd5, 0xef, 0xfa, 0x0b, 0x44, 0x19, 0x1d, + 0x07, 0x3a, 0xda, 0x35, 0xb0, 0xd2, 0x64, 0xf9, 0x0e, 0x5b, 0x69, 0xb2, 0xe2, 0xde, 0x18, 0x5f, + 0x60, 0xa4, 0xd7, 0xf8, 0x69, 0x10, 0xcf, 0x48, 0x24, 0x83, 0xd4, 0x6f, 0x01, 0xa8, 0xf6, 0xb8, + 0x52, 0x66, 0xe9, 0xe2, 0x44, 0x19, 0x77, 0xa1, 0x9b, 0x8e, 0x2f, 0x32, 0xd2, 0xeb, 0x3c, 0xc6, + 0xb2, 0x2b, 0x0b, 0xa6, 0xce, 0xfb, 0xd6, 0xad, 0x7b, 0x16, 0x7a, 0x05, 0x7d, 0x85, 0x7f, 0x78, + 0x16, 0x79, 0xe7, 0xb1, 0x18, 0x55, 0x4d, 0x89, 0x0d, 0x5c, 0x61, 0x5c, 0x2e, 0x60, 0x64, 0x72, + 0x49, 0xcf, 0x22, 0x8f, 0xfa, 0xfd, 0xcf, 0xa0, 0xa3, 0x3d, 0xd0, 0x53, 0x72, 0x2a, 0xbf, 0xda, + 0x1b, 0x55, 0x35, 0xf0, 0xcd, 0xd3, 0x52, 0xd4, 0x48, 0xe9, 0xa9, 0x3b, 0xa3, 0xb4, 0x23, 0xe8, + 0x9b, 0x7d, 0x6a, 0x65, 0x96, 0x95, 0x4d, 0x6f, 0x65, 0x96, 0x0b, 0xda, 0xdb, 0xc6, 0x5e, 0x78, + 0x7b, 0x56, 0x3f, 0x9d, 0xa7, 0x34, 0x21, 0xc9, 0xdb, 0xd5, 0x7a, 0x42, 0x52, 0x6c, 0x89, 0xeb, + 0x09, 0x49, 0xa9, 0xbf, 0x6d, 0xee, 0x89, 0xb3, 0x91, 0x9a, 0x41, 0x09, 0xac, 0x16, 0x7a, 0xc9, + 0xa8, 0xb0, 0xea, 0x62, 0xfb, 0x79, 0xf4, 0xc1, 0xc2, 0x79, 0xc1, 0xef, 0x2a, 0xe3, 0x37, 0xc4, + 0xeb, 0x8a, 0x9f, 0x1b, 0x86, 0x5c, 0x4d, 0xfc, 0xec, 0x02, 0xd5, 0x19, 0x56, 0x76, 0x50, 0x6a, + 0x2e, 0x8f, 0x46, 0x55, 0x53, 0x82, 0x89, 0x61, 0x6d, 0x9c, 0x89, 0xcc, 0x40, 0xa6, 0xd0, 0xd1, + 0xfa, 0x95, 0x4a, 0x6e, 0xe5, 0x56, 0xa8, 0x92, 0x5b, 0x55, 0x83, 0xd3, 0x90, 0x5b, 0x4a, 0xb2, + 0x30, 0x3e, 0x62, 0x0d, 0x51, 0xca, 0xe3, 0x5b, 0x68, 0xcb, 0x4e, 0x27, 0xca, 0x3d, 0xa2, 0xd0, + 0x0e, 0x1d, 0x0d, 0xcb, 0x13, 0x05, 0x37, 0x64, 0x01, 0x35, 0x15, 0xb3, 0x94, 0xae, 0x03, 0xab, + 0x85, 0xbe, 0xa7, 0xd2, 0x47, 0x75, 0x43, 0x74, 0xd4, 0x33, 0xfe, 0x4d, 0x05, 0x5f, 0x62, 0xa4, + 0x37, 0x11, 0x93, 0x7e, 0x2a, 0x3f, 0x61, 0xff, 0x46, 0x92, 0xde, 0xb3, 0x10, 0xd1, 0x18, 0x14, + 0x15, 0x5e, 0xdd, 0xa7, 0x1d, 0x99, 0x0f, 0x19, 0xf9, 0x1d, 0xfe, 0x02, 0x36, 0x5c, 0xc9, 0xf7, + 0x2c, 0x34, 0x2b, 0x34, 0x61, 0x45, 0x37, 0x4f, 0x8b, 0xe4, 0x95, 0x3d, 0xda, 0x51, 0xd5, 0xfd, + 0x16, 0xfe, 0x01, 0xe3, 0x75, 0x09, 0x5d, 0x34, 0x78, 0x51, 0xb7, 0x94, 0xd7, 0x7b, 0xf7, 0x2c, + 0x34, 0x85, 0xbe, 0x49, 0xf2, 0xbd, 0x58, 0x15, 0xfc, 0x1f, 0xa1, 0x12, 0x2b, 0xca, 0xe3, 0x77, + 0xb5, 0xae, 0xb4, 0xd1, 0x7b, 0x46, 0x37, 0xaa, 0x79, 0x15, 0x7a, 0xd3, 0xa3, 0x0d, 0x9d, 0xa7, + 0x9c, 0xc4, 0x98, 0x31, 0xbd, 0x8c, 0x46, 0x65, 0xa6, 0xae, 0xc0, 0x61, 0x21, 0xb4, 0xab, 0x77, + 0x45, 0x54, 0xae, 0x5a, 0xd1, 0x58, 0x51, 0xb9, 0x6a, 0x55, 0x23, 0x45, 0x2a, 0x8f, 0xe7, 0xaa, + 0xac, 0x6b, 0x72, 0xcc, 0x31, 0x78, 0xf2, 0x5d, 0xe8, 0x9e, 0x5c, 0x5e, 0xd0, 0x5f, 0x28, 0xa4, + 0x69, 0x95, 0xdd, 0x07, 0xe9, 0xa7, 0x68, 0x4d, 0xb2, 0x0a, 0xa2, 0x23, 0xde, 0x84, 0x40, 0x5f, + 0x41, 0x93, 0x95, 0xf6, 0x68, 0x43, 0x95, 0x41, 0xaa, 0x83, 0x30, 0xda, 0x2c, 0x40, 0xcd, 0x5c, + 0x04, 0xb3, 0xc3, 0x71, 0x1e, 0x89, 0x8a, 0x61, 0x0a, 0x7d, 0x9e, 0x0f, 0xcb, 0x02, 0x58, 0x79, + 0x65, 0xa1, 0x3e, 0x57, 0x5e, 0x59, 0xac, 0x95, 0xcd, 0x78, 0xcc, 0x53, 0xe2, 0x53, 0x81, 0x73, + 0xdf, 0xba, 0x35, 0x5d, 0x66, 0xff, 0xb8, 0xf6, 0xe9, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xb0, + 0x2f, 0x50, 0xfc, 0xe3, 0x36, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. From 1965731d669bd00d495129e1a559b03289f7c896 Mon Sep 17 00:00:00 2001 From: rsercano Date: Tue, 5 Jan 2021 18:34:59 +0300 Subject: [PATCH 15/16] fixed comment on proto --- docs/api.md | 2 +- lib/proto/xudrpc.swagger.json | 2 +- proto/xudrpc.proto | 2 +- test/simulation/xudrpc/xudrpc.pb.go | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/api.md b/docs/api.md index 73bebe4fc..dad06172b 100644 --- a/docs/api.md +++ b/docs/api.md @@ -207,7 +207,7 @@ | side | [BalanceAlert.Side](#xudrpc.BalanceAlert.Side) | | | | bound | [uint32](#uint32) | | The bound of the low balance in percentage. | | percent | [uint32](#uint32) | | The percent of the total trading balance. | -| side_balance | [uint64](#uint64) | | The current side balance. | +| side_balance | [uint64](#uint64) | | The balance in satoshis on this side of the channel | | currency | [string](#string) | | The currency of the channel this alert is for. | diff --git a/lib/proto/xudrpc.swagger.json b/lib/proto/xudrpc.swagger.json index 2f4c73b50..44a58a92b 100644 --- a/lib/proto/xudrpc.swagger.json +++ b/lib/proto/xudrpc.swagger.json @@ -1098,7 +1098,7 @@ "side_balance": { "type": "string", "format": "uint64", - "description": "The current side balance." + "title": "The balance in satoshis on this side of the channel" }, "currency": { "type": "string", diff --git a/proto/xudrpc.proto b/proto/xudrpc.proto index eb17dc7f2..9391a324e 100644 --- a/proto/xudrpc.proto +++ b/proto/xudrpc.proto @@ -452,7 +452,7 @@ message BalanceAlert { uint32 bound = 3 [json_name = "bound"]; // The percent of the total trading balance. uint32 percent = 4 [json_name = "percent"]; - // The current side balance. + // The balance in satoshis on this side of the channel uint64 side_balance = 5 [json_name = "side_balance"]; // The currency of the channel this alert is for. string currency = 6 [json_name = "currency"]; diff --git a/test/simulation/xudrpc/xudrpc.pb.go b/test/simulation/xudrpc/xudrpc.pb.go index 1d6807b5a..b9e3276bc 100644 --- a/test/simulation/xudrpc/xudrpc.pb.go +++ b/test/simulation/xudrpc/xudrpc.pb.go @@ -518,7 +518,7 @@ type BalanceAlert struct { Bound uint32 `protobuf:"varint,3,opt,name=bound,proto3" json:"bound,omitempty"` // The percent of the total trading balance. Percent uint32 `protobuf:"varint,4,opt,name=percent,proto3" json:"percent,omitempty"` - // The current side balance. + // The balance in satoshis on this side of the channel SideBalance uint64 `protobuf:"varint,5,opt,name=side_balance,proto3" json:"side_balance,omitempty"` // The currency of the channel this alert is for. Currency string `protobuf:"bytes,6,opt,name=currency,proto3" json:"currency,omitempty"` From 9d380b9be77a5fc1e4567b9fb8ba8f3230499090 Mon Sep 17 00:00:00 2001 From: rsercano Date: Tue, 5 Jan 2021 18:38:24 +0300 Subject: [PATCH 16/16] fixed lint --- lib/lndclient/LndClient.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/lndclient/LndClient.ts b/lib/lndclient/LndClient.ts index 7af4df323..ea60979f3 100644 --- a/lib/lndclient/LndClient.ts +++ b/lib/lndclient/LndClient.ts @@ -22,7 +22,7 @@ import SwapClient, { ClientStatus, PaymentState, SwapClientInfo, - WithdrawArguments + WithdrawArguments, } from '../swaps/SwapClient'; import { CloseChannelParams, OpenChannelParams, SwapCapacities, SwapDeal } from '../swaps/types'; import { deriveChild } from '../utils/seedutil';