diff --git a/docs/api.md b/docs/api.md index fb7fb7513..5145abcfe 100644 --- a/docs/api.md +++ b/docs/api.md @@ -67,6 +67,8 @@ - [RestoreNodeRequest](#xudrpc.RestoreNodeRequest) - [RestoreNodeRequest.LndBackupsEntry](#xudrpc.RestoreNodeRequest.LndBackupsEntry) - [RestoreNodeResponse](#xudrpc.RestoreNodeResponse) + - [SetLogLevelRequest](#xudrpc.SetLogLevelRequest) + - [SetLogLevelResponse](#xudrpc.SetLogLevelResponse) - [ShutdownRequest](#xudrpc.ShutdownRequest) - [ShutdownResponse](#xudrpc.ShutdownResponse) - [SubscribeOrdersRequest](#xudrpc.SubscribeOrdersRequest) @@ -91,6 +93,7 @@ - [Currency.SwapClient](#xudrpc.Currency.SwapClient) - [ListOrdersRequest.Owner](#xudrpc.ListOrdersRequest.Owner) + - [LogLevel](#xudrpc.LogLevel) - [OrderSide](#xudrpc.OrderSide) - [Role](#xudrpc.Role) @@ -1096,6 +1099,31 @@ + + +### SetLogLevelRequest + + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| log_level | [LogLevel](#xudrpc.LogLevel) | | | + + + + + + + + +### SetLogLevelResponse + + + + + + + ### ShutdownRequest @@ -1463,6 +1491,23 @@ + + +### LogLevel + + +| Name | Number | Description | +| ---- | ------ | ----------- | +| ALERT | 0 | | +| ERROR | 1 | | +| WARN | 2 | | +| INFO | 3 | | +| VERBOSE | 4 | | +| DEBUG | 5 | | +| TRACE | 6 | | + + + ### OrderSide @@ -1522,6 +1567,7 @@ The primary service for interacting with a running xud node. | RemoveOrder | [RemoveOrderRequest](#xudrpc.RemoveOrderRequest) | [RemoveOrderResponse](#xudrpc.RemoveOrderResponse) | Removes an order from the order book by its local id. This should be called when an order is canceled or filled outside of xud. Removed orders become immediately unavailable for swaps, and peers are notified that the order is no longer valid. Any portion of the order that is on hold due to ongoing swaps will not be removed until after the swap attempts complete. shell: xucli removeorder <order_id> [quantity] | | RemoveAllOrders | [RemoveAllOrdersRequest](#xudrpc.RemoveAllOrdersRequest) | [RemoveAllOrdersResponse](#xudrpc.RemoveAllOrdersResponse) | Removes all orders from the order book. Removed orders become immediately unavailable for swaps, and peers are notified that the orders are no longer valid. Any portion of the orders that is on hold due to ongoing swaps will not be removed until after the swap attempts complete. shell: xucli removeallorders | | 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 | | 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. | diff --git a/lib/Logger.ts b/lib/Logger.ts index 7e78d846c..280770c5b 100644 --- a/lib/Logger.ts +++ b/lib/Logger.ts @@ -23,6 +23,16 @@ const LevelPriorities = { trace: 6, }; +enum LevelPriority { + alert, + error, + warn, + info, + verbose, + debug, + trace, +} + export enum Context { Global = 'GLOBAL', DB = 'DB', @@ -138,6 +148,12 @@ class Logger { }); } + public setLogLevel = (level: Level) => { + this.logger?.transports.forEach((transport) => { + transport.level = level; + }); + } + private getLogFormat = (colorize: boolean, dateFormat?: string) => { const { format } = winston; @@ -219,4 +235,4 @@ class Logger { } export default Logger; -export { Level, Loggers }; +export { Level, Loggers, LevelPriority }; diff --git a/lib/Xud.ts b/lib/Xud.ts index 489a50a4f..cb601e62e 100644 --- a/lib/Xud.ts +++ b/lib/Xud.ts @@ -213,6 +213,13 @@ class Xud extends EventEmitter { shutdown: this.beginShutdown, }); + this.service.on('logLevel', (level) => { + this.swapClientManager?.setLogLevel(level); + Object.values(loggers).forEach((logger) => { + logger.setLogLevel(level); + }); + }); + if (this.swapClientManager.connextClient?.isOperational()) { this.httpServer = new HttpServer(loggers.http, this.service); await this.httpServer.listen( diff --git a/lib/cli/commands/loglevel.ts b/lib/cli/commands/loglevel.ts new file mode 100644 index 000000000..600fb08b9 --- /dev/null +++ b/lib/cli/commands/loglevel.ts @@ -0,0 +1,29 @@ +import { Arguments, Argv } from 'yargs'; +import { LogLevel, SetLogLevelRequest } from '../../proto/xudrpc_pb'; +import { callback, loadXudClient } from '../command'; +import { LevelPriority } from '../../Logger'; + +export const command = 'loglevel '; + +export const describe = 'set the logging level for xud'; + +export const builder = (argv: Argv) => argv + .positional('level', { + description: 'the logging level', + type: 'string', + choices: ['alert', 'error', 'warn', 'verbose', 'info', 'debug', 'trace'], + coerce: (logLevelStr: string) => { + const logLevelLower = logLevelStr.toLowerCase(); + return logLevelLower; + }, + }) + .example('$0 loglevel trace', 'set log level to trace') + .example('$0 loglevel info', 'set log level to info'); + +export const handler = async (argv: Arguments) => { + const request = new SetLogLevelRequest(); + const levelPriority = LevelPriority[argv.level] as unknown as number; + const logLevel: LogLevel = levelPriority as LogLevel; + request.setLogLevel(logLevel); + (await loadXudClient(argv)).setLogLevel(request, callback(argv)); +}; diff --git a/lib/cli/commands/unlock.ts b/lib/cli/commands/unlock.ts index e3e6ae82c..286d05b67 100644 --- a/lib/cli/commands/unlock.ts +++ b/lib/cli/commands/unlock.ts @@ -10,7 +10,7 @@ export const describe = 'unlock local xud node'; export const builder = {}; const formatOutput = (response: UnlockNodeResponse.AsObject) => { - console.log('xud was unlocked succesfully'); + console.log('xud was unlocked successfully'); if (response.unlockedLndsList.length) { console.log(`The following wallets were unlocked: ${response.unlockedLndsList.join(', ')}`); } diff --git a/lib/grpc/GrpcService.ts b/lib/grpc/GrpcService.ts index 715f00dd5..79a0f75ff 100644 --- a/lib/grpc/GrpcService.ts +++ b/lib/grpc/GrpcService.ts @@ -843,6 +843,20 @@ class GrpcService { } } + public setLogLevel: grpc.handleUnaryCall = async (call, callback) => { + if (!this.isReady(this.service, callback)) { + return; + } + try { + await this.service.setLogLevel(call.request.toObject()); + + const response = new xudrpc.SetLogLevelResponse(); + callback(null, response); + } catch (err) { + callback(getGrpcError(err), null); + } + } + public shutdown: grpc.handleUnaryCall = (_, callback) => { if (!this.isReady(this.service, callback)) { return; diff --git a/lib/grpc/getGrpcError.ts b/lib/grpc/getGrpcError.ts index 06358e0c8..1d50636c3 100644 --- a/lib/grpc/getGrpcError.ts +++ b/lib/grpc/getGrpcError.ts @@ -22,6 +22,7 @@ const getGrpcError = (err: any) => { case orderErrorCodes.MIN_QUANTITY_VIOLATED: case orderErrorCodes.QUANTITY_DOES_NOT_MATCH: case swapErrorCodes.REMOTE_IDENTIFIER_MISSING: + case orderErrorCodes.DUPLICATE_PAIR_CURRENCIES: code = status.INVALID_ARGUMENT; break; case orderErrorCodes.PAIR_DOES_NOT_EXIST: diff --git a/lib/orderbook/OrderBook.ts b/lib/orderbook/OrderBook.ts index ed8b42de7..008456973 100644 --- a/lib/orderbook/OrderBook.ts +++ b/lib/orderbook/OrderBook.ts @@ -290,6 +290,9 @@ class OrderBook extends EventEmitter { public addPair = async (pair: Pair) => { const pairId = derivePairId(pair); + if (pair.baseCurrency.toLowerCase() === pair.quoteCurrency.toLowerCase()) { + throw errors.DUPLICATE_PAIR_CURRENCIES(pair.baseCurrency, pair.quoteCurrency); + } if (this.pairInstances.has(pairId)) { throw errors.PAIR_ALREADY_EXISTS(pairId); } diff --git a/lib/orderbook/errors.ts b/lib/orderbook/errors.ts index 67eb64757..e9c674bb3 100644 --- a/lib/orderbook/errors.ts +++ b/lib/orderbook/errors.ts @@ -16,6 +16,7 @@ const errorCodes = { INSUFFICIENT_OUTBOUND_BALANCE: codesPrefix.concat('.12'), MIN_QUANTITY_VIOLATED: codesPrefix.concat('.13'), QUANTITY_ON_HOLD: codesPrefix.concat('.15'), + DUPLICATE_PAIR_CURRENCIES: codesPrefix.concat('.16'), }; const errors = { @@ -75,6 +76,10 @@ const errors = { message: `order with local id ${localId} has a quantity of ${holdQuantity} satoshis on hold, try again later`, code: errorCodes.QUANTITY_DOES_NOT_MATCH, }), + DUPLICATE_PAIR_CURRENCIES: (baseCurrency: string, quoteCurrency: string) => ({ + message: `base asset (${baseCurrency}) and quote asset (${quoteCurrency}) have to be different`, + code: errorCodes.DUPLICATE_PAIR_CURRENCIES, + }), }; export { errorCodes }; diff --git a/lib/proto/xudrpc.swagger.json b/lib/proto/xudrpc.swagger.json index d17e74aa2..ae36ba498 100644 --- a/lib/proto/xudrpc.swagger.json +++ b/lib/proto/xudrpc.swagger.json @@ -548,6 +548,33 @@ ] } }, + "/v1/setloglevel": { + "post": { + "summary": "Set the logging level.\nshell: xucli loglevel \u003clevel\u003e", + "operationId": "SetLogLevel", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/xudrpcSetLogLevelResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/xudrpcSetLogLevelRequest" + } + } + ], + "tags": [ + "Xud" + ] + } + }, "/v1/shutdown": { "post": { "summary": "Begin gracefully shutting down xud.\nshell: xucli shutdown", @@ -1277,6 +1304,19 @@ } } }, + "xudrpcLogLevel": { + "type": "string", + "enum": [ + "ALERT", + "ERROR", + "WARN", + "INFO", + "VERBOSE", + "DEBUG", + "TRACE" + ], + "default": "ALERT" + }, "xudrpcNodeIdentifier": { "type": "object", "properties": { @@ -1665,6 +1705,17 @@ ], "default": "TAKER" }, + "xudrpcSetLogLevelRequest": { + "type": "object", + "properties": { + "log_level": { + "$ref": "#/definitions/xudrpcLogLevel" + } + } + }, + "xudrpcSetLogLevelResponse": { + "type": "object" + }, "xudrpcShutdownRequest": { "type": "object" }, diff --git a/lib/proto/xudrpc_grpc_pb.d.ts b/lib/proto/xudrpc_grpc_pb.d.ts index bc6c63d9b..4a888d1b2 100644 --- a/lib/proto/xudrpc_grpc_pb.d.ts +++ b/lib/proto/xudrpc_grpc_pb.d.ts @@ -97,6 +97,7 @@ interface IXudService extends grpc.ServiceDefinition; responseDeserialize: grpc.deserialize; } +interface IXudService_ISetLogLevel extends grpc.MethodDefinition { + path: string; // "/xudrpc.Xud/SetLogLevel" + requestStream: boolean; // false + responseStream: boolean; // false + requestSerialize: grpc.serialize; + requestDeserialize: grpc.deserialize; + responseSerialize: grpc.serialize; + responseDeserialize: grpc.deserialize; +} interface IXudService_IShutdown extends grpc.MethodDefinition { path: string; // "/xudrpc.Xud/Shutdown" requestStream: boolean; // false @@ -413,6 +423,7 @@ export interface IXudServer { removeOrder: grpc.handleUnaryCall; removeAllOrders: grpc.handleUnaryCall; removePair: grpc.handleUnaryCall; + setLogLevel: grpc.handleUnaryCall; shutdown: grpc.handleUnaryCall; subscribeOrders: grpc.handleServerStreamingCall; subscribeSwapFailures: grpc.handleServerStreamingCall; @@ -490,6 +501,9 @@ export interface IXudClient { removePair(request: xudrpc_pb.RemovePairRequest, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.RemovePairResponse) => void): grpc.ClientUnaryCall; removePair(request: xudrpc_pb.RemovePairRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.RemovePairResponse) => void): grpc.ClientUnaryCall; removePair(request: xudrpc_pb.RemovePairRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.RemovePairResponse) => void): grpc.ClientUnaryCall; + setLogLevel(request: xudrpc_pb.SetLogLevelRequest, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.SetLogLevelResponse) => void): grpc.ClientUnaryCall; + setLogLevel(request: xudrpc_pb.SetLogLevelRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.SetLogLevelResponse) => void): grpc.ClientUnaryCall; + setLogLevel(request: xudrpc_pb.SetLogLevelRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.SetLogLevelResponse) => void): grpc.ClientUnaryCall; 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; @@ -582,6 +596,9 @@ export class XudClient extends grpc.Client implements IXudClient { public removePair(request: xudrpc_pb.RemovePairRequest, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.RemovePairResponse) => void): grpc.ClientUnaryCall; public removePair(request: xudrpc_pb.RemovePairRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.RemovePairResponse) => void): grpc.ClientUnaryCall; public removePair(request: xudrpc_pb.RemovePairRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.RemovePairResponse) => void): grpc.ClientUnaryCall; + public setLogLevel(request: xudrpc_pb.SetLogLevelRequest, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.SetLogLevelResponse) => void): grpc.ClientUnaryCall; + public setLogLevel(request: xudrpc_pb.SetLogLevelRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.SetLogLevelResponse) => void): grpc.ClientUnaryCall; + public setLogLevel(request: xudrpc_pb.SetLogLevelRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: xudrpc_pb.SetLogLevelResponse) => void): grpc.ClientUnaryCall; 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; diff --git a/lib/proto/xudrpc_grpc_pb.js b/lib/proto/xudrpc_grpc_pb.js index df6d1f975..d7d8d3997 100644 --- a/lib/proto/xudrpc_grpc_pb.js +++ b/lib/proto/xudrpc_grpc_pb.js @@ -543,6 +543,28 @@ function deserialize_xudrpc_RestoreNodeResponse(buffer_arg) { return xudrpc_pb.RestoreNodeResponse.deserializeBinary(new Uint8Array(buffer_arg)); } +function serialize_xudrpc_SetLogLevelRequest(arg) { + if (!(arg instanceof xudrpc_pb.SetLogLevelRequest)) { + throw new Error('Expected argument of type xudrpc.SetLogLevelRequest'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_xudrpc_SetLogLevelRequest(buffer_arg) { + return xudrpc_pb.SetLogLevelRequest.deserializeBinary(new Uint8Array(buffer_arg)); +} + +function serialize_xudrpc_SetLogLevelResponse(arg) { + if (!(arg instanceof xudrpc_pb.SetLogLevelResponse)) { + throw new Error('Expected argument of type xudrpc.SetLogLevelResponse'); + } + return Buffer.from(arg.serializeBinary()); +} + +function deserialize_xudrpc_SetLogLevelResponse(buffer_arg) { + return xudrpc_pb.SetLogLevelResponse.deserializeBinary(new Uint8Array(buffer_arg)); +} + function serialize_xudrpc_ShutdownRequest(arg) { if (!(arg instanceof xudrpc_pb.ShutdownRequest)) { throw new Error('Expected argument of type xudrpc.ShutdownRequest'); @@ -1094,6 +1116,19 @@ var XudService = exports.XudService = { responseSerialize: serialize_xudrpc_RemovePairResponse, responseDeserialize: deserialize_xudrpc_RemovePairResponse, }, + // Set the logging level. + // shell: xucli loglevel + setLogLevel: { + path: '/xudrpc.Xud/SetLogLevel', + requestStream: false, + responseStream: false, + requestType: xudrpc_pb.SetLogLevelRequest, + responseType: xudrpc_pb.SetLogLevelResponse, + requestSerialize: serialize_xudrpc_SetLogLevelRequest, + requestDeserialize: deserialize_xudrpc_SetLogLevelRequest, + responseSerialize: serialize_xudrpc_SetLogLevelResponse, + responseDeserialize: deserialize_xudrpc_SetLogLevelResponse, + }, // Begin gracefully shutting down xud. // shell: xucli shutdown shutdown: { diff --git a/lib/proto/xudrpc_pb.d.ts b/lib/proto/xudrpc_pb.d.ts index 7f935856c..575187fd5 100644 --- a/lib/proto/xudrpc_pb.d.ts +++ b/lib/proto/xudrpc_pb.d.ts @@ -1678,6 +1678,44 @@ export namespace RestoreNodeResponse { } } +export class SetLogLevelRequest extends jspb.Message { + getLogLevel(): LogLevel; + setLogLevel(value: LogLevel): void; + + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): SetLogLevelRequest.AsObject; + static toObject(includeInstance: boolean, msg: SetLogLevelRequest): SetLogLevelRequest.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: SetLogLevelRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): SetLogLevelRequest; + static deserializeBinaryFromReader(message: SetLogLevelRequest, reader: jspb.BinaryReader): SetLogLevelRequest; +} + +export namespace SetLogLevelRequest { + export type AsObject = { + logLevel: LogLevel, + } +} + +export class SetLogLevelResponse extends jspb.Message { + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): SetLogLevelResponse.AsObject; + static toObject(includeInstance: boolean, msg: SetLogLevelResponse): SetLogLevelResponse.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: SetLogLevelResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): SetLogLevelResponse; + static deserializeBinaryFromReader(message: SetLogLevelResponse, reader: jspb.BinaryReader): SetLogLevelResponse; +} + +export namespace SetLogLevelResponse { + export type AsObject = { + } +} + export class ShutdownRequest extends jspb.Message { serializeBinary(): Uint8Array; @@ -2286,3 +2324,13 @@ export enum Role { MAKER = 1, INTERNAL = 2, } + +export enum LogLevel { + ALERT = 0, + ERROR = 1, + WARN = 2, + INFO = 3, + VERBOSE = 4, + DEBUG = 5, + TRACE = 6, +} diff --git a/lib/proto/xudrpc_pb.js b/lib/proto/xudrpc_pb.js index be7b58c74..28882f179 100644 --- a/lib/proto/xudrpc_pb.js +++ b/lib/proto/xudrpc_pb.js @@ -51,6 +51,7 @@ goog.exportSymbol('proto.xudrpc.ListPairsResponse', null, global); goog.exportSymbol('proto.xudrpc.ListPeersRequest', null, global); goog.exportSymbol('proto.xudrpc.ListPeersResponse', null, global); goog.exportSymbol('proto.xudrpc.LndInfo', null, global); +goog.exportSymbol('proto.xudrpc.LogLevel', null, global); goog.exportSymbol('proto.xudrpc.NodeIdentifier', null, global); goog.exportSymbol('proto.xudrpc.OpenChannelRequest', null, global); goog.exportSymbol('proto.xudrpc.OpenChannelResponse', null, global); @@ -75,6 +76,8 @@ goog.exportSymbol('proto.xudrpc.RemovePairResponse', null, global); goog.exportSymbol('proto.xudrpc.RestoreNodeRequest', null, global); goog.exportSymbol('proto.xudrpc.RestoreNodeResponse', null, global); goog.exportSymbol('proto.xudrpc.Role', null, global); +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.SubscribeOrdersRequest', null, global); @@ -11280,6 +11283,264 @@ proto.xudrpc.RestoreNodeResponse.prototype.setRestoredConnext = 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.SetLogLevelRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.xudrpc.SetLogLevelRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.xudrpc.SetLogLevelRequest.displayName = 'proto.xudrpc.SetLogLevelRequest'; +} + + +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.SetLogLevelRequest.prototype.toObject = function(opt_includeInstance) { + return proto.xudrpc.SetLogLevelRequest.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.SetLogLevelRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.SetLogLevelRequest.toObject = function(includeInstance, msg) { + var f, obj = { + logLevel: jspb.Message.getFieldWithDefault(msg, 1, 0) + }; + + 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.SetLogLevelRequest} + */ +proto.xudrpc.SetLogLevelRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.xudrpc.SetLogLevelRequest; + return proto.xudrpc.SetLogLevelRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.xudrpc.SetLogLevelRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.xudrpc.SetLogLevelRequest} + */ +proto.xudrpc.SetLogLevelRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!proto.xudrpc.LogLevel} */ (reader.readEnum()); + msg.setLogLevel(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.xudrpc.SetLogLevelRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.xudrpc.SetLogLevelRequest.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.SetLogLevelRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.SetLogLevelRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getLogLevel(); + if (f !== 0.0) { + writer.writeEnum( + 1, + f + ); + } +}; + + +/** + * optional LogLevel log_level = 1; + * @return {!proto.xudrpc.LogLevel} + */ +proto.xudrpc.SetLogLevelRequest.prototype.getLogLevel = function() { + return /** @type {!proto.xudrpc.LogLevel} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** @param {!proto.xudrpc.LogLevel} value */ +proto.xudrpc.SetLogLevelRequest.prototype.setLogLevel = function(value) { + jspb.Message.setProto3EnumField(this, 1, 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.SetLogLevelResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.xudrpc.SetLogLevelResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.xudrpc.SetLogLevelResponse.displayName = 'proto.xudrpc.SetLogLevelResponse'; +} + + +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.SetLogLevelResponse.prototype.toObject = function(opt_includeInstance) { + return proto.xudrpc.SetLogLevelResponse.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.SetLogLevelResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.SetLogLevelResponse.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.SetLogLevelResponse} + */ +proto.xudrpc.SetLogLevelResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.xudrpc.SetLogLevelResponse; + return proto.xudrpc.SetLogLevelResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.xudrpc.SetLogLevelResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.xudrpc.SetLogLevelResponse} + */ +proto.xudrpc.SetLogLevelResponse.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.SetLogLevelResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.xudrpc.SetLogLevelResponse.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.SetLogLevelResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.xudrpc.SetLogLevelResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a @@ -15343,4 +15604,17 @@ proto.xudrpc.Role = { INTERNAL: 2 }; +/** + * @enum {number} + */ +proto.xudrpc.LogLevel = { + ALERT: 0, + ERROR: 1, + WARN: 2, + INFO: 3, + VERBOSE: 4, + DEBUG: 5, + TRACE: 6 +}; + goog.object.extend(exports, proto.xudrpc); diff --git a/lib/service/Service.ts b/lib/service/Service.ts index ad0b0c28f..d7e79c3cd 100644 --- a/lib/service/Service.ts +++ b/lib/service/Service.ts @@ -3,7 +3,7 @@ import { takeUntil } from 'rxjs/operators'; import { ProvidePreimageEvent, TransferReceivedEvent } from '../connextclient/types'; import { OrderSide, Owner, SwapClientType, SwapRole } from '../constants/enums'; import { OrderAttributes, TradeInstance } from '../db/types'; -import Logger from '../Logger'; +import Logger, { Level, LevelPriority } from '../Logger'; import OrderBook from '../orderbook/OrderBook'; import { Currency, isOwnOrder, Order, OrderPortion, OwnLimitOrder, OwnMarketOrder, OwnOrder, PeerOrder, PlaceOrderEvent } from '../orderbook/types'; import Pool from '../p2p/Pool'; @@ -18,6 +18,7 @@ import { checkDecimalPlaces, sortOrders, toEip55Address } from '../utils/utils'; import commitHash from '../Version'; import errors from './errors'; import { NodeIdentifier, ServiceComponents, ServiceOrder, ServiceOrderSidesArrays, ServicePlaceOrderEvent, ServiceTrade, XudInfo } from './types'; +import { EventEmitter } from 'events'; /** Functions to check argument validity and throw [[INVALID_ARGUMENT]] when invalid. */ const argChecks = { @@ -52,8 +53,13 @@ const argChecks = { }, }; +interface Service { + on(event: 'logLevel', listener: (level: Level) => void): this; + emit(event: 'logLevel', level: Level): boolean; +} + /** A class containing the available RPC methods for an unlocked, running instance of xud. */ -class Service { +class Service extends EventEmitter { public shutdown: () => void; /** Whether the service is disabled - in other words whether xud is locked. */ public disabled = false; @@ -66,6 +72,8 @@ class Service { /** Create an instance of available RPC methods and bind all exposed functions. */ constructor(components: ServiceComponents) { + super(); + this.shutdown = components.shutdown; this.orderBook = components.orderBook; this.swapClientManager = components.swapClientManager; @@ -406,6 +414,11 @@ class Service { }; } + public setLogLevel = async (args: { logLevel: number }) => { + const level = LevelPriority[args.logLevel] as Level; + this.emit('logLevel', level); + } + private toServiceOrder = (order: Order, includeAliases = false): ServiceOrder => { const { id, createdAt, pairId, price, quantity } = order; let serviceOrder: ServiceOrder; diff --git a/lib/swaps/SwapClientManager.ts b/lib/swaps/SwapClientManager.ts index 4e0877287..ee37edd60 100644 --- a/lib/swaps/SwapClientManager.ts +++ b/lib/swaps/SwapClientManager.ts @@ -6,7 +6,7 @@ import { Models } from '../db/DB'; import lndErrors from '../lndclient/errors'; import LndClient from '../lndclient/LndClient'; import { LndInfo } from '../lndclient/types'; -import { Loggers } from '../Logger'; +import { Loggers, Level } from '../Logger'; import { Currency } from '../orderbook/types'; import Peer from '../p2p/Peer'; import { UnitConverter } from '../utils/UnitConverter'; @@ -218,6 +218,12 @@ class SwapClientManager extends EventEmitter { this.inboundReservedAmounts.set(currency, inboundReservedAmount - amount); } + public setLogLevel = (level: Level) => { + for (const client of this.swapClients.values()) { + client.logger.setLogLevel(level); + } + } + /** * Initializes wallets with seed and password. */ diff --git a/proto/xudrpc.proto b/proto/xudrpc.proto index 8775e0460..df9485658 100644 --- a/proto/xudrpc.proto +++ b/proto/xudrpc.proto @@ -251,6 +251,15 @@ service Xud { }; } + /* Set the logging level. + * shell: xucli loglevel */ + rpc SetLogLevel(SetLogLevelRequest) returns (SetLogLevelResponse) { + option (google.api.http) = { + post: "/v1/setloglevel" + body: "*" + }; + } + /* Begin gracefully shutting down xud. * shell: xucli shutdown */ rpc Shutdown(ShutdownRequest) returns (ShutdownResponse) { @@ -347,6 +356,16 @@ enum Role { INTERNAL = 2; } +enum LogLevel { + ALERT = 0; + ERROR = 1; + WARN = 2; + INFO = 3; + VERBOSE = 4; + DEBUG = 5; + TRACE = 6; +} + message AddCurrencyResponse {} message AddPairRequest { @@ -789,6 +808,11 @@ message RestoreNodeResponse { bool restored_connext = 2; } +message SetLogLevelRequest { + LogLevel log_level = 1 [json_name = "log_level"]; +} +message SetLogLevelResponse {} + message ShutdownRequest {} message ShutdownResponse {} diff --git a/test/simulation/xudrpc/xudrpc.pb.go b/test/simulation/xudrpc/xudrpc.pb.go index ccd0c0f06..84b3e4d07 100644 --- a/test/simulation/xudrpc/xudrpc.pb.go +++ b/test/simulation/xudrpc/xudrpc.pb.go @@ -79,6 +79,46 @@ func (Role) EnumDescriptor() ([]byte, []int) { return fileDescriptor_6960a02cc0a63cf6, []int{1} } +type LogLevel int32 + +const ( + LogLevel_ALERT LogLevel = 0 + LogLevel_ERROR LogLevel = 1 + LogLevel_WARN LogLevel = 2 + LogLevel_INFO LogLevel = 3 + LogLevel_VERBOSE LogLevel = 4 + LogLevel_DEBUG LogLevel = 5 + LogLevel_TRACE LogLevel = 6 +) + +var LogLevel_name = map[int32]string{ + 0: "ALERT", + 1: "ERROR", + 2: "WARN", + 3: "INFO", + 4: "VERBOSE", + 5: "DEBUG", + 6: "TRACE", +} + +var LogLevel_value = map[string]int32{ + "ALERT": 0, + "ERROR": 1, + "WARN": 2, + "INFO": 3, + "VERBOSE": 4, + "DEBUG": 5, + "TRACE": 6, +} + +func (x LogLevel) String() string { + return proto.EnumName(LogLevel_name, int32(x)) +} + +func (LogLevel) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_6960a02cc0a63cf6, []int{2} +} + type Currency_SwapClient int32 const ( @@ -3264,6 +3304,76 @@ func (m *RestoreNodeResponse) GetRestoredConnext() bool { return false } +type SetLogLevelRequest struct { + LogLevel LogLevel `protobuf:"varint,1,opt,name=log_level,proto3,enum=xudrpc.LogLevel" json:"log_level,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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{58} +} + +func (m *SetLogLevelRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SetLogLevelRequest.Unmarshal(m, b) +} +func (m *SetLogLevelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SetLogLevelRequest.Marshal(b, m, deterministic) +} +func (m *SetLogLevelRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetLogLevelRequest.Merge(m, src) +} +func (m *SetLogLevelRequest) XXX_Size() int { + return xxx_messageInfo_SetLogLevelRequest.Size(m) +} +func (m *SetLogLevelRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SetLogLevelRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SetLogLevelRequest proto.InternalMessageInfo + +func (m *SetLogLevelRequest) GetLogLevel() LogLevel { + if m != nil { + return m.LogLevel + } + return LogLevel_ALERT +} + +type SetLogLevelResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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{59} +} + +func (m *SetLogLevelResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SetLogLevelResponse.Unmarshal(m, b) +} +func (m *SetLogLevelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SetLogLevelResponse.Marshal(b, m, deterministic) +} +func (m *SetLogLevelResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetLogLevelResponse.Merge(m, src) +} +func (m *SetLogLevelResponse) XXX_Size() int { + return xxx_messageInfo_SetLogLevelResponse.Size(m) +} +func (m *SetLogLevelResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SetLogLevelResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SetLogLevelResponse proto.InternalMessageInfo + type ShutdownRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -3274,7 +3384,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{58} + return fileDescriptor_6960a02cc0a63cf6, []int{60} } func (m *ShutdownRequest) XXX_Unmarshal(b []byte) error { @@ -3305,7 +3415,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{59} + return fileDescriptor_6960a02cc0a63cf6, []int{61} } func (m *ShutdownResponse) XXX_Unmarshal(b []byte) error { @@ -3338,7 +3448,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{60} + return fileDescriptor_6960a02cc0a63cf6, []int{62} } func (m *SubscribeOrdersRequest) XXX_Unmarshal(b []byte) error { @@ -3376,7 +3486,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{61} + return fileDescriptor_6960a02cc0a63cf6, []int{63} } func (m *SubscribeSwapsAcceptedRequest) XXX_Unmarshal(b []byte) error { @@ -3410,7 +3520,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{62} + return fileDescriptor_6960a02cc0a63cf6, []int{64} } func (m *SubscribeSwapsRequest) XXX_Unmarshal(b []byte) error { @@ -3470,7 +3580,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{63} + return fileDescriptor_6960a02cc0a63cf6, []int{65} } func (m *SwapAccepted) XXX_Unmarshal(b []byte) error { @@ -3588,7 +3698,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{64} + return fileDescriptor_6960a02cc0a63cf6, []int{66} } func (m *SwapFailure) XXX_Unmarshal(b []byte) error { @@ -3680,7 +3790,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{65} + return fileDescriptor_6960a02cc0a63cf6, []int{67} } func (m *SwapSuccess) XXX_Unmarshal(b []byte) error { @@ -3824,7 +3934,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{66} + return fileDescriptor_6960a02cc0a63cf6, []int{68} } func (m *Trade) XXX_Unmarshal(b []byte) error { @@ -3927,7 +4037,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{67} + return fileDescriptor_6960a02cc0a63cf6, []int{69} } func (m *TradeHistoryRequest) XXX_Unmarshal(b []byte) error { @@ -3966,7 +4076,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{68} + return fileDescriptor_6960a02cc0a63cf6, []int{70} } func (m *TradeHistoryResponse) XXX_Unmarshal(b []byte) error { @@ -4012,7 +4122,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{69} + return fileDescriptor_6960a02cc0a63cf6, []int{71} } func (m *TradingLimits) XXX_Unmarshal(b []byte) error { @@ -4074,7 +4184,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{70} + return fileDescriptor_6960a02cc0a63cf6, []int{72} } func (m *TradingLimitsRequest) XXX_Unmarshal(b []byte) error { @@ -4114,7 +4224,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{71} + return fileDescriptor_6960a02cc0a63cf6, []int{73} } func (m *TradingLimitsResponse) XXX_Unmarshal(b []byte) error { @@ -4156,7 +4266,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{72} + return fileDescriptor_6960a02cc0a63cf6, []int{74} } func (m *UnbanRequest) XXX_Unmarshal(b []byte) error { @@ -4201,7 +4311,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{73} + return fileDescriptor_6960a02cc0a63cf6, []int{75} } func (m *UnbanResponse) XXX_Unmarshal(b []byte) error { @@ -4235,7 +4345,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{74} + return fileDescriptor_6960a02cc0a63cf6, []int{76} } func (m *UnlockNodeRequest) XXX_Unmarshal(b []byte) error { @@ -4277,7 +4387,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{75} + return fileDescriptor_6960a02cc0a63cf6, []int{77} } func (m *UnlockNodeResponse) XXX_Unmarshal(b []byte) error { @@ -4333,7 +4443,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{76} + return fileDescriptor_6960a02cc0a63cf6, []int{78} } func (m *WithdrawRequest) XXX_Unmarshal(b []byte) error { @@ -4401,7 +4511,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{77} + return fileDescriptor_6960a02cc0a63cf6, []int{79} } func (m *WithdrawResponse) XXX_Unmarshal(b []byte) error { @@ -4432,6 +4542,7 @@ func (m *WithdrawResponse) GetTransactionId() string { 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.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") @@ -4497,6 +4608,8 @@ func init() { proto.RegisterType((*RestoreNodeRequest)(nil), "xudrpc.RestoreNodeRequest") proto.RegisterMapType((map[string][]byte)(nil), "xudrpc.RestoreNodeRequest.LndBackupsEntry") proto.RegisterType((*RestoreNodeResponse)(nil), "xudrpc.RestoreNodeResponse") + proto.RegisterType((*SetLogLevelRequest)(nil), "xudrpc.SetLogLevelRequest") + proto.RegisterType((*SetLogLevelResponse)(nil), "xudrpc.SetLogLevelResponse") proto.RegisterType((*ShutdownRequest)(nil), "xudrpc.ShutdownRequest") proto.RegisterType((*ShutdownResponse)(nil), "xudrpc.ShutdownResponse") proto.RegisterType((*SubscribeOrdersRequest)(nil), "xudrpc.SubscribeOrdersRequest") @@ -4523,253 +4636,261 @@ func init() { func init() { proto.RegisterFile("xudrpc.proto", fileDescriptor_6960a02cc0a63cf6) } var fileDescriptor_6960a02cc0a63cf6 = []byte{ - // 3923 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x4d, 0x93, 0x1c, 0x47, - 0x56, 0x53, 0xdd, 0xd3, 0xd3, 0x3d, 0xaf, 0x3f, 0x27, 0xe7, 0x43, 0xad, 0xb6, 0x6c, 0x6b, 0x13, - 0xcb, 0x21, 0xcb, 0xb6, 0x24, 0xc6, 0x18, 0xaf, 0x05, 0x72, 0x58, 0x33, 0x1a, 0x2c, 0xd9, 0xb3, - 0x92, 0xa2, 0x46, 0x5e, 0x89, 0x0d, 0xd8, 0x8a, 0xea, 0xaa, 0x94, 0xa6, 0x50, 0x4d, 0x56, 0xbb, - 0x3e, 0x34, 0x1a, 0xb8, 0x10, 0x1b, 0x9c, 0xe0, 0x06, 0xc1, 0x79, 0x39, 0x11, 0x44, 0xf0, 0x71, - 0xe5, 0x44, 0x04, 0x67, 0xae, 0x1c, 0x88, 0x00, 0x2e, 0x44, 0xf0, 0x0b, 0x08, 0xae, 0x44, 0x10, - 0xf9, 0x55, 0x99, 0x59, 0x55, 0x3d, 0x2b, 0x39, 0x60, 0x6f, 0x9d, 0x2f, 0x5f, 0xbe, 0x97, 0xf9, - 0xde, 0xcb, 0xf7, 0x95, 0xd5, 0x30, 0x78, 0x55, 0x84, 0xe9, 0x22, 0xb8, 0xbe, 0x48, 0x93, 0x3c, - 0x41, 0x6b, 0x62, 0x34, 0xdb, 0xf0, 0x29, 0x4d, 0x72, 0x3f, 0x8f, 0x12, 0x9a, 0x89, 0x29, 0xbc, - 0x0d, 0x9b, 0x77, 0xc2, 0x70, 0xbf, 0x48, 0x53, 0x42, 0x83, 0x33, 0x97, 0x64, 0x8b, 0x84, 0x66, - 0x04, 0xff, 0x14, 0x46, 0x77, 0xc2, 0xf0, 0x91, 0x1f, 0xa5, 0x2e, 0xf9, 0xae, 0x20, 0x59, 0x8e, - 0xde, 0x83, 0xe1, 0xdc, 0xcf, 0x88, 0x17, 0x48, 0xd4, 0xa9, 0x73, 0xd9, 0xb9, 0xba, 0xee, 0xda, - 0x40, 0xf4, 0x3e, 0x8c, 0xbe, 0x2b, 0x92, 0xdc, 0x40, 0x6b, 0x71, 0xb4, 0x0a, 0x14, 0x6f, 0xc0, - 0xb8, 0xa4, 0x2f, 0x59, 0xfe, 0x7d, 0x0b, 0xba, 0x7b, 0x7e, 0xec, 0xd3, 0x80, 0x30, 0x66, 0x79, - 0x92, 0xfb, 0xb1, 0x37, 0x17, 0x00, 0xce, 0x6c, 0xd5, 0xb5, 0x81, 0xe8, 0x2a, 0x8c, 0x83, 0x63, - 0x9f, 0x52, 0xa2, 0xf1, 0x5a, 0x1c, 0xaf, 0x0a, 0x46, 0x3f, 0x84, 0x0b, 0x0b, 0x42, 0xc3, 0x88, - 0x3e, 0xf7, 0xaa, 0x2b, 0xda, 0x7c, 0xc5, 0xb2, 0x69, 0x74, 0x0b, 0xa6, 0x11, 0xf5, 0x83, 0x3c, - 0x7a, 0x49, 0x6a, 0x4b, 0x57, 0xf9, 0xd2, 0xa5, 0xf3, 0x4c, 0x18, 0xa7, 0x7e, 0x1c, 0x93, 0xbc, - 0x5c, 0xd1, 0xe1, 0x2b, 0x2a, 0x50, 0xf4, 0x05, 0xcc, 0x0a, 0x1a, 0x24, 0xf4, 0x59, 0x94, 0x9e, - 0x90, 0xd0, 0xab, 0xac, 0x59, 0xe3, 0x6b, 0xce, 0xc1, 0xc0, 0xbf, 0x0e, 0xb0, 0xe7, 0x53, 0xa5, - 0xa8, 0xab, 0x30, 0xa6, 0x49, 0x48, 0xbc, 0x28, 0x24, 0x34, 0x8f, 0x9e, 0x45, 0x24, 0x95, 0xaa, - 0xaa, 0x82, 0xf1, 0x10, 0xfa, 0x7c, 0x9d, 0x54, 0xc0, 0x67, 0xd0, 0xd9, 0x3f, 0xf6, 0x23, 0x8a, - 0xb6, 0xa0, 0x13, 0xb0, 0x1f, 0x72, 0x9d, 0x18, 0xa0, 0x29, 0x74, 0x29, 0xc9, 0x4f, 0x93, 0xf4, - 0x85, 0xd4, 0xa9, 0x1a, 0xe2, 0x05, 0xf4, 0xf6, 0xc5, 0xd1, 0x33, 0xb4, 0x03, 0x6b, 0x42, 0x1a, - 0x7c, 0xf1, 0xd0, 0x95, 0x23, 0x34, 0x83, 0x9e, 0x92, 0x13, 0x5f, 0x3e, 0x74, 0xcb, 0x31, 0xa3, - 0x2c, 0xc5, 0xcf, 0xb5, 0x31, 0x74, 0xd5, 0x90, 0x51, 0x0b, 0xe2, 0x24, 0x23, 0x21, 0x97, 0xf5, - 0xd0, 0x95, 0x23, 0xfc, 0x0f, 0x0e, 0x6c, 0xee, 0xb3, 0x9f, 0x92, 0xef, 0x1b, 0x9f, 0x9d, 0xed, - 0xa7, 0x62, 0xa2, 0xe5, 0x98, 0x9d, 0xff, 0x59, 0x92, 0x4a, 0xdb, 0xe8, 0xb9, 0x62, 0x80, 0x2e, - 0x43, 0x3f, 0x24, 0x59, 0x1e, 0x51, 0x7e, 0x7f, 0xf8, 0x86, 0xd6, 0x5d, 0x13, 0xc4, 0xcf, 0x7e, - 0x92, 0x14, 0x34, 0x97, 0x7a, 0x96, 0x23, 0x34, 0x81, 0xf6, 0x33, 0xa2, 0x14, 0xc9, 0x7e, 0xe2, - 0x2f, 0x61, 0xcb, 0xde, 0xbe, 0x50, 0x01, 0xdb, 0x7f, 0x9e, 0xfa, 0x34, 0x63, 0x82, 0x49, 0xa8, - 0x17, 0x85, 0xd9, 0xd4, 0xb9, 0xdc, 0x66, 0xfb, 0xaf, 0x80, 0xf1, 0x47, 0x30, 0xda, 0x4f, 0x28, - 0x25, 0x41, 0xae, 0xce, 0x3e, 0x83, 0x1e, 0x3f, 0x64, 0x91, 0x46, 0xf2, 0xd0, 0xe5, 0x98, 0x5d, - 0xb7, 0x12, 0x5b, 0x6a, 0xfb, 0x06, 0x6c, 0xec, 0xa7, 0xc4, 0xcf, 0xc9, 0x83, 0x24, 0x24, 0x06, - 0x8d, 0x85, 0x9f, 0x65, 0xa7, 0x49, 0x1a, 0x2a, 0x1a, 0x6a, 0x8c, 0xff, 0xdc, 0x01, 0x64, 0xae, - 0x90, 0x5b, 0xfe, 0x15, 0x18, 0x66, 0x84, 0x84, 0xde, 0x09, 0x25, 0x27, 0x09, 0x8d, 0x02, 0xb9, - 0xe1, 0x01, 0x03, 0xfe, 0x48, 0xc2, 0xd0, 0x07, 0x30, 0x89, 0x68, 0x94, 0x47, 0x7e, 0x1c, 0xfd, - 0x3e, 0x09, 0xbd, 0x98, 0x86, 0xd9, 0xb4, 0x25, 0x0e, 0x66, 0xc0, 0x0f, 0x69, 0x98, 0xa1, 0x1b, - 0xb0, 0x69, 0xa2, 0x06, 0x6c, 0xdb, 0xaf, 0x72, 0xa9, 0x0a, 0x64, 0x4c, 0xed, 0x8b, 0x19, 0xfc, - 0x2f, 0x0e, 0xf4, 0x94, 0xff, 0xb2, 0xd4, 0xea, 0x54, 0xd4, 0x7a, 0x1b, 0xfa, 0xd9, 0xa9, 0xbf, - 0xf0, 0x82, 0x38, 0x22, 0x34, 0xe7, 0x5a, 0x1f, 0xed, 0xbe, 0x75, 0x5d, 0x7a, 0x4a, 0x45, 0xe2, - 0xfa, 0xd1, 0xa9, 0xbf, 0xd8, 0xe7, 0x28, 0xae, 0x89, 0x2f, 0x7c, 0xd2, 0x0b, 0x42, 0x3d, 0x3f, - 0x0c, 0x53, 0x92, 0x65, 0x7c, 0x4b, 0xeb, 0xae, 0x0d, 0x64, 0x77, 0x3e, 0x24, 0x41, 0x74, 0xe2, - 0xc7, 0xde, 0x22, 0xf6, 0x03, 0x92, 0x49, 0xcb, 0xad, 0x40, 0x31, 0x06, 0xd0, 0x8c, 0x50, 0x17, - 0xda, 0x87, 0x0f, 0xee, 0x4e, 0x56, 0x50, 0x1f, 0xba, 0xfb, 0x0f, 0x1f, 0x3c, 0x38, 0x78, 0xfa, - 0x78, 0xd2, 0x62, 0x3a, 0xbe, 0x4b, 0x16, 0x49, 0x16, 0x99, 0x3a, 0x5e, 0x76, 0x3c, 0xfc, 0x21, - 0x8c, 0x4b, 0x6c, 0xa9, 0x9b, 0x29, 0x74, 0xd5, 0x66, 0x05, 0xb6, 0x1a, 0x32, 0x03, 0xbc, 0x1b, - 0x65, 0x41, 0xf2, 0x92, 0xa4, 0x4c, 0x9b, 0xd9, 0x9b, 0x3b, 0x8f, 0x4f, 0x61, 0xbb, 0x42, 0x41, - 0x32, 0xbd, 0x04, 0xeb, 0xb4, 0x38, 0xf1, 0x18, 0x7e, 0x26, 0x9d, 0x80, 0x06, 0xe0, 0x3f, 0x76, - 0x00, 0x1d, 0xbc, 0x22, 0x41, 0x91, 0x13, 0x76, 0x7e, 0xe3, 0x60, 0x49, 0x1a, 0x92, 0xd4, 0x8b, - 0x4a, 0xc3, 0x53, 0x63, 0xee, 0x1e, 0xfc, 0x88, 0x4f, 0x49, 0xc7, 0x23, 0x87, 0x08, 0xc3, 0x60, - 0x41, 0x48, 0xea, 0x2d, 0x8a, 0xb9, 0xf7, 0x82, 0x9c, 0x49, 0x8d, 0x58, 0x30, 0x46, 0xf9, 0xbb, - 0xc2, 0xa7, 0x79, 0x94, 0x9f, 0x49, 0x87, 0x5d, 0x8e, 0xd9, 0x1d, 0xf8, 0x8a, 0xe4, 0x32, 0xe8, - 0xbc, 0x8e, 0x8c, 0xff, 0xca, 0x01, 0x64, 0xae, 0x90, 0x47, 0xbe, 0x0b, 0x3d, 0xe9, 0x8b, 0xc5, - 0x7d, 0xed, 0xef, 0x5e, 0x55, 0x66, 0x55, 0xc7, 0xbe, 0x2e, 0xc7, 0xd9, 0x01, 0xcd, 0xd3, 0x33, - 0xb7, 0x5c, 0x39, 0x3b, 0x84, 0xa1, 0x35, 0xc5, 0xfc, 0x06, 0x3b, 0x95, 0xd8, 0x04, 0xfb, 0x89, - 0xae, 0x40, 0xe7, 0xa5, 0x1f, 0x17, 0xc2, 0x85, 0xf6, 0x77, 0xc7, 0x8a, 0x8b, 0x62, 0x21, 0x66, - 0x6f, 0xb5, 0x7e, 0xe8, 0xe0, 0x09, 0x8c, 0xbe, 0x22, 0xf9, 0x7d, 0xfa, 0x2c, 0x91, 0x07, 0xc3, - 0xff, 0xda, 0x86, 0x71, 0x09, 0xd2, 0x16, 0xf2, 0x92, 0xa4, 0x19, 0x73, 0x68, 0xd2, 0x42, 0xe4, - 0x90, 0xc9, 0x96, 0xab, 0x5c, 0xc9, 0x56, 0x88, 0xde, 0x82, 0x21, 0x04, 0xab, 0x45, 0x1a, 0xb1, - 0x9b, 0xc0, 0xae, 0x32, 0xff, 0xad, 0xd4, 0xcf, 0x74, 0xa0, 0x6c, 0x5f, 0x03, 0xca, 0x59, 0x3f, - 0x4a, 0x33, 0xee, 0x25, 0xd5, 0x2c, 0x03, 0xa0, 0x0f, 0x61, 0x8d, 0x6b, 0x3d, 0xe3, 0xbe, 0xb2, - 0xbf, 0xbb, 0xa9, 0xce, 0xf7, 0x90, 0x43, 0xf7, 0x99, 0x37, 0x75, 0x25, 0x0a, 0xda, 0x85, 0x76, - 0x4c, 0xc3, 0x69, 0x97, 0xcb, 0xfb, 0xb2, 0x21, 0x6f, 0xf3, 0x80, 0xd7, 0x0f, 0x69, 0x28, 0xe4, - 0xcc, 0x90, 0x99, 0x67, 0xf7, 0xe3, 0xc8, 0xcf, 0xa6, 0xeb, 0x22, 0xb2, 0xf1, 0x81, 0x19, 0xd9, - 0xc0, 0x8a, 0x6c, 0xe8, 0x26, 0x6c, 0xaa, 0xc4, 0x80, 0xbb, 0x82, 0x63, 0x3f, 0x3b, 0x26, 0xd9, - 0xb4, 0xcf, 0xcf, 0xdb, 0x34, 0x85, 0x3e, 0x86, 0xae, 0x72, 0x59, 0x03, 0xfb, 0x0c, 0xd2, 0x5f, - 0xf1, 0xdd, 0x29, 0x9c, 0xd9, 0x57, 0xd0, 0x53, 0x3b, 0x7c, 0x03, 0x75, 0x1f, 0xd2, 0x90, 0x93, - 0x31, 0xd4, 0xfd, 0x05, 0x37, 0x4c, 0x76, 0x13, 0x0d, 0x95, 0xbf, 0xc1, 0x75, 0x76, 0x61, 0xd3, - 0x5a, 0x5f, 0x7a, 0xf7, 0x71, 0x4a, 0x16, 0x85, 0xc8, 0x19, 0x8f, 0x82, 0x24, 0x15, 0x71, 0x7d, - 0xc3, 0x05, 0x0d, 0x66, 0x71, 0x6f, 0xce, 0xe2, 0x98, 0xb8, 0x9f, 0x3d, 0x57, 0x8e, 0xf0, 0x05, - 0xd8, 0x3e, 0x8c, 0xb2, 0x5c, 0x7a, 0xd6, 0xa8, 0xf4, 0x32, 0xf8, 0x6b, 0xd8, 0xa9, 0x4e, 0x48, - 0x7e, 0x37, 0x01, 0x82, 0x12, 0x2a, 0xef, 0xd2, 0xa4, 0xea, 0xa2, 0x5d, 0x03, 0x07, 0xff, 0x93, - 0x03, 0x1b, 0x8c, 0x98, 0x30, 0x11, 0x75, 0x70, 0xc3, 0x67, 0x38, 0xb6, 0xcf, 0xf8, 0x14, 0x3a, - 0xc9, 0x29, 0x25, 0xa9, 0xf4, 0xff, 0xef, 0x96, 0x32, 0xad, 0xd2, 0xb8, 0xfe, 0x90, 0xa1, 0xb9, - 0x02, 0x9b, 0x59, 0x4e, 0x1c, 0x9d, 0x44, 0xb9, 0xcc, 0x50, 0xc4, 0x80, 0xc9, 0x37, 0xa2, 0x41, - 0x5c, 0x84, 0xc4, 0xe3, 0xa6, 0x24, 0xdd, 0x7d, 0xcf, 0xad, 0x82, 0xf1, 0x7b, 0xd0, 0xe1, 0xf4, - 0x50, 0x0f, 0x56, 0xf7, 0x1e, 0x3e, 0xbe, 0x37, 0x59, 0x61, 0x4e, 0xff, 0xe1, 0x93, 0x07, 0x13, - 0x87, 0x81, 0x1e, 0x1d, 0x1c, 0xb8, 0x93, 0x16, 0xfe, 0xb9, 0x03, 0xc8, 0xdc, 0x88, 0x94, 0xca, - 0x17, 0xe5, 0xbd, 0x10, 0x12, 0x79, 0xbf, 0x69, 0xd3, 0xd2, 0xe0, 0xc5, 0x50, 0xd8, 0xbc, 0x5c, - 0x35, 0xbb, 0x0f, 0x7d, 0x03, 0xdc, 0x60, 0x68, 0xef, 0xd9, 0x86, 0x36, 0xb2, 0xef, 0x9d, 0x69, - 0x67, 0x08, 0x26, 0x8c, 0x29, 0xcb, 0xdc, 0x4b, 0x75, 0x7e, 0x20, 0x34, 0x20, 0x61, 0x72, 0xcf, - 0x5b, 0xd0, 0x11, 0xb7, 0x5c, 0xe4, 0x03, 0x62, 0x50, 0x2e, 0x27, 0x5a, 0xce, 0xf8, 0x33, 0xb9, - 0x9c, 0x98, 0x47, 0xc6, 0xd0, 0x11, 0x2e, 0x44, 0x9c, 0x78, 0xa0, 0x76, 0xc4, 0xb0, 0x5c, 0x31, - 0x85, 0xff, 0xdd, 0x81, 0xae, 0xbc, 0x0a, 0xcc, 0x06, 0xb3, 0xdc, 0xcf, 0x0b, 0x15, 0xe9, 0xe4, - 0x08, 0x7d, 0x04, 0x3d, 0x99, 0x96, 0x67, 0xf2, 0x70, 0xda, 0x9c, 0x24, 0xdc, 0x2d, 0x31, 0xd0, - 0x15, 0x58, 0xe3, 0xc9, 0xae, 0x70, 0x69, 0xfd, 0xdd, 0xa1, 0x81, 0x1b, 0x51, 0x57, 0x4e, 0xb2, - 0x54, 0x70, 0x1e, 0x27, 0xc1, 0x8b, 0x63, 0x12, 0x3d, 0x3f, 0xce, 0xa5, 0x97, 0x33, 0x41, 0xa5, - 0x67, 0xec, 0x18, 0x9e, 0xd1, 0xf0, 0xb5, 0x6b, 0xb6, 0xaf, 0x2d, 0xdd, 0x52, 0xd7, 0x70, 0x4b, - 0xf8, 0x6b, 0x18, 0xf1, 0xfb, 0xa8, 0x93, 0xd6, 0xaa, 0x4f, 0x76, 0x1a, 0x7c, 0x72, 0x49, 0xab, - 0x65, 0xd2, 0xfa, 0x4b, 0x07, 0xd0, 0xc3, 0x05, 0xa1, 0xff, 0x2f, 0xf9, 0xb2, 0xce, 0x7b, 0xdb, - 0x56, 0xde, 0x7b, 0x19, 0xfa, 0x8b, 0x22, 0x3b, 0xf6, 0xe4, 0xa4, 0x88, 0xbe, 0x26, 0x48, 0x65, - 0xc6, 0x1d, 0x9d, 0x19, 0xdf, 0x86, 0x4d, 0x6b, 0x9f, 0xd2, 0x1c, 0xde, 0x87, 0x91, 0x9d, 0x01, - 0xcb, 0x7d, 0x56, 0xa0, 0xf8, 0x1f, 0x5b, 0xd0, 0xe1, 0x46, 0xcb, 0xed, 0x2f, 0x8d, 0x64, 0xe9, - 0xe8, 0xb8, 0x62, 0x60, 0x65, 0x03, 0x2d, 0x3b, 0x1b, 0x30, 0x7d, 0x46, 0xdb, 0xf6, 0x19, 0x23, - 0x68, 0x45, 0xa1, 0xcc, 0xf8, 0x5b, 0x51, 0x88, 0xbe, 0xac, 0x8b, 0xad, 0xc3, 0x6d, 0x6b, 0x47, - 0xd9, 0x8b, 0xad, 0xb8, 0x46, 0x71, 0xc6, 0x49, 0xe0, 0xc7, 0x8c, 0x99, 0x30, 0x86, 0x72, 0x8c, - 0xde, 0x01, 0x08, 0x78, 0x9e, 0x1d, 0x7a, 0x7e, 0xce, 0x4d, 0x62, 0xd5, 0x35, 0x20, 0xe8, 0x0a, - 0xac, 0x66, 0x51, 0x48, 0xa6, 0x3d, 0xee, 0xc0, 0x36, 0xac, 0xbb, 0x7a, 0x14, 0x85, 0xc4, 0xe5, - 0xd3, 0xcc, 0x58, 0xa2, 0xcc, 0x4b, 0x4e, 0xa9, 0xc7, 0xbd, 0x00, 0x0f, 0x79, 0x3d, 0xd7, 0x82, - 0x31, 0x33, 0x3d, 0x4e, 0xe2, 0x90, 0x87, 0xbd, 0x55, 0x97, 0xff, 0xc6, 0x7f, 0xe1, 0xc0, 0x80, - 0xd3, 0x72, 0xc9, 0x49, 0xf2, 0xd2, 0x8f, 0x2d, 0x99, 0x39, 0xcb, 0x65, 0x56, 0xc9, 0xcd, 0xcc, - 0x8c, 0xae, 0x5d, 0xc9, 0xe8, 0xcc, 0xd3, 0xaf, 0x56, 0x4e, 0x5f, 0xdd, 0x76, 0xa7, 0xbe, 0x6d, - 0x7c, 0x0c, 0x6b, 0xc2, 0x33, 0xa1, 0x8f, 0x01, 0xe6, 0xc5, 0x99, 0x67, 0x79, 0xc7, 0xa1, 0x25, - 0x11, 0xd7, 0x40, 0x40, 0x37, 0xa0, 0x9f, 0x91, 0x38, 0x56, 0xf8, 0xad, 0x26, 0x7c, 0x13, 0x03, - 0x7f, 0xa2, 0x3c, 0x27, 0xcf, 0x3d, 0x98, 0xbc, 0x98, 0xeb, 0x91, 0x69, 0x2d, 0xff, 0xcd, 0x6c, - 0x38, 0x39, 0xa5, 0xb2, 0xa8, 0x65, 0x3f, 0xf1, 0xcf, 0x1c, 0xb9, 0xea, 0xdb, 0x45, 0xe8, 0xe7, - 0x84, 0x85, 0x71, 0x71, 0x16, 0x87, 0x1b, 0x89, 0xcd, 0xef, 0xde, 0x8a, 0x2b, 0x66, 0xd1, 0x6f, - 0xc2, 0x50, 0x48, 0x28, 0x15, 0x82, 0x97, 0xfe, 0x6a, 0xcb, 0xde, 0x9e, 0x98, 0xbb, 0xb7, 0xe2, - 0xda, 0xc8, 0x7b, 0x23, 0x18, 0x08, 0x40, 0xc1, 0x99, 0xe2, 0x7f, 0x6b, 0xc1, 0x2a, 0x73, 0x96, - 0xcb, 0x8b, 0x80, 0xd7, 0x4a, 0xf1, 0xbe, 0x84, 0x41, 0x4c, 0x43, 0x35, 0x54, 0x7e, 0xf1, 0x92, - 0xe9, 0x8e, 0x59, 0x3a, 0xf2, 0xa8, 0x98, 0x7f, 0x43, 0xce, 0x64, 0xd8, 0xb1, 0x56, 0x30, 0xfe, - 0x11, 0x9d, 0x27, 0x05, 0x0d, 0x65, 0x6c, 0x54, 0x43, 0x1d, 0x22, 0x3a, 0x46, 0x88, 0x60, 0x5e, - 0xe3, 0x55, 0x11, 0x7a, 0xb6, 0xab, 0x34, 0x41, 0xe8, 0x23, 0xd8, 0xc8, 0x48, 0x90, 0xd0, 0x30, - 0x13, 0xe5, 0x61, 0x90, 0x93, 0x90, 0xdf, 0x93, 0xa1, 0x5b, 0x9f, 0x68, 0xce, 0xf9, 0x66, 0xb7, - 0x61, 0x5c, 0xd9, 0x76, 0x43, 0x58, 0xdc, 0x32, 0xc3, 0xe2, 0xba, 0x19, 0x06, 0xff, 0xb4, 0x05, - 0x1b, 0x8f, 0x58, 0x25, 0x27, 0x95, 0x22, 0xdc, 0xe9, 0xff, 0xa5, 0xcf, 0x31, 0xef, 0xcf, 0x6a, - 0xe5, 0xfe, 0x28, 0x0f, 0xd0, 0x39, 0xdf, 0x03, 0x5c, 0x83, 0x49, 0x4a, 0x78, 0xbd, 0xe9, 0x95, - 0xa4, 0x84, 0x38, 0x6b, 0x70, 0x96, 0xe9, 0x46, 0x27, 0x27, 0x24, 0x8c, 0xfc, 0x9c, 0x41, 0xbd, - 0x80, 0xd5, 0x13, 0x31, 0x97, 0x6a, 0xcf, 0x6d, 0x9a, 0x62, 0xe2, 0x3a, 0xf1, 0x5f, 0x71, 0x2f, - 0xd4, 0x73, 0xd9, 0x4f, 0xfc, 0x87, 0x2d, 0x40, 0xa6, 0x50, 0xa4, 0xef, 0xfe, 0x9c, 0x15, 0xff, - 0x39, 0x49, 0xa9, 0x1f, 0x7b, 0x27, 0x7e, 0x1e, 0x1c, 0x93, 0x25, 0x37, 0xb5, 0x86, 0x86, 0x7e, - 0x03, 0x46, 0x3c, 0xb9, 0xce, 0x8a, 0x20, 0x20, 0x19, 0x4b, 0xaf, 0xc4, 0x95, 0x2d, 0x93, 0x6a, - 0x56, 0x43, 0x1e, 0x89, 0x49, 0xb7, 0x82, 0x8a, 0x3e, 0x63, 0xb9, 0xeb, 0x89, 0x1f, 0x51, 0x96, - 0xa3, 0x8b, 0x0b, 0xd8, 0x6e, 0xb8, 0x80, 0x6e, 0x15, 0x0b, 0x7d, 0x0e, 0x43, 0x4e, 0xea, 0x99, - 0x1f, 0xc5, 0x45, 0xca, 0x73, 0xba, 0x1a, 0xd3, 0xdf, 0x12, 0x73, 0xae, 0x8d, 0x89, 0xff, 0xcb, - 0x81, 0xb1, 0x16, 0xc1, 0xc1, 0x4b, 0x56, 0xdc, 0x5f, 0x81, 0x0e, 0x3f, 0xcf, 0xd2, 0xeb, 0xcf, - 0x67, 0xd1, 0xe7, 0x30, 0x30, 0x0f, 0x20, 0x6f, 0x7f, 0xd3, 0x49, 0xef, 0xad, 0xb8, 0x16, 0x2a, - 0xfa, 0xfc, 0xf5, 0x4e, 0x7a, 0x6f, 0xa5, 0xe9, 0xac, 0x03, 0xf3, 0x04, 0xdc, 0xd4, 0x9a, 0x8f, - 0x5a, 0x72, 0x95, 0xa8, 0x7b, 0x5d, 0xe8, 0x10, 0x76, 0x40, 0x9c, 0x40, 0xdf, 0x28, 0x6e, 0x96, - 0xa6, 0x62, 0x86, 0x23, 0x6a, 0xd9, 0x8e, 0xc8, 0xc8, 0x8c, 0x56, 0x6b, 0x99, 0x91, 0x68, 0x45, - 0x76, 0x8c, 0x56, 0x24, 0xfe, 0x04, 0xb6, 0xb9, 0x1f, 0x24, 0xba, 0x6f, 0xfd, 0x8b, 0x6b, 0xf7, - 0x29, 0xec, 0x54, 0x17, 0xc9, 0x56, 0xd8, 0x21, 0x20, 0x31, 0x63, 0x5d, 0xe6, 0xf3, 0x5a, 0x12, - 0xe7, 0x5c, 0x69, 0xfc, 0x29, 0x6c, 0x5a, 0xd4, 0xe4, 0x2d, 0x78, 0x07, 0x26, 0x0a, 0xc5, 0x4b, - 0xa8, 0xc7, 0xc3, 0xae, 0x63, 0x84, 0xdd, 0x72, 0x7b, 0x77, 0xe2, 0xd8, 0xaa, 0x43, 0x70, 0x01, - 0x17, 0x6a, 0x33, 0x92, 0xe8, 0x47, 0xb0, 0xc1, 0xfd, 0x3f, 0x09, 0xcb, 0x9b, 0xac, 0x12, 0xee, - 0xfa, 0x04, 0xc3, 0x96, 0x9c, 0x0d, 0x6c, 0xd1, 0x86, 0xab, 0x4f, 0xe0, 0x8f, 0x61, 0x43, 0xb0, - 0x35, 0x5f, 0x01, 0x96, 0xd6, 0x55, 0x78, 0x4b, 0x09, 0xd1, 0x6a, 0xea, 0xff, 0x51, 0x8b, 0x81, - 0xb3, 0x3c, 0x49, 0xad, 0x3e, 0xe3, 0x6b, 0x35, 0x0d, 0xcd, 0x66, 0x64, 0xcb, 0x6e, 0x46, 0xa2, - 0x6f, 0xa0, 0xcf, 0x82, 0xcc, 0xdc, 0x0f, 0x5e, 0x14, 0x0b, 0x15, 0x95, 0xae, 0x29, 0xab, 0xad, - 0x73, 0x64, 0x31, 0x6a, 0x4f, 0x20, 0x8b, 0x18, 0x05, 0x71, 0x09, 0x40, 0x3f, 0xe0, 0xcf, 0x25, - 0x5e, 0xe8, 0xe7, 0xfe, 0xdc, 0xcf, 0x44, 0xa3, 0x76, 0xc0, 0x43, 0xce, 0x5d, 0x09, 0x92, 0xe1, - 0xc2, 0xa4, 0xf0, 0x8b, 0xc2, 0xc5, 0xc0, 0x0c, 0x17, 0x84, 0xd9, 0x84, 0xb1, 0x27, 0xdd, 0x3b, - 0x4d, 0x05, 0x58, 0xf6, 0x44, 0xa5, 0x18, 0x14, 0x90, 0x37, 0x44, 0x3f, 0x60, 0x5e, 0x5c, 0x22, - 0xa9, 0xd6, 0x82, 0xa8, 0xb3, 0xc7, 0x0a, 0xae, 0x5a, 0xa1, 0x1b, 0x30, 0x3e, 0x3a, 0x2e, 0xf2, - 0x30, 0x39, 0x55, 0xaf, 0x01, 0xac, 0xe0, 0xd2, 0x20, 0xa9, 0x94, 0x5f, 0x83, 0x9d, 0xa3, 0x62, - 0x9e, 0x05, 0x69, 0x34, 0x27, 0x76, 0xd9, 0x3c, 0x83, 0x1e, 0x79, 0x15, 0x65, 0x79, 0x44, 0x9f, - 0xf3, 0x83, 0xf5, 0xdc, 0x72, 0x8c, 0xdf, 0x85, 0xb7, 0xcb, 0x55, 0xcc, 0x2d, 0x64, 0x77, 0x82, - 0x80, 0x2c, 0x72, 0x12, 0x2a, 0x56, 0xb7, 0x61, 0xdb, 0x46, 0x30, 0x9e, 0x8e, 0x54, 0x39, 0x9c, - 0xfb, 0x2f, 0x64, 0x1e, 0xd4, 0x73, 0x6d, 0x20, 0xfe, 0x9f, 0x16, 0x0c, 0xd8, 0x32, 0x45, 0x16, - 0x5d, 0xac, 0x5d, 0xc0, 0x2e, 0x1f, 0xdf, 0xb7, 0x13, 0xc8, 0x56, 0x25, 0x81, 0x3c, 0x37, 0xa4, - 0x2e, 0x6b, 0x05, 0xea, 0xd0, 0xdd, 0x31, 0x43, 0x77, 0xb5, 0xc1, 0xb8, 0xd6, 0xd0, 0x60, 0xdc, - 0x81, 0xb5, 0x94, 0x77, 0x7f, 0x64, 0xf5, 0x26, 0x47, 0x2c, 0xfa, 0x8a, 0x2a, 0xc7, 0x4b, 0x49, - 0x40, 0xa2, 0x97, 0x4c, 0xa6, 0x3d, 0xce, 0xb5, 0x06, 0x67, 0xe5, 0x8d, 0x84, 0x65, 0xf2, 0x21, - 0x64, 0x5d, 0xbc, 0x14, 0xd9, 0x50, 0x74, 0x1d, 0x90, 0xf2, 0x67, 0x06, 0x55, 0xd1, 0xb4, 0x6a, - 0x98, 0x61, 0x7b, 0x28, 0xa1, 0x8a, 0x72, 0x5f, 0x64, 0x00, 0x55, 0x38, 0xfe, 0x6b, 0x07, 0xfa, - 0x86, 0xbb, 0xff, 0x9e, 0x2d, 0x59, 0x53, 0xc6, 0xed, 0x8a, 0x8c, 0xab, 0xd2, 0x5c, 0x6d, 0x90, - 0xe6, 0xfb, 0x30, 0x92, 0xf1, 0xc5, 0x4b, 0x89, 0x9f, 0x25, 0xca, 0xf3, 0x57, 0xa0, 0xf8, 0xef, - 0xda, 0x62, 0xb7, 0x32, 0x24, 0xfe, 0x72, 0x8d, 0x45, 0xab, 0xbc, 0x63, 0xa9, 0xfc, 0x2a, 0x8c, - 0x2d, 0xd5, 0x92, 0x50, 0x6a, 0xbc, 0x0a, 0x66, 0x49, 0xae, 0x56, 0x6d, 0x2e, 0xb5, 0x6d, 0x82, - 0x6a, 0xc2, 0x82, 0x06, 0x61, 0x5d, 0x86, 0xd5, 0x34, 0x89, 0x09, 0x57, 0xe9, 0x48, 0xf7, 0x48, - 0xdc, 0x24, 0x26, 0x2e, 0x9f, 0x61, 0x2e, 0xbf, 0x62, 0x16, 0x24, 0xe4, 0x8d, 0xc9, 0x75, 0xb7, - 0x3e, 0xc1, 0x2e, 0xaa, 0x69, 0x16, 0xf9, 0x74, 0x28, 0x9e, 0x38, 0x2c, 0x20, 0xab, 0x4f, 0x53, - 0x6f, 0x91, 0x92, 0xe8, 0xc4, 0x7f, 0x4e, 0xa6, 0x23, 0x8e, 0x62, 0x40, 0xf4, 0x55, 0x1a, 0x1b, - 0x57, 0x09, 0xff, 0x77, 0x0b, 0x3a, 0x8f, 0x53, 0x3f, 0x24, 0xac, 0x08, 0x3b, 0x61, 0x37, 0xde, - 0x5b, 0x5e, 0x14, 0xb9, 0x26, 0x06, 0x5b, 0x90, 0x1b, 0x0b, 0x5a, 0x8d, 0x0b, 0x0c, 0x0c, 0x43, - 0x3f, 0x6d, 0x4b, 0x3f, 0xe7, 0xe9, 0xd4, 0xb0, 0x84, 0x8e, 0x6d, 0x09, 0xe5, 0x79, 0xd6, 0x4c, - 0xd7, 0xa0, 0x64, 0xdf, 0x5d, 0x2a, 0xfb, 0xcb, 0xd0, 0x27, 0xe2, 0xa5, 0x83, 0x17, 0xf2, 0xc2, - 0x12, 0x4c, 0x50, 0x99, 0xc7, 0xaf, 0x9f, 0x9f, 0xc7, 0xdf, 0x82, 0x41, 0xc0, 0x0c, 0x83, 0xa4, - 0x0b, 0x3f, 0xcd, 0x85, 0x29, 0x2c, 0xef, 0x35, 0x58, 0xb8, 0xf8, 0x43, 0xd8, 0xe4, 0x52, 0xbf, - 0x17, 0xb1, 0x50, 0x71, 0x66, 0x54, 0x2a, 0xa2, 0x9d, 0xe9, 0x18, 0xed, 0x4c, 0x7c, 0x1b, 0xb6, - 0x6c, 0x64, 0x19, 0xa7, 0xae, 0xc0, 0x5a, 0xce, 0xe0, 0xb5, 0xbc, 0x9d, 0x63, 0xbb, 0x72, 0x12, - 0xff, 0xdc, 0x81, 0x21, 0x83, 0x44, 0xf4, 0xf9, 0x21, 0xa3, 0x97, 0x31, 0x81, 0x9f, 0xf8, 0xaf, - 0x3c, 0x56, 0x51, 0xab, 0xd6, 0x81, 0x1a, 0x33, 0x81, 0xb3, 0xdf, 0xf3, 0x42, 0xa5, 0x50, 0x6a, - 0x28, 0xb2, 0x9a, 0x8c, 0xa4, 0x3c, 0x7b, 0x29, 0x72, 0x51, 0x3b, 0x0a, 0x67, 0x52, 0x9f, 0x10, - 0x55, 0x8e, 0x04, 0x9a, 0x85, 0xe6, 0xaa, 0x5b, 0x83, 0xe3, 0x5d, 0x71, 0xc0, 0x72, 0x83, 0xaf, - 0x93, 0x37, 0xfe, 0x8d, 0x03, 0xdb, 0x95, 0x45, 0x52, 0x2c, 0x77, 0x60, 0x8d, 0xcb, 0x4d, 0x89, - 0xe5, 0x03, 0x53, 0x2c, 0x35, 0xf4, 0xeb, 0x62, 0x28, 0x3b, 0xb3, 0x62, 0xe1, 0xec, 0x11, 0xf4, - 0x0d, 0x70, 0x43, 0x4e, 0xf1, 0xa1, 0xdd, 0x99, 0xdd, 0x6e, 0x66, 0x61, 0xa4, 0x1a, 0x3f, 0x86, - 0xc1, 0xb7, 0x74, 0xfe, 0x3d, 0x3e, 0x07, 0x40, 0x97, 0x60, 0x3d, 0x25, 0xb2, 0x6e, 0x96, 0x19, - 0x86, 0x06, 0xe0, 0x31, 0x0c, 0x25, 0x5d, 0xfd, 0x80, 0xfc, 0x2d, 0x8d, 0x93, 0xe0, 0xc5, 0xeb, - 0x3e, 0x20, 0xff, 0x04, 0x90, 0xb9, 0x40, 0xe7, 0x40, 0x05, 0x87, 0x56, 0x72, 0x20, 0x05, 0xe4, - 0x39, 0xd0, 0xbb, 0xd0, 0x37, 0x51, 0xc4, 0x7b, 0x13, 0x68, 0x04, 0xfc, 0x27, 0x0e, 0x8c, 0x9f, - 0x44, 0xf9, 0x71, 0x98, 0xfa, 0xa7, 0xaf, 0xa1, 0xd4, 0xea, 0x63, 0x7e, 0xeb, 0xbc, 0xc7, 0xfc, - 0x76, 0xf5, 0x31, 0xdf, 0x8f, 0x63, 0xd9, 0xca, 0x60, 0x3f, 0xcd, 0x26, 0xe6, 0x50, 0x34, 0x31, - 0x6f, 0xc1, 0x44, 0x6f, 0xe6, 0xcd, 0x3a, 0x98, 0xd7, 0xae, 0xc2, 0x7a, 0x79, 0xff, 0x51, 0x17, - 0xda, 0x7b, 0xdf, 0xfe, 0xf6, 0x64, 0x05, 0xf5, 0x60, 0xf5, 0xe8, 0xe0, 0xf0, 0x50, 0x3c, 0x16, - 0xf0, 0xf7, 0x83, 0xd6, 0xb5, 0x6b, 0xb0, 0xca, 0xbc, 0x0d, 0x5a, 0x87, 0xce, 0xe3, 0x3b, 0xdf, - 0x1c, 0xb8, 0x93, 0x15, 0xf6, 0xf3, 0x47, 0xfc, 0xa7, 0x83, 0x06, 0xd0, 0xbb, 0xff, 0xe0, 0xf1, - 0x81, 0xfb, 0xe0, 0xce, 0xe1, 0xa4, 0xb5, 0xfb, 0x1f, 0x0e, 0x74, 0x9f, 0x16, 0xe1, 0x7d, 0x1a, - 0xe5, 0xe8, 0x00, 0x40, 0xbf, 0xe3, 0xa3, 0x8b, 0x65, 0x8b, 0xbb, 0xfa, 0x35, 0xc0, 0x6c, 0xd6, - 0x34, 0x25, 0xb5, 0xbf, 0x82, 0xee, 0x41, 0xdf, 0xc8, 0x69, 0xd1, 0x6c, 0x79, 0xf2, 0x3d, 0x7b, - 0xab, 0x71, 0xae, 0xa4, 0x74, 0x00, 0xa0, 0x0d, 0x43, 0x6f, 0xa8, 0x66, 0x5d, 0x7a, 0x43, 0x75, - 0x3b, 0xc2, 0x2b, 0xbb, 0x7f, 0x7b, 0x01, 0xda, 0x4f, 0x8b, 0x10, 0x3d, 0x85, 0xbe, 0xf1, 0x49, - 0x13, 0xaa, 0x3d, 0x1f, 0xe9, 0xed, 0x34, 0x7d, 0xf9, 0x34, 0xfb, 0xd9, 0x3f, 0xff, 0xe7, 0x9f, - 0xb5, 0xb6, 0xf0, 0xf8, 0xc6, 0xcb, 0x5f, 0xbd, 0xe1, 0x87, 0xa1, 0x32, 0x99, 0x5b, 0xce, 0x35, - 0xe4, 0x42, 0x57, 0x7e, 0xb5, 0x84, 0x76, 0x0c, 0x1a, 0x46, 0x81, 0x34, 0xbb, 0x50, 0x83, 0x4b, - 0xba, 0x3b, 0x9c, 0xee, 0x04, 0xf7, 0x25, 0x5d, 0x16, 0x5d, 0x18, 0xcd, 0x3d, 0x68, 0xef, 0xf9, - 0x14, 0x21, 0xfd, 0x94, 0xab, 0xae, 0xee, 0x6c, 0xd3, 0x82, 0x49, 0x3a, 0x88, 0xd3, 0x19, 0xe0, - 0x2e, 0xa3, 0x33, 0xf7, 0x29, 0xa3, 0x11, 0xc0, 0xc0, 0xfc, 0x9c, 0x04, 0xe9, 0x8f, 0x1a, 0xea, - 0xdf, 0xc8, 0xcc, 0x2e, 0x35, 0x4f, 0x4a, 0xf2, 0x53, 0x4e, 0x1e, 0xe1, 0x09, 0x23, 0xcf, 0xbf, - 0xb6, 0x91, 0x8f, 0x23, 0xec, 0xf0, 0xf2, 0x1b, 0x12, 0x7d, 0x78, 0xfb, 0x13, 0x14, 0x7d, 0xf8, - 0xea, 0xc7, 0x26, 0xd6, 0xe1, 0xa5, 0x47, 0x61, 0x1b, 0xff, 0x29, 0x0c, 0x9f, 0xf0, 0x6f, 0x99, - 0xe4, 0x97, 0x0b, 0x9a, 0xb2, 0xfd, 0xe1, 0x83, 0xa6, 0x5c, 0xf9, 0xc4, 0x01, 0x5f, 0xe2, 0x94, - 0x77, 0xf0, 0x06, 0xa3, 0x2c, 0xbe, 0x8b, 0x0a, 0x05, 0x0a, 0xa3, 0xff, 0x7b, 0x30, 0xb4, 0x3e, - 0x52, 0x40, 0xe5, 0xe1, 0x9b, 0xbe, 0x7e, 0x98, 0xbd, 0xbd, 0x64, 0xb6, 0x89, 0x57, 0x28, 0x51, - 0xf8, 0x67, 0x0d, 0x8c, 0xd7, 0x53, 0x00, 0xfd, 0xd8, 0xaf, 0xad, 0xb8, 0xf6, 0x81, 0x81, 0xb6, - 0xe2, 0xfa, 0xb7, 0x01, 0x78, 0x93, 0xb3, 0x18, 0xa2, 0xbe, 0xd0, 0xae, 0xa0, 0x75, 0x08, 0x5d, - 0xf9, 0xac, 0xad, 0xe5, 0x63, 0xbf, 0xed, 0x6b, 0xf9, 0x54, 0xde, 0xbf, 0xf1, 0x84, 0x13, 0x04, - 0xd4, 0x63, 0x04, 0x23, 0x46, 0xe2, 0x77, 0xa0, 0x6f, 0xbc, 0xf4, 0x22, 0x73, 0x37, 0x95, 0xe7, - 0x63, 0x7d, 0x51, 0x1a, 0x9e, 0x86, 0xf1, 0x16, 0xa7, 0x3c, 0x42, 0x03, 0x46, 0x99, 0x49, 0x81, - 0x53, 0x7f, 0x02, 0xa0, 0x1f, 0x25, 0xb5, 0x14, 0x6a, 0xaf, 0xab, 0x5a, 0x0a, 0xf5, 0x37, 0x4c, - 0x65, 0xe3, 0x08, 0x18, 0x69, 0xd9, 0xba, 0x7f, 0x0e, 0x23, 0xfb, 0xcd, 0x18, 0xbd, 0x6d, 0x52, - 0xa8, 0x3d, 0x32, 0xcf, 0xde, 0x59, 0x36, 0x6d, 0xdb, 0x24, 0x1a, 0x71, 0x9b, 0xd4, 0x64, 0x8f, - 0x60, 0xbd, 0x7c, 0xcd, 0x44, 0x53, 0x93, 0x88, 0xf9, 0xe8, 0x39, 0xbb, 0xd8, 0x30, 0x23, 0x29, - 0x6f, 0x70, 0xca, 0x7d, 0xb4, 0xce, 0x28, 0x8b, 0xa6, 0xb6, 0x22, 0xca, 0x3f, 0x82, 0xb0, 0x89, - 0x1a, 0x4f, 0xa1, 0x15, 0xa2, 0xe6, 0x83, 0x68, 0x85, 0x28, 0xa7, 0xe3, 0x41, 0xdf, 0x78, 0x2b, - 0xd3, 0x9a, 0xac, 0x3f, 0xf4, 0x69, 0x4d, 0x36, 0x3c, 0xae, 0xe1, 0x0b, 0x9c, 0xf4, 0x86, 0x70, - 0x79, 0xc9, 0x82, 0x50, 0x75, 0xe5, 0x7f, 0x17, 0x40, 0x37, 0x33, 0xb5, 0x32, 0x6b, 0x8d, 0x6f, - 0x6d, 0x7e, 0x95, 0xde, 0x27, 0xbe, 0xc8, 0x49, 0x6f, 0x62, 0x2e, 0x64, 0xde, 0x72, 0xe6, 0xea, - 0xbc, 0xe5, 0x5c, 0xbb, 0xe9, 0xa0, 0x67, 0x30, 0xd2, 0xf8, 0x47, 0x67, 0x34, 0x38, 0x8f, 0xc5, - 0xac, 0x69, 0x4a, 0x1e, 0xe0, 0x6d, 0xce, 0xe5, 0x02, 0x46, 0x36, 0x97, 0xec, 0x8c, 0x06, 0xec, - 0x66, 0xfe, 0x04, 0xfa, 0xc6, 0x27, 0x47, 0x5a, 0x4e, 0xf5, 0xef, 0x90, 0x66, 0x4d, 0xed, 0x56, - 0x3b, 0x24, 0xc8, 0xfc, 0x3d, 0x3b, 0xf5, 0x17, 0x8c, 0x36, 0x85, 0x91, 0xdd, 0x55, 0xd4, 0x66, - 0xd9, 0xd8, 0xa2, 0xd4, 0x66, 0xb9, 0xa4, 0x19, 0x69, 0x9d, 0x45, 0xf4, 0xf0, 0xcc, 0x10, 0x34, - 0x67, 0x51, 0xb7, 0xec, 0x2e, 0x9a, 0x51, 0xb7, 0xda, 0xc0, 0x34, 0xa3, 0x6e, 0xad, 0x1d, 0x69, - 0x9f, 0x49, 0xb0, 0x51, 0x9a, 0x41, 0x29, 0x8c, 0x2b, 0x0d, 0x47, 0x54, 0xd9, 0x75, 0xb5, 0x47, - 0x39, 0x7b, 0x77, 0xe9, 0xbc, 0xe4, 0xf7, 0x0e, 0xe7, 0x37, 0xc5, 0x9b, 0x9a, 0x9f, 0x1f, 0xc7, - 0x42, 0x4d, 0x22, 0x12, 0x80, 0x6e, 0x1f, 0x6a, 0x3b, 0xa8, 0x75, 0x20, 0x67, 0xb3, 0xa6, 0x29, - 0xc9, 0xc4, 0xb2, 0x36, 0xc1, 0x44, 0x85, 0xd9, 0x1f, 0x43, 0x4f, 0xf5, 0xc1, 0x50, 0x69, 0xad, - 0x95, 0x66, 0xd9, 0x6c, 0x5a, 0x9f, 0xa8, 0x5c, 0x11, 0xee, 0xec, 0x32, 0x39, 0xcb, 0xe8, 0x12, - 0x18, 0x57, 0x7a, 0x69, 0x5a, 0x56, 0xcd, 0x4d, 0xb6, 0x99, 0xfd, 0x55, 0x93, 0x78, 0x23, 0xc4, - 0x6f, 0x71, 0x06, 0xdb, 0x88, 0xcb, 0x27, 0x53, 0x0b, 0x85, 0x7c, 0x6e, 0x3a, 0x68, 0x51, 0xe9, - 0xad, 0xc9, 0x26, 0x8d, 0xe1, 0x04, 0x1b, 0x5b, 0x6f, 0xb3, 0xa6, 0x46, 0x3e, 0xfe, 0x01, 0xe7, - 0xf5, 0x16, 0xba, 0x68, 0xf1, 0x62, 0x16, 0xad, 0xde, 0x31, 0x6e, 0x3a, 0x68, 0x0e, 0x23, 0x9b, - 0xe4, 0x1b, 0xb1, 0xaa, 0x5c, 0x1d, 0x84, 0x6a, 0xac, 0x18, 0x8f, 0x3f, 0x30, 0x1a, 0x91, 0x56, - 0x4b, 0x11, 0x5d, 0x69, 0xe6, 0x55, 0x69, 0x39, 0xce, 0xb6, 0x4c, 0x9e, 0x6a, 0x12, 0x63, 0xce, - 0xf4, 0x12, 0x9a, 0xd5, 0x99, 0xfa, 0x12, 0x87, 0x7b, 0x9f, 0x81, 0x59, 0xec, 0xea, 0xa4, 0xa9, - 0xa1, 0x5e, 0xd6, 0x49, 0x53, 0x53, 0x7d, 0xac, 0x94, 0x27, 0x92, 0x26, 0x5e, 0x0c, 0x1f, 0x0b, - 0x0c, 0x66, 0x21, 0xcf, 0xab, 0x45, 0xf1, 0xa5, 0x25, 0x65, 0x62, 0x25, 0x07, 0x69, 0x2c, 0x22, - 0x95, 0x89, 0xa3, 0x0d, 0xc5, 0x2a, 0xa2, 0xcf, 0x45, 0x2d, 0x89, 0xbe, 0x86, 0x0e, 0xaf, 0xd0, - 0xd0, 0x96, 0x4e, 0x93, 0x75, 0x21, 0x38, 0xdb, 0xae, 0x40, 0xed, 0x30, 0x8e, 0x79, 0x5c, 0x29, - 0xa8, 0xcc, 0x28, 0xe7, 0x30, 0x12, 0x89, 0x99, 0xaa, 0x63, 0xf4, 0xa5, 0xa9, 0x94, 0x59, 0xfa, - 0xd2, 0x54, 0x4b, 0x1e, 0xdb, 0x95, 0x89, 0xdc, 0xec, 0x54, 0xe2, 0xdc, 0x72, 0xae, 0xcd, 0xd7, - 0xf8, 0x3f, 0x10, 0x3e, 0xf9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x70, 0xa5, 0x5c, 0x37, 0xac, - 0x30, 0x00, 0x00, + // 4049 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x3b, 0x4d, 0x6f, 0x1d, 0xc9, + 0x56, 0xee, 0x7b, 0x7d, 0x7d, 0xaf, 0xcf, 0xfd, 0x74, 0xf9, 0x23, 0x37, 0x77, 0x32, 0x33, 0x79, + 0xc5, 0x64, 0x94, 0xf1, 0xcc, 0x38, 0xc1, 0xc3, 0x30, 0x6f, 0x02, 0x19, 0x8d, 0xed, 0xf8, 0x25, + 0x99, 0xf1, 0xb3, 0xa3, 0x76, 0x32, 0x09, 0x4f, 0xf0, 0x5a, 0x7d, 0xbb, 0x2b, 0x76, 0x93, 0x76, + 0xf7, 0x9d, 0xfe, 0xb0, 0x63, 0xd8, 0xa0, 0x27, 0x56, 0xb0, 0x02, 0xc4, 0xfa, 0xb1, 0x42, 0x48, + 0x20, 0xb6, 0xac, 0x90, 0x58, 0xb3, 0x65, 0x81, 0x04, 0x6c, 0x90, 0xf8, 0x05, 0x88, 0x2d, 0x12, + 0xaa, 0xaf, 0xae, 0xaa, 0xee, 0xbe, 0x7e, 0xc9, 0x13, 0xb0, 0xbb, 0x75, 0xea, 0xf4, 0x39, 0x55, + 0xe7, 0x9c, 0x3a, 0x5f, 0x55, 0x17, 0x7a, 0xaf, 0x73, 0x3f, 0x99, 0x79, 0x5b, 0xb3, 0x24, 0xce, + 0x62, 0xb4, 0xc4, 0x47, 0x93, 0x15, 0x37, 0x8a, 0xe2, 0xcc, 0xcd, 0x82, 0x38, 0x4a, 0xf9, 0x14, + 0x5e, 0x87, 0xd5, 0x1d, 0xdf, 0xdf, 0xcb, 0x93, 0x84, 0x44, 0xde, 0xa5, 0x4d, 0xd2, 0x59, 0x1c, + 0xa5, 0x04, 0xff, 0x14, 0x06, 0x3b, 0xbe, 0xff, 0xc4, 0x0d, 0x12, 0x9b, 0x7c, 0x9f, 0x93, 0x34, + 0x43, 0x1f, 0x40, 0x7f, 0xea, 0xa6, 0xc4, 0xf1, 0x04, 0xea, 0xd8, 0xba, 0x69, 0xdd, 0x5e, 0xb6, + 0x4d, 0x20, 0xfa, 0x10, 0x06, 0xdf, 0xe7, 0x71, 0xa6, 0xa1, 0x35, 0x18, 0x5a, 0x09, 0x8a, 0x57, + 0x60, 0x58, 0xd0, 0x17, 0x2c, 0xff, 0xae, 0x01, 0xed, 0x5d, 0x37, 0x74, 0x23, 0x8f, 0x50, 0x66, + 0x59, 0x9c, 0xb9, 0xa1, 0x33, 0xe5, 0x00, 0xc6, 0x6c, 0xd1, 0x36, 0x81, 0xe8, 0x36, 0x0c, 0xbd, + 0x53, 0x37, 0x8a, 0x88, 0xc2, 0x6b, 0x30, 0xbc, 0x32, 0x18, 0xfd, 0x10, 0xae, 0xcd, 0x48, 0xe4, + 0x07, 0xd1, 0x89, 0x53, 0xfe, 0xa2, 0xc9, 0xbe, 0x98, 0x37, 0x8d, 0xee, 0xc1, 0x38, 0x88, 0x5c, + 0x2f, 0x0b, 0xce, 0x49, 0xe5, 0xd3, 0x45, 0xf6, 0xe9, 0xdc, 0x79, 0x2a, 0x8c, 0x0b, 0x37, 0x0c, + 0x49, 0x56, 0x7c, 0xd1, 0x62, 0x5f, 0x94, 0xa0, 0xe8, 0x2b, 0x98, 0xe4, 0x91, 0x17, 0x47, 0x2f, + 0x83, 0xe4, 0x8c, 0xf8, 0x4e, 0xe9, 0x9b, 0x25, 0xf6, 0xcd, 0x15, 0x18, 0xf8, 0xd7, 0x01, 0x76, + 0xdd, 0x48, 0x2a, 0xea, 0x36, 0x0c, 0xa3, 0xd8, 0x27, 0x4e, 0xe0, 0x93, 0x28, 0x0b, 0x5e, 0x06, + 0x24, 0x11, 0xaa, 0x2a, 0x83, 0x71, 0x1f, 0xba, 0xec, 0x3b, 0xa1, 0x80, 0x2f, 0xa0, 0xb5, 0x77, + 0xea, 0x06, 0x11, 0x5a, 0x83, 0x96, 0x47, 0x7f, 0x88, 0xef, 0xf8, 0x00, 0x8d, 0xa1, 0x1d, 0x91, + 0xec, 0x22, 0x4e, 0x5e, 0x09, 0x9d, 0xca, 0x21, 0x9e, 0x41, 0x67, 0x8f, 0x6f, 0x3d, 0x45, 0x1b, + 0xb0, 0xc4, 0xa5, 0xc1, 0x3e, 0xee, 0xdb, 0x62, 0x84, 0x26, 0xd0, 0x91, 0x72, 0x62, 0x9f, 0xf7, + 0xed, 0x62, 0x4c, 0x29, 0x0b, 0xf1, 0x33, 0x6d, 0xf4, 0x6d, 0x39, 0xa4, 0xd4, 0xbc, 0x30, 0x4e, + 0x89, 0xcf, 0x64, 0xdd, 0xb7, 0xc5, 0x08, 0xff, 0xbd, 0x05, 0xab, 0x7b, 0xf4, 0xa7, 0xe0, 0xfb, + 0xd6, 0x7b, 0xa7, 0xeb, 0x29, 0x99, 0x68, 0x31, 0xa6, 0xfb, 0x7f, 0x19, 0x27, 0xc2, 0x36, 0x3a, + 0x36, 0x1f, 0xa0, 0x9b, 0xd0, 0xf5, 0x49, 0x9a, 0x05, 0x11, 0x3b, 0x3f, 0x6c, 0x41, 0xcb, 0xb6, + 0x0e, 0x62, 0x7b, 0x3f, 0x8b, 0xf3, 0x28, 0x13, 0x7a, 0x16, 0x23, 0x34, 0x82, 0xe6, 0x4b, 0x22, + 0x15, 0x49, 0x7f, 0xe2, 0xaf, 0x61, 0xcd, 0x5c, 0x3e, 0x57, 0x01, 0x5d, 0x7f, 0x96, 0xb8, 0x51, + 0x4a, 0x05, 0x13, 0x47, 0x4e, 0xe0, 0xa7, 0x63, 0xeb, 0x66, 0x93, 0xae, 0xbf, 0x04, 0xc6, 0x9f, + 0xc0, 0x60, 0x2f, 0x8e, 0x22, 0xe2, 0x65, 0x72, 0xef, 0x13, 0xe8, 0xb0, 0x4d, 0xe6, 0x49, 0x20, + 0x36, 0x5d, 0x8c, 0xe9, 0x71, 0x2b, 0xb0, 0x85, 0xb6, 0xef, 0xc0, 0xca, 0x5e, 0x42, 0xdc, 0x8c, + 0x1c, 0xc6, 0x3e, 0xd1, 0x68, 0xcc, 0xdc, 0x34, 0xbd, 0x88, 0x13, 0x5f, 0xd2, 0x90, 0x63, 0xfc, + 0xe7, 0x16, 0x20, 0xfd, 0x0b, 0xb1, 0xe4, 0x5f, 0x81, 0x7e, 0x4a, 0x88, 0xef, 0x9c, 0x45, 0xe4, + 0x2c, 0x8e, 0x02, 0x4f, 0x2c, 0xb8, 0x47, 0x81, 0x3f, 0x16, 0x30, 0xf4, 0x11, 0x8c, 0x82, 0x28, + 0xc8, 0x02, 0x37, 0x0c, 0x7e, 0x8f, 0xf8, 0x4e, 0x18, 0xf9, 0xe9, 0xb8, 0xc1, 0x37, 0xa6, 0xc1, + 0x0f, 0x22, 0x3f, 0x45, 0x77, 0x60, 0x55, 0x47, 0xf5, 0xe8, 0xb2, 0x5f, 0x67, 0x42, 0x15, 0x48, + 0x9b, 0xda, 0xe3, 0x33, 0xf8, 0x9f, 0x2d, 0xe8, 0x48, 0xff, 0x65, 0xa8, 0xd5, 0x2a, 0xa9, 0xf5, + 0x3e, 0x74, 0xd3, 0x0b, 0x77, 0xe6, 0x78, 0x61, 0x40, 0xa2, 0x8c, 0x69, 0x7d, 0xb0, 0xfd, 0xce, + 0x96, 0xf0, 0x94, 0x92, 0xc4, 0xd6, 0xf1, 0x85, 0x3b, 0xdb, 0x63, 0x28, 0xb6, 0x8e, 0xcf, 0x7d, + 0xd2, 0x2b, 0x12, 0x39, 0xae, 0xef, 0x27, 0x24, 0x4d, 0xd9, 0x92, 0x96, 0x6d, 0x13, 0x48, 0xcf, + 0xbc, 0x4f, 0xbc, 0xe0, 0xcc, 0x0d, 0x9d, 0x59, 0xe8, 0x7a, 0x24, 0x15, 0x96, 0x5b, 0x82, 0x62, + 0x0c, 0xa0, 0x18, 0xa1, 0x36, 0x34, 0x0f, 0x0e, 0x1f, 0x8c, 0x16, 0x50, 0x17, 0xda, 0x7b, 0x47, + 0x87, 0x87, 0xfb, 0x2f, 0x9e, 0x8e, 0x1a, 0x54, 0xc7, 0x0f, 0xc8, 0x2c, 0x4e, 0x03, 0x5d, 0xc7, + 0xf3, 0xb6, 0x87, 0x3f, 0x86, 0x61, 0x81, 0x2d, 0x74, 0x33, 0x86, 0xb6, 0x5c, 0x2c, 0xc7, 0x96, + 0x43, 0x6a, 0x80, 0x0f, 0x82, 0xd4, 0x8b, 0xcf, 0x49, 0x42, 0xb5, 0x99, 0xbe, 0xbd, 0xf3, 0xf8, + 0x1c, 0xd6, 0x4b, 0x14, 0x04, 0xd3, 0x1b, 0xb0, 0x1c, 0xe5, 0x67, 0x0e, 0xc5, 0x4f, 0x85, 0x13, + 0x50, 0x00, 0xfc, 0x47, 0x16, 0xa0, 0xfd, 0xd7, 0xc4, 0xcb, 0x33, 0x42, 0xf7, 0xaf, 0x6d, 0x2c, + 0x4e, 0x7c, 0x92, 0x38, 0x41, 0x61, 0x78, 0x72, 0xcc, 0xdc, 0x83, 0x1b, 0xb0, 0x29, 0xe1, 0x78, + 0xc4, 0x10, 0x61, 0xe8, 0xcd, 0x08, 0x49, 0x9c, 0x59, 0x3e, 0x75, 0x5e, 0x91, 0x4b, 0xa1, 0x11, + 0x03, 0x46, 0x29, 0x7f, 0x9f, 0xbb, 0x51, 0x16, 0x64, 0x97, 0xc2, 0x61, 0x17, 0x63, 0x7a, 0x06, + 0x1e, 0x92, 0x4c, 0x04, 0x9d, 0x37, 0x91, 0xf1, 0x5f, 0x59, 0x80, 0xf4, 0x2f, 0xc4, 0x96, 0x1f, + 0x40, 0x47, 0xf8, 0x62, 0x7e, 0x5e, 0xbb, 0xdb, 0xb7, 0xa5, 0x59, 0x55, 0xb1, 0xb7, 0xc4, 0x38, + 0xdd, 0x8f, 0xb2, 0xe4, 0xd2, 0x2e, 0xbe, 0x9c, 0x1c, 0x40, 0xdf, 0x98, 0xa2, 0x7e, 0x83, 0xee, + 0x8a, 0x2f, 0x82, 0xfe, 0x44, 0xb7, 0xa0, 0x75, 0xee, 0x86, 0x39, 0x77, 0xa1, 0xdd, 0xed, 0xa1, + 0xe4, 0x22, 0x59, 0xf0, 0xd9, 0x7b, 0x8d, 0x1f, 0x5a, 0x78, 0x04, 0x83, 0x87, 0x24, 0x7b, 0x1c, + 0xbd, 0x8c, 0xc5, 0xc6, 0xf0, 0xbf, 0x34, 0x61, 0x58, 0x80, 0x94, 0x85, 0x9c, 0x93, 0x24, 0xa5, + 0x0e, 0x4d, 0x58, 0x88, 0x18, 0x52, 0xd9, 0x32, 0x95, 0x4b, 0xd9, 0x72, 0xd1, 0x1b, 0x30, 0x84, + 0x60, 0x31, 0x4f, 0x02, 0x7a, 0x12, 0xe8, 0x51, 0x66, 0xbf, 0xa5, 0xfa, 0xa9, 0x0e, 0xa4, 0xed, + 0x2b, 0x40, 0x31, 0xeb, 0x06, 0x49, 0xca, 0xbc, 0xa4, 0x9c, 0xa5, 0x00, 0xf4, 0x31, 0x2c, 0x31, + 0xad, 0xa7, 0xcc, 0x57, 0x76, 0xb7, 0x57, 0xe5, 0xfe, 0x8e, 0x18, 0x74, 0x8f, 0x7a, 0x53, 0x5b, + 0xa0, 0xa0, 0x6d, 0x68, 0x86, 0x91, 0x3f, 0x6e, 0x33, 0x79, 0xdf, 0xd4, 0xe4, 0xad, 0x6f, 0x70, + 0xeb, 0x20, 0xf2, 0xb9, 0x9c, 0x29, 0x32, 0xf5, 0xec, 0x6e, 0x18, 0xb8, 0xe9, 0x78, 0x99, 0x47, + 0x36, 0x36, 0xd0, 0x23, 0x1b, 0x18, 0x91, 0x0d, 0xdd, 0x85, 0x55, 0x99, 0x18, 0x30, 0x57, 0x70, + 0xea, 0xa6, 0xa7, 0x24, 0x1d, 0x77, 0xd9, 0x7e, 0xeb, 0xa6, 0xd0, 0xa7, 0xd0, 0x96, 0x2e, 0xab, + 0x67, 0xee, 0x41, 0xf8, 0x2b, 0xb6, 0x3a, 0x89, 0x33, 0x79, 0x08, 0x1d, 0xb9, 0xc2, 0xb7, 0x50, + 0xf7, 0x41, 0xe4, 0x33, 0x32, 0x9a, 0xba, 0xbf, 0x62, 0x86, 0x49, 0x4f, 0xa2, 0xa6, 0xf2, 0xb7, + 0x38, 0xce, 0x36, 0xac, 0x1a, 0xdf, 0x17, 0xde, 0x7d, 0x98, 0x90, 0x59, 0xce, 0x73, 0xc6, 0x63, + 0x2f, 0x4e, 0x78, 0x5c, 0x5f, 0xb1, 0x41, 0x81, 0x69, 0xdc, 0x9b, 0xd2, 0x38, 0xc6, 0xcf, 0x67, + 0xc7, 0x16, 0x23, 0x7c, 0x0d, 0xd6, 0x0f, 0x82, 0x34, 0x13, 0x9e, 0x35, 0x28, 0xbc, 0x0c, 0xfe, + 0x06, 0x36, 0xca, 0x13, 0x82, 0xdf, 0x5d, 0x00, 0xaf, 0x80, 0x8a, 0xb3, 0x34, 0x2a, 0xbb, 0x68, + 0x5b, 0xc3, 0xc1, 0xff, 0x68, 0xc1, 0x0a, 0x25, 0xc6, 0x4d, 0x44, 0x6e, 0x5c, 0xf3, 0x19, 0x96, + 0xe9, 0x33, 0x3e, 0x87, 0x56, 0x7c, 0x11, 0x91, 0x44, 0xf8, 0xff, 0xf7, 0x0b, 0x99, 0x96, 0x69, + 0x6c, 0x1d, 0x51, 0x34, 0x9b, 0x63, 0x53, 0xcb, 0x09, 0x83, 0xb3, 0x20, 0x13, 0x19, 0x0a, 0x1f, + 0x50, 0xf9, 0x06, 0x91, 0x17, 0xe6, 0x3e, 0x71, 0x98, 0x29, 0x09, 0x77, 0xdf, 0xb1, 0xcb, 0x60, + 0xfc, 0x01, 0xb4, 0x18, 0x3d, 0xd4, 0x81, 0xc5, 0xdd, 0xa3, 0xa7, 0x8f, 0x46, 0x0b, 0xd4, 0xe9, + 0x1f, 0x3d, 0x3f, 0x1c, 0x59, 0x14, 0xf4, 0x64, 0x7f, 0xdf, 0x1e, 0x35, 0xf0, 0xcf, 0x2d, 0x40, + 0xfa, 0x42, 0x84, 0x54, 0xbe, 0x2a, 0xce, 0x05, 0x97, 0xc8, 0x87, 0x75, 0x8b, 0x16, 0x06, 0xcf, + 0x87, 0xdc, 0xe6, 0xc5, 0x57, 0x93, 0xc7, 0xd0, 0xd5, 0xc0, 0x35, 0x86, 0xf6, 0x81, 0x69, 0x68, + 0x03, 0xf3, 0xdc, 0xe9, 0x76, 0x86, 0x60, 0x44, 0x99, 0xd2, 0xcc, 0xbd, 0x50, 0xe7, 0x47, 0x5c, + 0x03, 0x02, 0x26, 0xd6, 0xbc, 0x06, 0x2d, 0x7e, 0xca, 0x79, 0x3e, 0xc0, 0x07, 0xc5, 0xe7, 0x44, + 0xc9, 0x19, 0x7f, 0x21, 0x3e, 0x27, 0xfa, 0x96, 0x31, 0xb4, 0xb8, 0x0b, 0xe1, 0x3b, 0xee, 0xc9, + 0x15, 0x51, 0x2c, 0x9b, 0x4f, 0xe1, 0x7f, 0xb3, 0xa0, 0x2d, 0x8e, 0x02, 0xb5, 0xc1, 0x34, 0x73, + 0xb3, 0x5c, 0x46, 0x3a, 0x31, 0x42, 0x9f, 0x40, 0x47, 0xa4, 0xe5, 0xa9, 0xd8, 0x9c, 0x32, 0x27, + 0x01, 0xb7, 0x0b, 0x0c, 0x74, 0x0b, 0x96, 0x58, 0xb2, 0xcb, 0x5d, 0x5a, 0x77, 0xbb, 0xaf, 0xe1, + 0x06, 0x91, 0x2d, 0x26, 0x69, 0x2a, 0x38, 0x0d, 0x63, 0xef, 0xd5, 0x29, 0x09, 0x4e, 0x4e, 0x33, + 0xe1, 0xe5, 0x74, 0x50, 0xe1, 0x19, 0x5b, 0x9a, 0x67, 0xd4, 0x7c, 0xed, 0x92, 0xe9, 0x6b, 0x0b, + 0xb7, 0xd4, 0xd6, 0xdc, 0x12, 0xfe, 0x06, 0x06, 0xec, 0x3c, 0xaa, 0xa4, 0xb5, 0xec, 0x93, 0xad, + 0x1a, 0x9f, 0x5c, 0xd0, 0x6a, 0xe8, 0xb4, 0xfe, 0xd2, 0x02, 0x74, 0x34, 0x23, 0xd1, 0xff, 0x49, + 0xbe, 0xac, 0xf2, 0xde, 0xa6, 0x91, 0xf7, 0xde, 0x84, 0xee, 0x2c, 0x4f, 0x4f, 0x1d, 0x31, 0xc9, + 0xa3, 0xaf, 0x0e, 0x92, 0x99, 0x71, 0x4b, 0x65, 0xc6, 0xf7, 0x61, 0xd5, 0x58, 0xa7, 0x30, 0x87, + 0x0f, 0x61, 0x60, 0x66, 0xc0, 0x62, 0x9d, 0x25, 0x28, 0xfe, 0x87, 0x06, 0xb4, 0x98, 0xd1, 0x32, + 0xfb, 0x4b, 0x02, 0x51, 0x3a, 0x5a, 0x36, 0x1f, 0x18, 0xd9, 0x40, 0xc3, 0xcc, 0x06, 0x74, 0x9f, + 0xd1, 0x34, 0x7d, 0xc6, 0x00, 0x1a, 0x81, 0x2f, 0x32, 0xfe, 0x46, 0xe0, 0xa3, 0xaf, 0xab, 0x62, + 0x6b, 0x31, 0xdb, 0xda, 0x90, 0xf6, 0x62, 0x2a, 0xae, 0x56, 0x9c, 0x61, 0xec, 0xb9, 0x21, 0x65, + 0xc6, 0x8d, 0xa1, 0x18, 0xa3, 0xf7, 0x00, 0x3c, 0x96, 0x67, 0xfb, 0x8e, 0x9b, 0x31, 0x93, 0x58, + 0xb4, 0x35, 0x08, 0xba, 0x05, 0x8b, 0x69, 0xe0, 0x93, 0x71, 0x87, 0x39, 0xb0, 0x15, 0xe3, 0xac, + 0x1e, 0x07, 0x3e, 0xb1, 0xd9, 0x34, 0x35, 0x96, 0x20, 0x75, 0xe2, 0x8b, 0xc8, 0x61, 0x5e, 0x80, + 0x85, 0xbc, 0x8e, 0x6d, 0xc0, 0xa8, 0x99, 0x9e, 0xc6, 0xa1, 0xcf, 0xc2, 0xde, 0xa2, 0xcd, 0x7e, + 0xe3, 0xbf, 0xb0, 0xa0, 0xc7, 0x68, 0xd9, 0xe4, 0x2c, 0x3e, 0x77, 0x43, 0x43, 0x66, 0xd6, 0x7c, + 0x99, 0x95, 0x72, 0x33, 0x3d, 0xa3, 0x6b, 0x96, 0x32, 0x3a, 0x7d, 0xf7, 0x8b, 0xa5, 0xdd, 0x97, + 0x97, 0xdd, 0xaa, 0x2e, 0x1b, 0x9f, 0xc2, 0x12, 0xf7, 0x4c, 0xe8, 0x53, 0x80, 0x69, 0x7e, 0xe9, + 0x18, 0xde, 0xb1, 0x6f, 0x48, 0xc4, 0xd6, 0x10, 0xd0, 0x1d, 0xe8, 0xa6, 0x24, 0x0c, 0x25, 0x7e, + 0xa3, 0x0e, 0x5f, 0xc7, 0xc0, 0x9f, 0x49, 0xcf, 0xc9, 0x72, 0x0f, 0x2a, 0x2f, 0xea, 0x7a, 0x44, + 0x5a, 0xcb, 0x7e, 0x53, 0x1b, 0x8e, 0x2f, 0x22, 0x51, 0xd4, 0xd2, 0x9f, 0xf8, 0x67, 0x96, 0xf8, + 0xea, 0xd9, 0xcc, 0x77, 0x33, 0x42, 0xc3, 0x38, 0xdf, 0x8b, 0xc5, 0x8c, 0xc4, 0xe4, 0xf7, 0x68, + 0xc1, 0xe6, 0xb3, 0xe8, 0x37, 0xa1, 0xcf, 0x25, 0x94, 0x70, 0xc1, 0x0b, 0x7f, 0xb5, 0x66, 0x2e, + 0x8f, 0xcf, 0x3d, 0x5a, 0xb0, 0x4d, 0xe4, 0xdd, 0x01, 0xf4, 0x38, 0x20, 0x67, 0x4c, 0xf1, 0xbf, + 0x36, 0x60, 0x91, 0x3a, 0xcb, 0xf9, 0x45, 0xc0, 0x1b, 0xa5, 0x78, 0x5f, 0x43, 0x2f, 0x8c, 0x7c, + 0x39, 0x94, 0x7e, 0xf1, 0x86, 0xee, 0x8e, 0x69, 0x3a, 0xf2, 0x24, 0x9f, 0x7e, 0x4b, 0x2e, 0x45, + 0xd8, 0x31, 0xbe, 0xa0, 0xfc, 0x83, 0x68, 0x1a, 0xe7, 0x91, 0x2f, 0x62, 0xa3, 0x1c, 0xaa, 0x10, + 0xd1, 0xd2, 0x42, 0x04, 0xf5, 0x1a, 0xaf, 0x73, 0xdf, 0x31, 0x5d, 0xa5, 0x0e, 0x42, 0x9f, 0xc0, + 0x4a, 0x4a, 0xbc, 0x38, 0xf2, 0x53, 0x5e, 0x1e, 0x7a, 0x19, 0xf1, 0xd9, 0x39, 0xe9, 0xdb, 0xd5, + 0x89, 0xfa, 0x9c, 0x6f, 0x72, 0x1f, 0x86, 0xa5, 0x65, 0xd7, 0x84, 0xc5, 0x35, 0x3d, 0x2c, 0x2e, + 0xeb, 0x61, 0xf0, 0x4f, 0x1b, 0xb0, 0xf2, 0x84, 0x56, 0x72, 0x42, 0x29, 0xdc, 0x9d, 0xfe, 0x6f, + 0xfa, 0x1c, 0xfd, 0xfc, 0x2c, 0x96, 0xce, 0x8f, 0xf4, 0x00, 0xad, 0xab, 0x3d, 0xc0, 0x26, 0x8c, + 0x12, 0xc2, 0xea, 0x4d, 0xa7, 0x20, 0xc5, 0xc5, 0x59, 0x81, 0xd3, 0x4c, 0x37, 0x38, 0x3b, 0x23, + 0x7e, 0xe0, 0x66, 0x14, 0xea, 0x78, 0xb4, 0x9e, 0x08, 0x99, 0x54, 0x3b, 0x76, 0xdd, 0x14, 0x15, + 0xd7, 0x99, 0xfb, 0x9a, 0x79, 0xa1, 0x8e, 0x4d, 0x7f, 0xe2, 0x3f, 0x68, 0x00, 0xd2, 0x85, 0x22, + 0x7c, 0xf7, 0x97, 0xb4, 0xf8, 0xcf, 0x48, 0x12, 0xb9, 0xa1, 0x73, 0xe6, 0x66, 0xde, 0x29, 0x99, + 0x73, 0x52, 0x2b, 0x68, 0xe8, 0x37, 0x60, 0xc0, 0x92, 0xeb, 0x34, 0xf7, 0x3c, 0x92, 0xd2, 0xf4, + 0x8a, 0x1f, 0xd9, 0x22, 0xa9, 0xa6, 0x35, 0xe4, 0x31, 0x9f, 0xb4, 0x4b, 0xa8, 0xe8, 0x0b, 0x9a, + 0xbb, 0x9e, 0xb9, 0x41, 0x44, 0x73, 0x74, 0x7e, 0x00, 0x9b, 0x35, 0x07, 0xd0, 0x2e, 0x63, 0xa1, + 0x2f, 0xa1, 0xcf, 0x48, 0xbd, 0x74, 0x83, 0x30, 0x4f, 0x58, 0x4e, 0x57, 0x61, 0xfa, 0x23, 0x3e, + 0x67, 0x9b, 0x98, 0xf8, 0x3f, 0x2d, 0x18, 0x2a, 0x11, 0xec, 0x9f, 0xd3, 0xe2, 0xfe, 0x16, 0xb4, + 0xd8, 0x7e, 0xe6, 0x1e, 0x7f, 0x36, 0x8b, 0xbe, 0x84, 0x9e, 0xbe, 0x01, 0x71, 0xfa, 0xeb, 0x76, + 0xfa, 0x68, 0xc1, 0x36, 0x50, 0xd1, 0x97, 0x6f, 0xb6, 0xd3, 0x47, 0x0b, 0x75, 0x7b, 0xed, 0xe9, + 0x3b, 0x60, 0xa6, 0x56, 0xbf, 0xd5, 0x82, 0xab, 0x40, 0xdd, 0x6d, 0x43, 0x8b, 0xd0, 0x0d, 0xe2, + 0x18, 0xba, 0x5a, 0x71, 0x33, 0x37, 0x15, 0xd3, 0x1c, 0x51, 0xc3, 0x74, 0x44, 0x5a, 0x66, 0xb4, + 0x58, 0xc9, 0x8c, 0x78, 0x2b, 0xb2, 0xa5, 0xb5, 0x22, 0xf1, 0x67, 0xb0, 0xce, 0xfc, 0x20, 0x51, + 0x7d, 0xeb, 0x5f, 0x5c, 0xbb, 0x8f, 0x61, 0xa3, 0xfc, 0x91, 0x68, 0x85, 0x1d, 0x00, 0xe2, 0x33, + 0xc6, 0x61, 0xbe, 0xaa, 0x25, 0x71, 0xc5, 0x91, 0xc6, 0x9f, 0xc3, 0xaa, 0x41, 0x4d, 0x9c, 0x82, + 0xf7, 0x60, 0x24, 0x51, 0x9c, 0x38, 0x72, 0x58, 0xd8, 0xb5, 0xb4, 0xb0, 0x5b, 0x2c, 0x6f, 0x27, + 0x0c, 0x8d, 0x3a, 0x04, 0xe7, 0x70, 0xad, 0x32, 0x23, 0x88, 0x7e, 0x02, 0x2b, 0xcc, 0xff, 0x13, + 0xbf, 0x38, 0xc9, 0x32, 0xe1, 0xae, 0x4e, 0x50, 0x6c, 0xc1, 0x59, 0xc3, 0xe6, 0x6d, 0xb8, 0xea, + 0x04, 0xfe, 0x14, 0x56, 0x38, 0x5b, 0xfd, 0x16, 0x60, 0x6e, 0x5d, 0x85, 0xd7, 0xa4, 0x10, 0x8d, + 0xa6, 0xfe, 0x1f, 0x36, 0x28, 0x38, 0xcd, 0xe2, 0xc4, 0xe8, 0x33, 0xbe, 0x51, 0xd3, 0x50, 0x6f, + 0x46, 0x36, 0xcc, 0x66, 0x24, 0xfa, 0x16, 0xba, 0x34, 0xc8, 0x4c, 0x5d, 0xef, 0x55, 0x3e, 0x93, + 0x51, 0x69, 0x53, 0x5a, 0x6d, 0x95, 0x23, 0x8d, 0x51, 0xbb, 0x1c, 0x99, 0xc7, 0x28, 0x08, 0x0b, + 0x00, 0xfa, 0x01, 0xbb, 0x2e, 0x71, 0x7c, 0x37, 0x73, 0xa7, 0x6e, 0xca, 0x1b, 0xb5, 0x3d, 0x16, + 0x72, 0x1e, 0x08, 0x90, 0x08, 0x17, 0x3a, 0x85, 0x5f, 0x14, 0x2e, 0x7a, 0x7a, 0xb8, 0x20, 0xd4, + 0x26, 0xb4, 0x35, 0xa9, 0xde, 0x69, 0xc2, 0xc1, 0xa2, 0x27, 0x2a, 0xc4, 0x20, 0x81, 0xac, 0x21, + 0xfa, 0x11, 0xf5, 0xe2, 0x02, 0x49, 0xb6, 0x16, 0x78, 0x9d, 0x3d, 0x94, 0x70, 0xd9, 0x0a, 0x7d, + 0x00, 0xe8, 0x98, 0x64, 0x07, 0xf1, 0xc9, 0x01, 0x39, 0x57, 0x49, 0xfe, 0x16, 0x2c, 0x87, 0xf1, + 0x89, 0x13, 0x52, 0x18, 0x5b, 0xee, 0x40, 0xd5, 0x40, 0x05, 0xae, 0x42, 0xc1, 0xeb, 0xb0, 0x6a, + 0x50, 0x11, 0xaa, 0x5c, 0x81, 0xe1, 0xf1, 0x69, 0x9e, 0xf9, 0xf1, 0x85, 0xbc, 0x6a, 0xa0, 0xd5, + 0x9c, 0x02, 0x09, 0xb4, 0x5f, 0x83, 0x8d, 0xe3, 0x7c, 0x9a, 0x7a, 0x49, 0x30, 0x25, 0x66, 0x4d, + 0x3e, 0x81, 0x0e, 0x79, 0x1d, 0xa4, 0x59, 0x10, 0x9d, 0xb0, 0x65, 0x74, 0xec, 0x62, 0x8c, 0xdf, + 0x87, 0x77, 0x8b, 0xaf, 0xa8, 0xcf, 0x49, 0x77, 0x3c, 0x8f, 0xcc, 0x32, 0xe2, 0x4b, 0x56, 0xf7, + 0x61, 0xdd, 0x44, 0xd0, 0xee, 0xa5, 0x64, 0xad, 0x9d, 0xb9, 0xaf, 0x44, 0x92, 0xd5, 0xb1, 0x4d, + 0x20, 0xfe, 0xef, 0x06, 0xf4, 0xe8, 0x67, 0x92, 0x2c, 0xba, 0x5e, 0x39, 0xdd, 0x6d, 0x36, 0x7e, + 0x6c, 0x66, 0xa7, 0x8d, 0x52, 0x76, 0x7a, 0x65, 0xbc, 0x9e, 0xd7, 0x67, 0x54, 0x79, 0x41, 0x4b, + 0xcf, 0x0b, 0xca, 0xdd, 0xcb, 0xa5, 0x9a, 0xee, 0xe5, 0x06, 0x2c, 0x25, 0xac, 0xb5, 0x24, 0x4a, + 0x43, 0x31, 0xa2, 0xa1, 0x9d, 0x97, 0x50, 0x4e, 0x42, 0x3c, 0x12, 0x9c, 0x53, 0x99, 0x76, 0x18, + 0xd7, 0x0a, 0x9c, 0xd6, 0x4e, 0x02, 0x96, 0x8a, 0x5b, 0x96, 0x65, 0x7e, 0x0d, 0x65, 0x42, 0xd1, + 0x16, 0x20, 0xe9, 0x2c, 0x35, 0xaa, 0xbc, 0x23, 0x56, 0x33, 0x43, 0xd7, 0x50, 0x40, 0x25, 0xe5, + 0x2e, 0x4f, 0x2f, 0xca, 0x70, 0xfc, 0xd7, 0x16, 0x74, 0xb5, 0x58, 0xf2, 0x4b, 0xf6, 0x7b, 0x75, + 0x19, 0x37, 0x4b, 0x32, 0x2e, 0x4b, 0x73, 0xb1, 0x46, 0x9a, 0x1f, 0xc2, 0x40, 0x04, 0x2f, 0x27, + 0x21, 0x6e, 0x1a, 0xcb, 0xb0, 0x52, 0x82, 0xe2, 0xbf, 0x6d, 0xf2, 0xd5, 0x8a, 0x78, 0xfb, 0xff, + 0x6b, 0x2c, 0x4a, 0xe5, 0x2d, 0x43, 0xe5, 0xb7, 0x61, 0x68, 0xa8, 0x96, 0xf8, 0x42, 0xe3, 0x65, + 0x30, 0xcd, 0xa0, 0x95, 0x6a, 0x33, 0xa1, 0x6d, 0x1d, 0x54, 0x11, 0x16, 0xd4, 0x08, 0xeb, 0x26, + 0x2c, 0x26, 0x71, 0x48, 0x98, 0x4a, 0x07, 0xaa, 0x01, 0x63, 0xc7, 0x21, 0xb1, 0xd9, 0x0c, 0x8d, + 0x27, 0x25, 0xb3, 0x20, 0x3e, 0xeb, 0x7a, 0x2e, 0xdb, 0xd5, 0x09, 0x7a, 0x50, 0x75, 0xb3, 0xc8, + 0xc6, 0x7d, 0x7e, 0x7f, 0x62, 0x00, 0x69, 0xf1, 0x9b, 0x38, 0xb3, 0x84, 0x04, 0x67, 0xee, 0x09, + 0x19, 0x0f, 0x18, 0x8a, 0x06, 0x51, 0x47, 0x69, 0xa8, 0x1d, 0x25, 0xfc, 0x5f, 0x0d, 0x68, 0x3d, + 0x4d, 0x5c, 0x9f, 0xd0, 0x0a, 0xef, 0x8c, 0x9e, 0x78, 0x67, 0x7e, 0xc5, 0x65, 0xeb, 0x18, 0xf4, + 0x83, 0x4c, 0xfb, 0xa0, 0x51, 0xfb, 0x81, 0x86, 0xa1, 0xe9, 0xa7, 0x69, 0xe8, 0xe7, 0x2a, 0x9d, + 0x6a, 0x96, 0xd0, 0x32, 0x2d, 0xa1, 0xd8, 0xcf, 0x92, 0xee, 0x1a, 0xa4, 0xec, 0xdb, 0x73, 0x65, + 0x7f, 0x13, 0xba, 0x84, 0x5f, 0xa3, 0xb0, 0x2e, 0x01, 0xb7, 0x04, 0x1d, 0x54, 0x14, 0x09, 0xcb, + 0x57, 0x17, 0x09, 0xf7, 0xa0, 0xe7, 0x51, 0xc3, 0x20, 0xc9, 0xcc, 0x4d, 0x32, 0x6e, 0x0a, 0xf3, + 0x1b, 0x19, 0x06, 0x2e, 0xfe, 0x18, 0x56, 0x99, 0xd4, 0x1f, 0x05, 0x34, 0x0e, 0x5d, 0x6a, 0x65, + 0x10, 0xef, 0x95, 0x5a, 0x5a, 0xaf, 0x14, 0xdf, 0x87, 0x35, 0x13, 0x59, 0x04, 0xc1, 0x5b, 0xb0, + 0x94, 0x51, 0x78, 0xa5, 0x28, 0x60, 0xd8, 0xb6, 0x98, 0xc4, 0x3f, 0xb7, 0xa0, 0x4f, 0x21, 0x41, + 0x74, 0x72, 0x40, 0xe9, 0xa5, 0x54, 0xe0, 0x67, 0xee, 0x6b, 0x87, 0x96, 0xeb, 0xb2, 0x2f, 0x21, + 0xc7, 0x54, 0xe0, 0xf4, 0xf7, 0x34, 0x97, 0xf9, 0x99, 0x1c, 0xf2, 0x94, 0x29, 0x25, 0x09, 0x4b, + 0x8d, 0xf2, 0x8c, 0x17, 0xa6, 0xdc, 0x99, 0x54, 0x27, 0x78, 0x09, 0x25, 0x80, 0x7a, 0x15, 0xbb, + 0x68, 0x57, 0xe0, 0x78, 0x9b, 0x6f, 0xb0, 0x58, 0xe0, 0x9b, 0x24, 0xa5, 0x7f, 0x63, 0xc1, 0x7a, + 0xe9, 0x23, 0x21, 0x96, 0x1d, 0x58, 0x62, 0x72, 0x93, 0x62, 0xf9, 0x48, 0x17, 0x4b, 0x05, 0x7d, + 0x8b, 0x0f, 0x45, 0xdb, 0x97, 0x7f, 0x38, 0x79, 0x02, 0x5d, 0x0d, 0x5c, 0x93, 0xb0, 0x7c, 0x6c, + 0xb6, 0x7d, 0xd7, 0xeb, 0x59, 0x68, 0x79, 0xcc, 0x77, 0xd0, 0x7b, 0x16, 0x4d, 0x7f, 0x89, 0xb7, + 0x06, 0xe8, 0x06, 0x2c, 0x27, 0x44, 0x14, 0xe5, 0x22, 0x7d, 0x51, 0x00, 0x3c, 0x84, 0xbe, 0xa0, + 0xab, 0x6e, 0xa7, 0x9f, 0x45, 0x61, 0xec, 0xbd, 0x7a, 0xd3, 0xdb, 0xe9, 0x9f, 0x00, 0xd2, 0x3f, + 0x50, 0x09, 0x56, 0xce, 0xa0, 0xa5, 0x04, 0x4b, 0x02, 0x59, 0x82, 0xf5, 0x3e, 0x74, 0x75, 0x14, + 0x7e, 0x99, 0x05, 0x0a, 0x01, 0xff, 0xb1, 0x05, 0xc3, 0xe7, 0x41, 0x76, 0xea, 0x27, 0xee, 0xc5, + 0x1b, 0x28, 0xb5, 0xfc, 0x52, 0xa0, 0x71, 0xd5, 0x4b, 0x81, 0x66, 0xf9, 0xa5, 0x80, 0x1b, 0x86, + 0xa2, 0x4f, 0x42, 0x7f, 0xea, 0x1d, 0xd2, 0x3e, 0xef, 0x90, 0xde, 0x83, 0x91, 0x5a, 0xcc, 0xdb, + 0xb5, 0x47, 0x37, 0x6f, 0xc3, 0x72, 0x71, 0xfe, 0x51, 0x1b, 0x9a, 0xbb, 0xcf, 0x7e, 0x6b, 0xb4, + 0x80, 0x3a, 0xb0, 0x78, 0xbc, 0x7f, 0x70, 0xc0, 0x6f, 0x22, 0xd8, 0xe5, 0x44, 0x63, 0x73, 0x13, + 0x16, 0xa9, 0xb7, 0x41, 0xcb, 0xd0, 0x7a, 0xba, 0xf3, 0xed, 0xbe, 0x3d, 0x5a, 0xa0, 0x3f, 0x7f, + 0xcc, 0x7e, 0x5a, 0xa8, 0x07, 0x9d, 0xc7, 0x87, 0x4f, 0xf7, 0xed, 0xc3, 0x9d, 0x83, 0x51, 0x63, + 0xf3, 0x39, 0x74, 0x64, 0xb6, 0x48, 0x91, 0x76, 0x0e, 0xf6, 0xed, 0xa7, 0x1c, 0x7f, 0xdf, 0xb6, + 0x8f, 0x6c, 0x4e, 0xf7, 0xf9, 0x8e, 0x7d, 0x38, 0x6a, 0xd0, 0x5f, 0x8f, 0x0f, 0x7f, 0x74, 0x34, + 0x6a, 0xa2, 0x2e, 0xb4, 0xbf, 0xdb, 0xb7, 0x77, 0x8f, 0x8e, 0xf7, 0x47, 0x8b, 0x14, 0xf7, 0xc1, + 0xfe, 0xee, 0xb3, 0x87, 0xa3, 0x16, 0xe3, 0x68, 0xef, 0xec, 0xed, 0x8f, 0x96, 0xb6, 0xff, 0xdd, + 0x82, 0xf6, 0x8b, 0xdc, 0x7f, 0x1c, 0x05, 0x19, 0xda, 0x07, 0x50, 0xaf, 0x0f, 0xd0, 0xf5, 0xa2, + 0x31, 0x5f, 0x7e, 0xc3, 0x30, 0x99, 0xd4, 0x4d, 0x09, 0xb3, 0x5a, 0x40, 0x8f, 0xa0, 0xab, 0x65, + 0xe2, 0x68, 0x32, 0xbf, 0x64, 0x98, 0xbc, 0x53, 0x3b, 0x57, 0x50, 0xda, 0x07, 0x50, 0x16, 0xa7, + 0x16, 0x54, 0x31, 0x5b, 0xb5, 0xa0, 0xaa, 0x81, 0xe2, 0x85, 0xed, 0x3f, 0x19, 0x43, 0xf3, 0x45, + 0xee, 0xa3, 0x17, 0xd0, 0xd5, 0x1e, 0x62, 0xa1, 0xca, 0xa5, 0x97, 0x5a, 0x4e, 0xdd, 0x7b, 0xad, + 0xc9, 0xcf, 0xfe, 0xe9, 0x3f, 0xfe, 0xac, 0xb1, 0x86, 0x87, 0x77, 0xce, 0x7f, 0xf5, 0x8e, 0xeb, + 0xfb, 0xd2, 0x16, 0xef, 0x59, 0x9b, 0xc8, 0x86, 0xb6, 0x78, 0x6b, 0x85, 0x36, 0x34, 0x1a, 0x5a, + 0x59, 0x37, 0xb9, 0x56, 0x81, 0x0b, 0xba, 0x1b, 0x8c, 0xee, 0x08, 0x77, 0x05, 0x5d, 0x1a, 0xb6, + 0x28, 0xcd, 0x5d, 0x68, 0xee, 0xba, 0x11, 0x42, 0xea, 0x02, 0x5a, 0xfa, 0x84, 0xc9, 0xaa, 0x01, + 0x13, 0x74, 0x10, 0xa3, 0xd3, 0xc3, 0x6d, 0x4a, 0x67, 0xea, 0x46, 0x94, 0x86, 0x07, 0x3d, 0xfd, + 0x11, 0x0c, 0x52, 0x4f, 0x31, 0xaa, 0x2f, 0x7b, 0x26, 0x37, 0xea, 0x27, 0x05, 0xf9, 0x31, 0x23, + 0x8f, 0xf0, 0x88, 0x92, 0x67, 0x6f, 0x84, 0xc4, 0x95, 0x0e, 0xdd, 0xbc, 0x78, 0xf9, 0xa2, 0x36, + 0x6f, 0x3e, 0x9c, 0x51, 0x9b, 0x2f, 0x3f, 0x91, 0x31, 0x36, 0x2f, 0x5c, 0x15, 0x5d, 0xf8, 0x4f, + 0xa1, 0xff, 0x9c, 0xbd, 0xc0, 0x12, 0xef, 0x2d, 0x14, 0x65, 0xf3, 0xb9, 0x86, 0xa2, 0x5c, 0x7a, + 0x98, 0x81, 0x6f, 0x30, 0xca, 0x1b, 0x78, 0x85, 0x52, 0xe6, 0xaf, 0xb9, 0x7c, 0x8e, 0x42, 0xe9, + 0xff, 0x2e, 0xf4, 0x8d, 0xa7, 0x15, 0xa8, 0xd8, 0x7c, 0xdd, 0x9b, 0x8d, 0xc9, 0xbb, 0x73, 0x66, + 0xeb, 0x78, 0xf9, 0x02, 0x85, 0x3d, 0xc6, 0xa0, 0xbc, 0x5e, 0x00, 0xa8, 0x27, 0x0a, 0xca, 0x8a, + 0x2b, 0xcf, 0x22, 0x94, 0x15, 0x57, 0x5f, 0x34, 0xe0, 0x55, 0xc6, 0xa2, 0x8f, 0xba, 0x5c, 0xbb, + 0x9c, 0xd6, 0x01, 0xb4, 0xc5, 0x65, 0xbc, 0x92, 0x8f, 0xf9, 0x22, 0x41, 0xc9, 0xa7, 0x74, 0x6b, + 0x8f, 0x47, 0x8c, 0x20, 0xa0, 0x0e, 0x25, 0x18, 0x50, 0x12, 0xbf, 0x0d, 0x5d, 0xed, 0x7e, 0x1a, + 0xe9, 0xab, 0x29, 0x5d, 0x7a, 0xab, 0x83, 0x52, 0x73, 0xa1, 0x8d, 0xd7, 0x18, 0xe5, 0x01, 0xea, + 0x51, 0xca, 0x54, 0x0a, 0x8c, 0xfa, 0x73, 0x00, 0x75, 0x95, 0xaa, 0xa4, 0x50, 0xb9, 0x13, 0x56, + 0x52, 0xa8, 0xde, 0xbc, 0x4a, 0x1b, 0x47, 0x40, 0x49, 0x8b, 0x0b, 0x87, 0x13, 0x18, 0x98, 0x37, + 0xdd, 0xe8, 0x5d, 0x9d, 0x42, 0xe5, 0x6a, 0x7c, 0xf2, 0xde, 0xbc, 0x69, 0xd3, 0x26, 0xd1, 0x80, + 0xd9, 0xa4, 0x22, 0x7b, 0x0c, 0xcb, 0xc5, 0x1d, 0x2c, 0x1a, 0xeb, 0x44, 0xf4, 0xab, 0xda, 0xc9, + 0xf5, 0x9a, 0x19, 0x59, 0xdf, 0x33, 0xca, 0x5d, 0xb4, 0x4c, 0x29, 0xf3, 0x56, 0xbc, 0x24, 0xca, + 0x9e, 0x6e, 0x98, 0x44, 0xb5, 0x0b, 0xdc, 0x12, 0x51, 0xfd, 0x1a, 0xb7, 0x44, 0x94, 0xd1, 0x71, + 0xa0, 0xab, 0xdd, 0xf0, 0x29, 0x4d, 0x56, 0xaf, 0x27, 0x95, 0x26, 0x6b, 0xae, 0x04, 0xf1, 0x35, + 0x46, 0x7a, 0x85, 0xbb, 0xbc, 0x78, 0x46, 0x22, 0x79, 0xe4, 0x7f, 0x07, 0x40, 0xb5, 0x60, 0x95, + 0x32, 0x2b, 0xed, 0x7a, 0x65, 0x7e, 0xa5, 0x8e, 0x2d, 0xbe, 0xce, 0x48, 0xaf, 0x62, 0x26, 0x64, + 0xd6, 0x28, 0x67, 0xea, 0xbc, 0x67, 0x6d, 0xde, 0xb5, 0xd0, 0x4b, 0x18, 0x28, 0xfc, 0xe3, 0xcb, + 0xc8, 0xbb, 0x8a, 0xc5, 0xa4, 0x6e, 0x4a, 0x6c, 0xe0, 0x5d, 0xc6, 0xe5, 0x1a, 0x46, 0x26, 0x97, + 0xf4, 0x32, 0xf2, 0xe8, 0xc9, 0xfc, 0x09, 0x74, 0xb5, 0x87, 0x52, 0x4a, 0x4e, 0xd5, 0xd7, 0x53, + 0x93, 0xba, 0x26, 0xb1, 0x19, 0x12, 0x44, 0x61, 0x90, 0x5e, 0xb8, 0x33, 0x4a, 0x3b, 0x82, 0x81, + 0xd9, 0x0b, 0x55, 0x66, 0x59, 0xdb, 0x58, 0x55, 0x66, 0x39, 0xa7, 0x85, 0x6a, 0xec, 0x85, 0x77, + 0x1e, 0xf5, 0x10, 0x34, 0xa5, 0x51, 0xb7, 0xe8, 0x89, 0xea, 0x51, 0xb7, 0xdc, 0x76, 0xd5, 0xa3, + 0x6e, 0xa5, 0x89, 0x6a, 0xee, 0x89, 0xb3, 0x91, 0x9a, 0x41, 0x09, 0x0c, 0x4b, 0x6d, 0x52, 0x54, + 0x5a, 0x75, 0xb9, 0xb3, 0x3a, 0x79, 0x7f, 0xee, 0xbc, 0xe0, 0xf7, 0x1e, 0xe3, 0x37, 0xc6, 0xab, + 0x8a, 0x9f, 0x1b, 0x86, 0x5c, 0x4d, 0x3c, 0x12, 0x80, 0x6a, 0x7a, 0x2a, 0x3b, 0xa8, 0xf4, 0x4d, + 0x27, 0x93, 0xba, 0x29, 0xc1, 0xc4, 0xb0, 0x36, 0xce, 0x44, 0x86, 0xd9, 0x29, 0x74, 0xb5, 0x56, + 0x9c, 0x92, 0x5b, 0xb5, 0xcb, 0xa7, 0xe4, 0x56, 0xd7, 0xbb, 0x33, 0xe4, 0x96, 0x92, 0x2c, 0x8c, + 0x4f, 0x58, 0xaf, 0x8f, 0xf2, 0xf8, 0x0e, 0x3a, 0xb2, 0x89, 0x87, 0x8a, 0x13, 0x51, 0xea, 0xf4, + 0x4d, 0xc6, 0xd5, 0x89, 0xd2, 0x31, 0x64, 0x0e, 0x35, 0x15, 0xb3, 0x94, 0x2e, 0x81, 0x61, 0xa9, + 0x11, 0xa8, 0xf4, 0x51, 0xdf, 0x21, 0x9c, 0x98, 0xef, 0xbd, 0xf8, 0xed, 0x29, 0x7e, 0x87, 0x31, + 0x58, 0x47, 0x4c, 0x07, 0xa9, 0xfc, 0x90, 0xeb, 0xe0, 0xae, 0x85, 0x66, 0xa5, 0xc6, 0xa0, 0xe8, + 0x30, 0x69, 0x8e, 0xb6, 0xb6, 0x6f, 0x38, 0xa9, 0xbb, 0xe2, 0xc0, 0x3f, 0x60, 0xbc, 0xde, 0x41, + 0xd7, 0x0d, 0x5e, 0xf4, 0xd4, 0xc8, 0x1b, 0x9e, 0xbb, 0x16, 0x9a, 0xc2, 0xc0, 0x24, 0xf9, 0x56, + 0xac, 0x4a, 0xc7, 0x13, 0xa1, 0x0a, 0x2b, 0xca, 0xe3, 0xf7, 0xb5, 0x2e, 0xaa, 0xd1, 0x0f, 0x45, + 0xb7, 0xea, 0x79, 0x95, 0xfa, 0xa5, 0x93, 0x35, 0x9d, 0xa7, 0x9c, 0xc4, 0x98, 0x31, 0xbd, 0x81, + 0x26, 0x55, 0xa6, 0xae, 0xc0, 0x61, 0x1e, 0xae, 0xa7, 0x57, 0xea, 0x2a, 0x31, 0xab, 0x29, 0xf6, + 0x55, 0x62, 0x56, 0x57, 0xdc, 0x4b, 0xe5, 0xf1, 0xc4, 0x8c, 0x55, 0xf2, 0xa7, 0x1c, 0x83, 0x5a, + 0xc8, 0x49, 0xb9, 0xa2, 0xbf, 0x31, 0xa7, 0xc6, 0x2d, 0xe5, 0x39, 0xb5, 0x15, 0xb0, 0x3c, 0x46, + 0x68, 0x45, 0xb2, 0x0a, 0xa2, 0x13, 0x5e, 0x08, 0xa3, 0x6f, 0xa0, 0xc5, 0xca, 0x4b, 0xb4, 0xa6, + 0x52, 0x71, 0x55, 0xc5, 0x4e, 0xd6, 0x4b, 0x50, 0x33, 0x55, 0xc0, 0x2c, 0x76, 0xe5, 0x91, 0xc8, + 0x5a, 0xa7, 0x30, 0xe0, 0xc9, 0x9f, 0x2c, 0xc2, 0xd4, 0xa1, 0x29, 0xd5, 0x88, 0xea, 0xd0, 0x94, + 0xeb, 0x35, 0xd3, 0x5d, 0xf2, 0xfc, 0xef, 0x42, 0xe0, 0xdc, 0xb3, 0x36, 0xa7, 0x4b, 0xec, 0xbf, + 0x19, 0x9f, 0xfd, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7d, 0xb7, 0x3a, 0x7b, 0xc6, 0x31, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -5014,6 +5135,9 @@ type XudClient interface { // is no longer supported so that they will know to stop sending orders for it. // shell: xucli removepair RemovePair(ctx context.Context, in *RemovePairRequest, opts ...grpc.CallOption) (*RemovePairResponse, error) + // Set the logging level. + // shell: xucli loglevel + SetLogLevel(ctx context.Context, in *SetLogLevelRequest, opts ...grpc.CallOption) (*SetLogLevelResponse, error) // Begin gracefully shutting down xud. // shell: xucli shutdown Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) @@ -5279,6 +5403,15 @@ func (c *xudClient) RemovePair(ctx context.Context, in *RemovePairRequest, opts return out, nil } +func (c *xudClient) SetLogLevel(ctx context.Context, in *SetLogLevelRequest, opts ...grpc.CallOption) (*SetLogLevelResponse, error) { + out := new(SetLogLevelResponse) + err := c.cc.Invoke(ctx, "/xudrpc.Xud/SetLogLevel", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *xudClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) { out := new(ShutdownResponse) err := c.cc.Invoke(ctx, "/xudrpc.Xud/Shutdown", in, out, opts...) @@ -5538,6 +5671,9 @@ type XudServer interface { // is no longer supported so that they will know to stop sending orders for it. // shell: xucli removepair RemovePair(context.Context, *RemovePairRequest) (*RemovePairResponse, error) + // Set the logging level. + // shell: xucli loglevel + SetLogLevel(context.Context, *SetLogLevelRequest) (*SetLogLevelResponse, error) // Begin gracefully shutting down xud. // shell: xucli shutdown Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error) @@ -5977,6 +6113,24 @@ func _Xud_RemovePair_Handler(srv interface{}, ctx context.Context, dec func(inte return interceptor(ctx, in, info, handler) } +func _Xud_SetLogLevel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetLogLevelRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(XudServer).SetLogLevel(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/xudrpc.Xud/SetLogLevel", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(XudServer).SetLogLevel(ctx, req.(*SetLogLevelRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Xud_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ShutdownRequest) if err := dec(in); err != nil { @@ -6239,6 +6393,10 @@ var _Xud_serviceDesc = grpc.ServiceDesc{ MethodName: "RemovePair", Handler: _Xud_RemovePair_Handler, }, + { + MethodName: "SetLogLevel", + Handler: _Xud_SetLogLevel_Handler, + }, { MethodName: "Shutdown", Handler: _Xud_Shutdown_Handler,